From 759fe58877ac75a9157e831cc5e54aaa70250223 Mon Sep 17 00:00:00 2001 From: Jatin Bhateja Date: Thu, 19 Feb 2026 06:23:46 +0000 Subject: [PATCH 01/63] 8376186: [VectorAPI] Nomenclature change for concrete vector classes Reviewed-by: liach, psandoz --- .../jdk/incubator/vector/ByteVector.java | 80 +- ...{Byte128Vector.java => ByteVector128.java} | 386 ++++---- ...{Byte256Vector.java => ByteVector256.java} | 386 ++++---- ...{Byte512Vector.java => ByteVector512.java} | 386 ++++---- .../{Byte64Vector.java => ByteVector64.java} | 386 ++++---- ...{ByteMaxVector.java => ByteVectorMax.java} | 386 ++++---- .../jdk/incubator/vector/DoubleVector.java | 96 +- ...ble128Vector.java => DoubleVector128.java} | 378 ++++---- ...ble256Vector.java => DoubleVector256.java} | 378 ++++---- ...ble512Vector.java => DoubleVector512.java} | 378 ++++---- ...ouble64Vector.java => DoubleVector64.java} | 378 ++++---- ...bleMaxVector.java => DoubleVectorMax.java} | 378 ++++---- .../jdk/incubator/vector/FloatVector.java | 80 +- ...loat128Vector.java => FloatVector128.java} | 378 ++++---- ...loat256Vector.java => FloatVector256.java} | 378 ++++---- ...loat512Vector.java => FloatVector512.java} | 378 ++++---- ...{Float64Vector.java => FloatVector64.java} | 378 ++++---- ...loatMaxVector.java => FloatVectorMax.java} | 378 ++++---- .../jdk/incubator/vector/IntVector.java | 80 +- .../{Int128Vector.java => IntVector128.java} | 384 ++++---- .../{Int256Vector.java => IntVector256.java} | 384 ++++---- .../{Int512Vector.java => IntVector512.java} | 384 ++++---- .../{Int64Vector.java => IntVector64.java} | 384 ++++---- .../{IntMaxVector.java => IntVectorMax.java} | 386 ++++---- .../jdk/incubator/vector/LongVector.java | 96 +- ...{Long128Vector.java => LongVector128.java} | 376 ++++---- ...{Long256Vector.java => LongVector256.java} | 376 ++++---- ...{Long512Vector.java => LongVector512.java} | 376 ++++---- .../{Long64Vector.java => LongVector64.java} | 376 ++++---- ...{LongMaxVector.java => LongVectorMax.java} | 376 ++++---- .../jdk/incubator/vector/ShortVector.java | 80 +- ...hort128Vector.java => ShortVector128.java} | 386 ++++---- ...hort256Vector.java => ShortVector256.java} | 386 ++++---- ...hort512Vector.java => ShortVector512.java} | 386 ++++---- ...{Short64Vector.java => ShortVector64.java} | 386 ++++---- ...hortMaxVector.java => ShortVectorMax.java} | 386 ++++---- .../incubator/vector/VectorMathLibrary.java | 8 +- .../incubator/vector/X-Vector.java.template | 96 +- .../vector/X-VectorBits.java.template | 6 +- .../classes/jdk/incubator/vector/gen-src.sh | 16 +- ....java => ByteVector128LoadStoreTests.java} | 4 +- ...ctorTests.java => ByteVector128Tests.java} | 872 ++++++++--------- ....java => ByteVector256LoadStoreTests.java} | 4 +- ...ctorTests.java => ByteVector256Tests.java} | 872 ++++++++--------- ....java => ByteVector512LoadStoreTests.java} | 4 +- ...ctorTests.java => ByteVector512Tests.java} | 872 ++++++++--------- ...s.java => ByteVector64LoadStoreTests.java} | 4 +- ...ectorTests.java => ByteVector64Tests.java} | 872 ++++++++--------- ....java => ByteVectorMaxLoadStoreTests.java} | 4 +- ...ctorTests.java => ByteVectorMaxTests.java} | 874 ++++++++--------- ...ava => DoubleVector128LoadStoreTests.java} | 4 +- ...orTests.java => DoubleVector128Tests.java} | 588 ++++++------ ...ava => DoubleVector256LoadStoreTests.java} | 4 +- ...orTests.java => DoubleVector256Tests.java} | 588 ++++++------ ...ava => DoubleVector512LoadStoreTests.java} | 4 +- ...orTests.java => DoubleVector512Tests.java} | 588 ++++++------ ...java => DoubleVector64LoadStoreTests.java} | 4 +- ...torTests.java => DoubleVector64Tests.java} | 588 ++++++------ ...ava => DoubleVectorMaxLoadStoreTests.java} | 4 +- ...orTests.java => DoubleVectorMaxTests.java} | 588 ++++++------ ...java => FloatVector128LoadStoreTests.java} | 4 +- ...torTests.java => FloatVector128Tests.java} | 590 ++++++------ ...java => FloatVector256LoadStoreTests.java} | 4 +- ...torTests.java => FloatVector256Tests.java} | 590 ++++++------ ...java => FloatVector512LoadStoreTests.java} | 4 +- ...torTests.java => FloatVector512Tests.java} | 590 ++++++------ ....java => FloatVector64LoadStoreTests.java} | 4 +- ...ctorTests.java => FloatVector64Tests.java} | 590 ++++++------ ...java => FloatVectorMaxLoadStoreTests.java} | 4 +- ...torTests.java => FloatVectorMaxTests.java} | 590 ++++++------ ...s.java => IntVector128LoadStoreTests.java} | 4 +- ...ectorTests.java => IntVector128Tests.java} | 886 +++++++++--------- ...s.java => IntVector256LoadStoreTests.java} | 4 +- ...ectorTests.java => IntVector256Tests.java} | 886 +++++++++--------- ...s.java => IntVector512LoadStoreTests.java} | 4 +- ...ectorTests.java => IntVector512Tests.java} | 886 +++++++++--------- ...ts.java => IntVector64LoadStoreTests.java} | 4 +- ...VectorTests.java => IntVector64Tests.java} | 886 +++++++++--------- ...s.java => IntVectorMaxLoadStoreTests.java} | 4 +- ...ectorTests.java => IntVectorMaxTests.java} | 886 +++++++++--------- ....java => LongVector128LoadStoreTests.java} | 4 +- ...ctorTests.java => LongVector128Tests.java} | 872 ++++++++--------- ....java => LongVector256LoadStoreTests.java} | 4 +- ...ctorTests.java => LongVector256Tests.java} | 872 ++++++++--------- ....java => LongVector512LoadStoreTests.java} | 4 +- ...ctorTests.java => LongVector512Tests.java} | 872 ++++++++--------- ...s.java => LongVector64LoadStoreTests.java} | 4 +- ...ectorTests.java => LongVector64Tests.java} | 872 ++++++++--------- ....java => LongVectorMaxLoadStoreTests.java} | 4 +- ...ctorTests.java => LongVectorMaxTests.java} | 872 ++++++++--------- ...java => ShortVector128LoadStoreTests.java} | 4 +- ...torTests.java => ShortVector128Tests.java} | 870 ++++++++--------- ...java => ShortVector256LoadStoreTests.java} | 4 +- ...torTests.java => ShortVector256Tests.java} | 870 ++++++++--------- ...java => ShortVector512LoadStoreTests.java} | 4 +- ...torTests.java => ShortVector512Tests.java} | 870 ++++++++--------- ....java => ShortVector64LoadStoreTests.java} | 4 +- ...ctorTests.java => ShortVector64Tests.java} | 870 ++++++++--------- ...java => ShortVectorMaxLoadStoreTests.java} | 4 +- ...torTests.java => ShortVectorMaxTests.java} | 870 ++++++++--------- test/jdk/jdk/incubator/vector/gen-tests.sh | 27 +- 101 files changed, 17809 insertions(+), 17810 deletions(-) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Byte128Vector.java => ByteVector128.java} (68%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Byte256Vector.java => ByteVector256.java} (69%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Byte512Vector.java => ByteVector512.java} (71%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Byte64Vector.java => ByteVector64.java} (67%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{ByteMaxVector.java => ByteVectorMax.java} (67%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Double128Vector.java => DoubleVector128.java} (67%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Double256Vector.java => DoubleVector256.java} (67%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Double512Vector.java => DoubleVector512.java} (68%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Double64Vector.java => DoubleVector64.java} (67%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{DoubleMaxVector.java => DoubleVectorMax.java} (68%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Float128Vector.java => FloatVector128.java} (65%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Float256Vector.java => FloatVector256.java} (66%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Float512Vector.java => FloatVector512.java} (66%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Float64Vector.java => FloatVector64.java} (65%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{FloatMaxVector.java => FloatVectorMax.java} (65%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Int128Vector.java => IntVector128.java} (66%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Int256Vector.java => IntVector256.java} (66%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Int512Vector.java => IntVector512.java} (67%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Int64Vector.java => IntVector64.java} (66%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{IntMaxVector.java => IntVectorMax.java} (65%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Long128Vector.java => LongVector128.java} (68%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Long256Vector.java => LongVector256.java} (68%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Long512Vector.java => LongVector512.java} (68%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Long64Vector.java => LongVector64.java} (68%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{LongMaxVector.java => LongVectorMax.java} (68%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Short128Vector.java => ShortVector128.java} (66%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Short256Vector.java => ShortVector256.java} (67%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Short512Vector.java => ShortVector512.java} (69%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{Short64Vector.java => ShortVector64.java} (66%) rename src/jdk.incubator.vector/share/classes/jdk/incubator/vector/{ShortMaxVector.java => ShortVectorMax.java} (66%) rename test/jdk/jdk/incubator/vector/{Byte128VectorLoadStoreTests.java => ByteVector128LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Byte128VectorTests.java => ByteVector128Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Byte256VectorLoadStoreTests.java => ByteVector256LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Byte256VectorTests.java => ByteVector256Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Byte512VectorLoadStoreTests.java => ByteVector512LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Byte512VectorTests.java => ByteVector512Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Byte64VectorLoadStoreTests.java => ByteVector64LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Byte64VectorTests.java => ByteVector64Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{ByteMaxVectorLoadStoreTests.java => ByteVectorMaxLoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{ByteMaxVectorTests.java => ByteVectorMaxTests.java} (90%) rename test/jdk/jdk/incubator/vector/{Double128VectorLoadStoreTests.java => DoubleVector128LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Double128VectorTests.java => DoubleVector128Tests.java} (91%) rename test/jdk/jdk/incubator/vector/{Double256VectorLoadStoreTests.java => DoubleVector256LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Double256VectorTests.java => DoubleVector256Tests.java} (91%) rename test/jdk/jdk/incubator/vector/{Double512VectorLoadStoreTests.java => DoubleVector512LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Double512VectorTests.java => DoubleVector512Tests.java} (91%) rename test/jdk/jdk/incubator/vector/{Double64VectorLoadStoreTests.java => DoubleVector64LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Double64VectorTests.java => DoubleVector64Tests.java} (91%) rename test/jdk/jdk/incubator/vector/{DoubleMaxVectorLoadStoreTests.java => DoubleVectorMaxLoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{DoubleMaxVectorTests.java => DoubleVectorMaxTests.java} (91%) rename test/jdk/jdk/incubator/vector/{Float128VectorLoadStoreTests.java => FloatVector128LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Float128VectorTests.java => FloatVector128Tests.java} (91%) rename test/jdk/jdk/incubator/vector/{Float256VectorLoadStoreTests.java => FloatVector256LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Float256VectorTests.java => FloatVector256Tests.java} (91%) rename test/jdk/jdk/incubator/vector/{Float512VectorLoadStoreTests.java => FloatVector512LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Float512VectorTests.java => FloatVector512Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Float64VectorLoadStoreTests.java => FloatVector64LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Float64VectorTests.java => FloatVector64Tests.java} (91%) rename test/jdk/jdk/incubator/vector/{FloatMaxVectorLoadStoreTests.java => FloatVectorMaxLoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{FloatMaxVectorTests.java => FloatVectorMaxTests.java} (90%) rename test/jdk/jdk/incubator/vector/{Int128VectorLoadStoreTests.java => IntVector128LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Int128VectorTests.java => IntVector128Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Int256VectorLoadStoreTests.java => IntVector256LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Int256VectorTests.java => IntVector256Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Int512VectorLoadStoreTests.java => IntVector512LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Int512VectorTests.java => IntVector512Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Int64VectorLoadStoreTests.java => IntVector64LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Int64VectorTests.java => IntVector64Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{IntMaxVectorLoadStoreTests.java => IntVectorMaxLoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{IntMaxVectorTests.java => IntVectorMaxTests.java} (90%) rename test/jdk/jdk/incubator/vector/{Long128VectorLoadStoreTests.java => LongVector128LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Long128VectorTests.java => LongVector128Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Long256VectorLoadStoreTests.java => LongVector256LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Long256VectorTests.java => LongVector256Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Long512VectorLoadStoreTests.java => LongVector512LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Long512VectorTests.java => LongVector512Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Long64VectorLoadStoreTests.java => LongVector64LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Long64VectorTests.java => LongVector64Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{LongMaxVectorLoadStoreTests.java => LongVectorMaxLoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{LongMaxVectorTests.java => LongVectorMaxTests.java} (90%) rename test/jdk/jdk/incubator/vector/{Short128VectorLoadStoreTests.java => ShortVector128LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Short128VectorTests.java => ShortVector128Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Short256VectorLoadStoreTests.java => ShortVector256LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Short256VectorTests.java => ShortVector256Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Short512VectorLoadStoreTests.java => ShortVector512LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Short512VectorTests.java => ShortVector512Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{Short64VectorLoadStoreTests.java => ShortVector64LoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{Short64VectorTests.java => ShortVector64Tests.java} (90%) rename test/jdk/jdk/incubator/vector/{ShortMaxVectorLoadStoreTests.java => ShortVectorMaxLoadStoreTests.java} (99%) rename test/jdk/jdk/incubator/vector/{ShortMaxVectorTests.java => ShortVectorMaxTests.java} (90%) diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java index 36609807774..846032cb5c6 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java @@ -84,8 +84,8 @@ public abstract class ByteVector extends AbstractVector { // The various shape-specific subclasses // also specialize them by wrapping // them in a call like this: - // return (Byte128Vector) - // super.bOp((Byte128Vector) o); + // return (ByteVector128) + // super.bOp((ByteVector128) o); // The purpose of that is to forcibly inline // the generic definition from this file // into a sharply-typed and size-specific @@ -4474,13 +4474,13 @@ public abstract class ByteVector extends AbstractVector { @Override @ForceInline public final ByteVector zero() { - if ((Class) vectorType() == ByteMaxVector.class) - return ByteMaxVector.ZERO; + if ((Class) vectorType() == ByteVectorMax.class) + return ByteVectorMax.ZERO; switch (vectorBitSize()) { - case 64: return Byte64Vector.ZERO; - case 128: return Byte128Vector.ZERO; - case 256: return Byte256Vector.ZERO; - case 512: return Byte512Vector.ZERO; + case 64: return ByteVector64.ZERO; + case 128: return ByteVector128.ZERO; + case 256: return ByteVector256.ZERO; + case 512: return ByteVector512.ZERO; } throw new AssertionError(); } @@ -4488,13 +4488,13 @@ public abstract class ByteVector extends AbstractVector { @Override @ForceInline public final ByteVector iota() { - if ((Class) vectorType() == ByteMaxVector.class) - return ByteMaxVector.IOTA; + if ((Class) vectorType() == ByteVectorMax.class) + return ByteVectorMax.IOTA; switch (vectorBitSize()) { - case 64: return Byte64Vector.IOTA; - case 128: return Byte128Vector.IOTA; - case 256: return Byte256Vector.IOTA; - case 512: return Byte512Vector.IOTA; + case 64: return ByteVector64.IOTA; + case 128: return ByteVector128.IOTA; + case 256: return ByteVector256.IOTA; + case 512: return ByteVector512.IOTA; } throw new AssertionError(); } @@ -4503,13 +4503,13 @@ public abstract class ByteVector extends AbstractVector { @Override @ForceInline public final VectorMask maskAll(boolean bit) { - if ((Class) vectorType() == ByteMaxVector.class) - return ByteMaxVector.ByteMaxMask.maskAll(bit); + if ((Class) vectorType() == ByteVectorMax.class) + return ByteVectorMax.ByteMaskMax.maskAll(bit); switch (vectorBitSize()) { - case 64: return Byte64Vector.Byte64Mask.maskAll(bit); - case 128: return Byte128Vector.Byte128Mask.maskAll(bit); - case 256: return Byte256Vector.Byte256Mask.maskAll(bit); - case 512: return Byte512Vector.Byte512Mask.maskAll(bit); + case 64: return ByteVector64.ByteMask64.maskAll(bit); + case 128: return ByteVector128.ByteMask128.maskAll(bit); + case 256: return ByteVector256.ByteMask256.maskAll(bit); + case 512: return ByteVector512.ByteMask512.maskAll(bit); } throw new AssertionError(); } @@ -4537,42 +4537,42 @@ public abstract class ByteVector extends AbstractVector { /** Species representing {@link ByteVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ public static final VectorSpecies SPECIES_64 = new ByteSpecies(VectorShape.S_64_BIT, - Byte64Vector.class, - Byte64Vector.Byte64Mask.class, - Byte64Vector.Byte64Shuffle.class, - Byte64Vector::new); + ByteVector64.class, + ByteVector64.ByteMask64.class, + ByteVector64.ByteShuffle64.class, + ByteVector64::new); /** Species representing {@link ByteVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ public static final VectorSpecies SPECIES_128 = new ByteSpecies(VectorShape.S_128_BIT, - Byte128Vector.class, - Byte128Vector.Byte128Mask.class, - Byte128Vector.Byte128Shuffle.class, - Byte128Vector::new); + ByteVector128.class, + ByteVector128.ByteMask128.class, + ByteVector128.ByteShuffle128.class, + ByteVector128::new); /** Species representing {@link ByteVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ public static final VectorSpecies SPECIES_256 = new ByteSpecies(VectorShape.S_256_BIT, - Byte256Vector.class, - Byte256Vector.Byte256Mask.class, - Byte256Vector.Byte256Shuffle.class, - Byte256Vector::new); + ByteVector256.class, + ByteVector256.ByteMask256.class, + ByteVector256.ByteShuffle256.class, + ByteVector256::new); /** Species representing {@link ByteVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ public static final VectorSpecies SPECIES_512 = new ByteSpecies(VectorShape.S_512_BIT, - Byte512Vector.class, - Byte512Vector.Byte512Mask.class, - Byte512Vector.Byte512Shuffle.class, - Byte512Vector::new); + ByteVector512.class, + ByteVector512.ByteMask512.class, + ByteVector512.ByteShuffle512.class, + ByteVector512::new); /** Species representing {@link ByteVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ public static final VectorSpecies SPECIES_MAX = new ByteSpecies(VectorShape.S_Max_BIT, - ByteMaxVector.class, - ByteMaxVector.ByteMaxMask.class, - ByteMaxVector.ByteMaxShuffle.class, - ByteMaxVector::new); + ByteVectorMax.class, + ByteVectorMax.ByteMaskMax.class, + ByteVectorMax.ByteShuffleMax.class, + ByteVectorMax::new); /** * Preferred species for {@link ByteVector}s. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector128.java similarity index 68% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector128.java index 0b710938ede..396165cef5e 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector128.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Byte128Vector extends ByteVector { +final class ByteVector128 extends ByteVector { static final ByteSpecies VSPECIES = (ByteSpecies) ByteVector.SPECIES_128; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Byte128Vector.class; + static final Class VCLASS = ByteVector128.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Byte128Vector extends ByteVector { static final Class ETYPE = byte.class; // used by the JVM - Byte128Vector(byte[] v) { + ByteVector128(byte[] v) { super(v); } - // For compatibility as Byte128Vector::new, + // For compatibility as ByteVector128::new, // stored into species.vectorFactory. - Byte128Vector(Object v) { + ByteVector128(Object v) { this((byte[]) v); } - static final Byte128Vector ZERO = new Byte128Vector(new byte[VLENGTH]); - static final Byte128Vector IOTA = new Byte128Vector(VSPECIES.iotaArray()); + static final ByteVector128 ZERO = new ByteVector128(new byte[VLENGTH]); + static final ByteVector128 IOTA = new ByteVector128(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Byte128Vector extends ByteVector { @Override @ForceInline - public final Byte128Vector broadcast(byte e) { - return (Byte128Vector) super.broadcastTemplate(e); // specialize + public final ByteVector128 broadcast(byte e) { + return (ByteVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Byte128Vector broadcast(long e) { - return (Byte128Vector) super.broadcastTemplate(e); // specialize + public final ByteVector128 broadcast(long e) { + return (ByteVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Byte128Mask maskFromArray(boolean[] bits) { - return new Byte128Mask(bits); + ByteMask128 maskFromArray(boolean[] bits) { + return new ByteMask128(bits); } @Override @ForceInline - Byte128Shuffle iotaShuffle() { return Byte128Shuffle.IOTA; } + ByteShuffle128 iotaShuffle() { return ByteShuffle128.IOTA; } @Override @ForceInline - Byte128Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Byte128Shuffle) iotaShuffleTemplate((byte) start, (byte) step, wrap); + ByteShuffle128 iotaShuffle(int start, int step, boolean wrap) { + return (ByteShuffle128) iotaShuffleTemplate((byte) start, (byte) step, wrap); } @Override @ForceInline - Byte128Shuffle shuffleFromArray(int[] indices, int i) { return new Byte128Shuffle(indices, i); } + ByteShuffle128 shuffleFromArray(int[] indices, int i) { return new ByteShuffle128(indices, i); } @Override @ForceInline - Byte128Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Byte128Shuffle(fn); } + ByteShuffle128 shuffleFromOp(IntUnaryOperator fn) { return new ByteShuffle128(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Byte128Vector vectorFactory(byte[] vec) { - return new Byte128Vector(vec); + ByteVector128 vectorFactory(byte[] vec) { + return new ByteVector128(vec); } @ForceInline final @Override - Byte128Vector asByteVectorRaw() { - return (Byte128Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector128 asByteVectorRaw() { + return (ByteVector128) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Byte128Vector extends ByteVector { @ForceInline final @Override - Byte128Vector uOp(FUnOp f) { - return (Byte128Vector) super.uOpTemplate(f); // specialize + ByteVector128 uOp(FUnOp f) { + return (ByteVector128) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Byte128Vector uOp(VectorMask m, FUnOp f) { - return (Byte128Vector) - super.uOpTemplate((Byte128Mask)m, f); // specialize + ByteVector128 uOp(VectorMask m, FUnOp f) { + return (ByteVector128) + super.uOpTemplate((ByteMask128)m, f); // specialize } // Binary operator @ForceInline final @Override - Byte128Vector bOp(Vector v, FBinOp f) { - return (Byte128Vector) super.bOpTemplate((Byte128Vector)v, f); // specialize + ByteVector128 bOp(Vector v, FBinOp f) { + return (ByteVector128) super.bOpTemplate((ByteVector128)v, f); // specialize } @ForceInline final @Override - Byte128Vector bOp(Vector v, + ByteVector128 bOp(Vector v, VectorMask m, FBinOp f) { - return (Byte128Vector) - super.bOpTemplate((Byte128Vector)v, (Byte128Mask)m, + return (ByteVector128) + super.bOpTemplate((ByteVector128)v, (ByteMask128)m, f); // specialize } @@ -219,19 +219,19 @@ final class Byte128Vector extends ByteVector { @ForceInline final @Override - Byte128Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Byte128Vector) - super.tOpTemplate((Byte128Vector)v1, (Byte128Vector)v2, + ByteVector128 tOp(Vector v1, Vector v2, FTriOp f) { + return (ByteVector128) + super.tOpTemplate((ByteVector128)v1, (ByteVector128)v2, f); // specialize } @ForceInline final @Override - Byte128Vector tOp(Vector v1, Vector v2, + ByteVector128 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Byte128Vector) - super.tOpTemplate((Byte128Vector)v1, (Byte128Vector)v2, - (Byte128Mask)m, f); // specialize + return (ByteVector128) + super.tOpTemplate((ByteVector128)v1, (ByteVector128)v2, + (ByteMask128)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Byte128Vector extends ByteVector { @Override @ForceInline - public Byte128Vector lanewise(Unary op) { - return (Byte128Vector) super.lanewiseTemplate(op); // specialize + public ByteVector128 lanewise(Unary op) { + return (ByteVector128) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Byte128Vector lanewise(Unary op, VectorMask m) { - return (Byte128Vector) super.lanewiseTemplate(op, Byte128Mask.class, (Byte128Mask) m); // specialize + public ByteVector128 lanewise(Unary op, VectorMask m) { + return (ByteVector128) super.lanewiseTemplate(op, ByteMask128.class, (ByteMask128) m); // specialize } @Override @ForceInline - public Byte128Vector lanewise(Binary op, Vector v) { - return (Byte128Vector) super.lanewiseTemplate(op, v); // specialize + public ByteVector128 lanewise(Binary op, Vector v) { + return (ByteVector128) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Byte128Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Byte128Vector) super.lanewiseTemplate(op, Byte128Mask.class, v, (Byte128Mask) m); // specialize + public ByteVector128 lanewise(Binary op, Vector v, VectorMask m) { + return (ByteVector128) super.lanewiseTemplate(op, ByteMask128.class, v, (ByteMask128) m); // specialize } /*package-private*/ @Override - @ForceInline Byte128Vector + @ForceInline ByteVector128 lanewiseShift(VectorOperators.Binary op, int e) { - return (Byte128Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (ByteVector128) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Byte128Vector + @ForceInline ByteVector128 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Byte128Vector) super.lanewiseShiftTemplate(op, Byte128Mask.class, e, (Byte128Mask) m); // specialize + return (ByteVector128) super.lanewiseShiftTemplate(op, ByteMask128.class, e, (ByteMask128) m); // specialize } /*package-private*/ @Override @ForceInline public final - Byte128Vector + ByteVector128 lanewise(Ternary op, Vector v1, Vector v2) { - return (Byte128Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ByteVector128) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Byte128Vector + ByteVector128 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Byte128Vector) super.lanewiseTemplate(op, Byte128Mask.class, v1, v2, (Byte128Mask) m); // specialize + return (ByteVector128) super.lanewiseTemplate(op, ByteMask128.class, v1, v2, (ByteMask128) m); // specialize } @Override @ForceInline public final - Byte128Vector addIndex(int scale) { - return (Byte128Vector) super.addIndexTemplate(scale); // specialize + ByteVector128 addIndex(int scale) { + return (ByteVector128) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Byte128Vector extends ByteVector { @ForceInline public final byte reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Byte128Mask.class, (Byte128Mask) m); // specialized + return super.reduceLanesTemplate(op, ByteMask128.class, (ByteMask128) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Byte128Vector extends ByteVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Byte128Mask.class, (Byte128Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, ByteMask128.class, (ByteMask128) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Byte128Vector extends ByteVector { @Override @ForceInline - public final Byte128Shuffle toShuffle() { - return (Byte128Shuffle) toShuffle(vspecies(), false); + public final ByteShuffle128 toShuffle() { + return (ByteShuffle128) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Byte128Mask test(Test op) { - return super.testTemplate(Byte128Mask.class, op); // specialize + public final ByteMask128 test(Test op) { + return super.testTemplate(ByteMask128.class, op); // specialize } @Override @ForceInline - public final Byte128Mask test(Test op, VectorMask m) { - return super.testTemplate(Byte128Mask.class, op, (Byte128Mask) m); // specialize + public final ByteMask128 test(Test op, VectorMask m) { + return super.testTemplate(ByteMask128.class, op, (ByteMask128) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Byte128Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Byte128Mask.class, op, v); // specialize + public final ByteMask128 compare(Comparison op, Vector v) { + return super.compareTemplate(ByteMask128.class, op, v); // specialize } @Override @ForceInline - public final Byte128Mask compare(Comparison op, byte s) { - return super.compareTemplate(Byte128Mask.class, op, s); // specialize + public final ByteMask128 compare(Comparison op, byte s) { + return super.compareTemplate(ByteMask128.class, op, s); // specialize } @Override @ForceInline - public final Byte128Mask compare(Comparison op, long s) { - return super.compareTemplate(Byte128Mask.class, op, s); // specialize + public final ByteMask128 compare(Comparison op, long s) { + return super.compareTemplate(ByteMask128.class, op, s); // specialize } @Override @ForceInline - public final Byte128Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Byte128Mask.class, op, v, (Byte128Mask) m); + public final ByteMask128 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ByteMask128.class, op, v, (ByteMask128) m); } @Override @ForceInline - public Byte128Vector blend(Vector v, VectorMask m) { - return (Byte128Vector) - super.blendTemplate(Byte128Mask.class, - (Byte128Vector) v, - (Byte128Mask) m); // specialize + public ByteVector128 blend(Vector v, VectorMask m) { + return (ByteVector128) + super.blendTemplate(ByteMask128.class, + (ByteVector128) v, + (ByteMask128) m); // specialize } @Override @ForceInline - public Byte128Vector slice(int origin, Vector v) { - return (Byte128Vector) super.sliceTemplate(origin, v); // specialize + public ByteVector128 slice(int origin, Vector v) { + return (ByteVector128) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Byte128Vector slice(int origin) { - return (Byte128Vector) super.sliceTemplate(origin); // specialize + public ByteVector128 slice(int origin) { + return (ByteVector128) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Byte128Vector unslice(int origin, Vector w, int part) { - return (Byte128Vector) super.unsliceTemplate(origin, w, part); // specialize + public ByteVector128 unslice(int origin, Vector w, int part) { + return (ByteVector128) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Byte128Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Byte128Vector) - super.unsliceTemplate(Byte128Mask.class, + public ByteVector128 unslice(int origin, Vector w, int part, VectorMask m) { + return (ByteVector128) + super.unsliceTemplate(ByteMask128.class, origin, w, part, - (Byte128Mask) m); // specialize + (ByteMask128) m); // specialize } @Override @ForceInline - public Byte128Vector unslice(int origin) { - return (Byte128Vector) super.unsliceTemplate(origin); // specialize + public ByteVector128 unslice(int origin) { + return (ByteVector128) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Byte128Vector rearrange(VectorShuffle s) { - return (Byte128Vector) - super.rearrangeTemplate(Byte128Shuffle.class, - (Byte128Shuffle) s); // specialize + public ByteVector128 rearrange(VectorShuffle s) { + return (ByteVector128) + super.rearrangeTemplate(ByteShuffle128.class, + (ByteShuffle128) s); // specialize } @Override @ForceInline - public Byte128Vector rearrange(VectorShuffle shuffle, + public ByteVector128 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Byte128Vector) - super.rearrangeTemplate(Byte128Shuffle.class, - Byte128Mask.class, - (Byte128Shuffle) shuffle, - (Byte128Mask) m); // specialize + return (ByteVector128) + super.rearrangeTemplate(ByteShuffle128.class, + ByteMask128.class, + (ByteShuffle128) shuffle, + (ByteMask128) m); // specialize } @Override @ForceInline - public Byte128Vector rearrange(VectorShuffle s, + public ByteVector128 rearrange(VectorShuffle s, Vector v) { - return (Byte128Vector) - super.rearrangeTemplate(Byte128Shuffle.class, - (Byte128Shuffle) s, - (Byte128Vector) v); // specialize + return (ByteVector128) + super.rearrangeTemplate(ByteShuffle128.class, + (ByteShuffle128) s, + (ByteVector128) v); // specialize } @Override @ForceInline - public Byte128Vector compress(VectorMask m) { - return (Byte128Vector) - super.compressTemplate(Byte128Mask.class, - (Byte128Mask) m); // specialize + public ByteVector128 compress(VectorMask m) { + return (ByteVector128) + super.compressTemplate(ByteMask128.class, + (ByteMask128) m); // specialize } @Override @ForceInline - public Byte128Vector expand(VectorMask m) { - return (Byte128Vector) - super.expandTemplate(Byte128Mask.class, - (Byte128Mask) m); // specialize + public ByteVector128 expand(VectorMask m) { + return (ByteVector128) + super.expandTemplate(ByteMask128.class, + (ByteMask128) m); // specialize } @Override @ForceInline - public Byte128Vector selectFrom(Vector v) { - return (Byte128Vector) - super.selectFromTemplate((Byte128Vector) v); // specialize + public ByteVector128 selectFrom(Vector v) { + return (ByteVector128) + super.selectFromTemplate((ByteVector128) v); // specialize } @Override @ForceInline - public Byte128Vector selectFrom(Vector v, + public ByteVector128 selectFrom(Vector v, VectorMask m) { - return (Byte128Vector) - super.selectFromTemplate((Byte128Vector) v, - Byte128Mask.class, (Byte128Mask) m); // specialize + return (ByteVector128) + super.selectFromTemplate((ByteVector128) v, + ByteMask128.class, (ByteMask128) m); // specialize } @Override @ForceInline - public Byte128Vector selectFrom(Vector v1, + public ByteVector128 selectFrom(Vector v1, Vector v2) { - return (Byte128Vector) - super.selectFromTemplate((Byte128Vector) v1, (Byte128Vector) v2); // specialize + return (ByteVector128) + super.selectFromTemplate((ByteVector128) v1, (ByteVector128) v2); // specialize } @ForceInline @@ -558,7 +558,7 @@ final class Byte128Vector extends ByteVector { @ForceInline @Override - public Byte128Vector withLane(int i, byte e) { + public ByteVector128 withLane(int i, byte e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -581,7 +581,7 @@ final class Byte128Vector extends ByteVector { } @ForceInline - public Byte128Vector withLaneHelper(int i, byte e) { + public ByteVector128 withLaneHelper(int i, byte e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -594,19 +594,19 @@ final class Byte128Vector extends ByteVector { // Mask - static final class Byte128Mask extends AbstractMask { + static final class ByteMask128 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - Byte128Mask(boolean[] bits) { + ByteMask128(boolean[] bits) { this(bits, 0); } - Byte128Mask(boolean[] bits, int offset) { + ByteMask128(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Byte128Mask(boolean val) { + ByteMask128(boolean val) { super(prepare(val)); } @@ -639,31 +639,31 @@ final class Byte128Vector extends ByteVector { } @Override - Byte128Mask uOp(MUnOp f) { + ByteMask128 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Byte128Mask(res); + return new ByteMask128(res); } @Override - Byte128Mask bOp(VectorMask m, MBinOp f) { + ByteMask128 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Byte128Mask)m).getBits(); + boolean[] mbits = ((ByteMask128)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Byte128Mask(res); + return new ByteMask128(res); } @ForceInline @Override public final - Byte128Vector toVector() { - return (Byte128Vector) super.toVectorTemplate(); // specialize + ByteVector128 toVector() { + return (ByteVector128) super.toVectorTemplate(); // specialize } /** @@ -696,25 +696,25 @@ final class Byte128Vector extends ByteVector { @Override @ForceInline /*package-private*/ - Byte128Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Byte128Mask) VectorSupport.indexPartiallyInUpperRange( - Byte128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Byte128Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + ByteMask128 indexPartiallyInUpperRange(long offset, long limit) { + return (ByteMask128) VectorSupport.indexPartiallyInUpperRange( + ByteMask128.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ByteMask128) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Byte128Mask not() { + public ByteMask128 not() { return xor(maskAll(true)); } @Override @ForceInline - public Byte128Mask compress() { - return (Byte128Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Byte128Vector.class, Byte128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ByteMask128 compress() { + return (ByteMask128)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ByteVector128.class, ByteMask128.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -723,30 +723,30 @@ final class Byte128Vector extends ByteVector { @Override @ForceInline - public Byte128Mask and(VectorMask mask) { + public ByteMask128 and(VectorMask mask) { Objects.requireNonNull(mask); - Byte128Mask m = (Byte128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Byte128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask128 m = (ByteMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ByteMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Byte128Mask or(VectorMask mask) { + public ByteMask128 or(VectorMask mask) { Objects.requireNonNull(mask); - Byte128Mask m = (Byte128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Byte128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask128 m = (ByteMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ByteMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Byte128Mask xor(VectorMask mask) { + public ByteMask128 xor(VectorMask mask) { Objects.requireNonNull(mask); - Byte128Mask m = (Byte128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask128 m = (ByteMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ByteMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -756,21 +756,21 @@ final class Byte128Vector extends ByteVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Byte128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ByteMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Byte128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ByteMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Byte128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ByteMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -780,7 +780,7 @@ final class Byte128Vector extends ByteVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Byte128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ByteMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -790,7 +790,7 @@ final class Byte128Vector extends ByteVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Byte128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ByteMask128.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -799,48 +799,48 @@ final class Byte128Vector extends ByteVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Byte128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ByteMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Byte128Mask)m).getBits())); + (m, __) -> anyTrueHelper(((ByteMask128)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Byte128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ByteMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Byte128Mask)m).getBits())); + (m, __) -> allTrueHelper(((ByteMask128)m).getBits())); } @ForceInline /*package-private*/ - static Byte128Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Byte128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ByteMask128 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ByteMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Byte128Mask TRUE_MASK = new Byte128Mask(true); - private static final Byte128Mask FALSE_MASK = new Byte128Mask(false); + private static final ByteMask128 TRUE_MASK = new ByteMask128(true); + private static final ByteMask128 FALSE_MASK = new ByteMask128(false); } // Shuffle - static final class Byte128Shuffle extends AbstractShuffle { + static final class ByteShuffle128 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - Byte128Shuffle(byte[] indices) { + ByteShuffle128(byte[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Byte128Shuffle(int[] indices, int i) { + ByteShuffle128(int[] indices, int i) { this(prepare(indices, i)); } - Byte128Shuffle(IntUnaryOperator fn) { + ByteShuffle128(IntUnaryOperator fn) { this(prepare(fn)); } @@ -860,23 +860,23 @@ final class Byte128Vector extends ByteVector { assert(VLENGTH < Byte.MAX_VALUE); assert(Byte.MIN_VALUE <= -VLENGTH); } - static final Byte128Shuffle IOTA = new Byte128Shuffle(IDENTITY); + static final ByteShuffle128 IOTA = new ByteShuffle128(IDENTITY); @Override @ForceInline - public Byte128Vector toVector() { + public ByteVector128 toVector() { return toBitsVector(); } @Override @ForceInline - Byte128Vector toBitsVector() { - return (Byte128Vector) super.toBitsVectorTemplate(); + ByteVector128 toBitsVector() { + return (ByteVector128) super.toBitsVectorTemplate(); } @Override - Byte128Vector toBitsVector0() { - return ((Byte128Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ByteVector128 toBitsVector0() { + return ((ByteVector128) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -925,30 +925,30 @@ final class Byte128Vector extends ByteVector { @Override @ForceInline - public final Byte128Mask laneIsValid() { - return (Byte128Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final ByteMask128 laneIsValid() { + return (ByteMask128) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Byte128Shuffle rearrange(VectorShuffle shuffle) { - Byte128Shuffle concreteShuffle = (Byte128Shuffle) shuffle; - return (Byte128Shuffle) toBitsVector().rearrange(concreteShuffle) + public final ByteShuffle128 rearrange(VectorShuffle shuffle) { + ByteShuffle128 concreteShuffle = (ByteShuffle128) shuffle; + return (ByteShuffle128) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Byte128Shuffle wrapIndexes() { - Byte128Vector v = toBitsVector(); + public final ByteShuffle128 wrapIndexes() { + ByteVector128 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Byte128Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ByteVector128) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Byte128Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ByteVector128) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Byte128Shuffle) v.toShuffle(vspecies(), false); + return (ByteShuffle128) v.toShuffle(vspecies(), false); } private static byte[] prepare(int[] indices, int offset) { @@ -999,14 +999,14 @@ final class Byte128Vector extends ByteVector { @Override final ByteVector fromArray0(byte[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Byte128Mask.class, a, offset, (Byte128Mask) m, offsetInRange); // specialize + return super.fromArray0Template(ByteMask128.class, a, offset, (ByteMask128) m, offsetInRange); // specialize } @ForceInline @Override final ByteVector fromArray0(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Byte128Mask.class, a, offset, indexMap, mapOffset, (Byte128Mask) m); + return super.fromArray0Template(ByteMask128.class, a, offset, indexMap, mapOffset, (ByteMask128) m); } @@ -1021,7 +1021,7 @@ final class Byte128Vector extends ByteVector { @Override final ByteVector fromBooleanArray0(boolean[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromBooleanArray0Template(Byte128Mask.class, a, offset, (Byte128Mask) m, offsetInRange); // specialize + return super.fromBooleanArray0Template(ByteMask128.class, a, offset, (ByteMask128) m, offsetInRange); // specialize } @ForceInline @@ -1035,7 +1035,7 @@ final class Byte128Vector extends ByteVector { @Override final ByteVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Byte128Mask.class, ms, offset, (Byte128Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ByteMask128.class, ms, offset, (ByteMask128) m, offsetInRange); // specialize } @ForceInline @@ -1049,7 +1049,7 @@ final class Byte128Vector extends ByteVector { @Override final void intoArray0(byte[] a, int offset, VectorMask m) { - super.intoArray0Template(Byte128Mask.class, a, offset, (Byte128Mask) m); + super.intoArray0Template(ByteMask128.class, a, offset, (ByteMask128) m); } @@ -1057,14 +1057,14 @@ final class Byte128Vector extends ByteVector { @Override final void intoBooleanArray0(boolean[] a, int offset, VectorMask m) { - super.intoBooleanArray0Template(Byte128Mask.class, a, offset, (Byte128Mask) m); + super.intoBooleanArray0Template(ByteMask128.class, a, offset, (ByteMask128) m); } @ForceInline @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Byte128Mask.class, ms, offset, (Byte128Mask) m); + super.intoMemorySegment0Template(ByteMask128.class, ms, offset, (ByteMask128) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector256.java similarity index 69% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector256.java index 6b0e57f8b8f..5da5dba4a2a 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector256.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Byte256Vector extends ByteVector { +final class ByteVector256 extends ByteVector { static final ByteSpecies VSPECIES = (ByteSpecies) ByteVector.SPECIES_256; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Byte256Vector.class; + static final Class VCLASS = ByteVector256.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Byte256Vector extends ByteVector { static final Class ETYPE = byte.class; // used by the JVM - Byte256Vector(byte[] v) { + ByteVector256(byte[] v) { super(v); } - // For compatibility as Byte256Vector::new, + // For compatibility as ByteVector256::new, // stored into species.vectorFactory. - Byte256Vector(Object v) { + ByteVector256(Object v) { this((byte[]) v); } - static final Byte256Vector ZERO = new Byte256Vector(new byte[VLENGTH]); - static final Byte256Vector IOTA = new Byte256Vector(VSPECIES.iotaArray()); + static final ByteVector256 ZERO = new ByteVector256(new byte[VLENGTH]); + static final ByteVector256 IOTA = new ByteVector256(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Byte256Vector extends ByteVector { @Override @ForceInline - public final Byte256Vector broadcast(byte e) { - return (Byte256Vector) super.broadcastTemplate(e); // specialize + public final ByteVector256 broadcast(byte e) { + return (ByteVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Byte256Vector broadcast(long e) { - return (Byte256Vector) super.broadcastTemplate(e); // specialize + public final ByteVector256 broadcast(long e) { + return (ByteVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Byte256Mask maskFromArray(boolean[] bits) { - return new Byte256Mask(bits); + ByteMask256 maskFromArray(boolean[] bits) { + return new ByteMask256(bits); } @Override @ForceInline - Byte256Shuffle iotaShuffle() { return Byte256Shuffle.IOTA; } + ByteShuffle256 iotaShuffle() { return ByteShuffle256.IOTA; } @Override @ForceInline - Byte256Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Byte256Shuffle) iotaShuffleTemplate((byte) start, (byte) step, wrap); + ByteShuffle256 iotaShuffle(int start, int step, boolean wrap) { + return (ByteShuffle256) iotaShuffleTemplate((byte) start, (byte) step, wrap); } @Override @ForceInline - Byte256Shuffle shuffleFromArray(int[] indices, int i) { return new Byte256Shuffle(indices, i); } + ByteShuffle256 shuffleFromArray(int[] indices, int i) { return new ByteShuffle256(indices, i); } @Override @ForceInline - Byte256Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Byte256Shuffle(fn); } + ByteShuffle256 shuffleFromOp(IntUnaryOperator fn) { return new ByteShuffle256(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Byte256Vector vectorFactory(byte[] vec) { - return new Byte256Vector(vec); + ByteVector256 vectorFactory(byte[] vec) { + return new ByteVector256(vec); } @ForceInline final @Override - Byte256Vector asByteVectorRaw() { - return (Byte256Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector256 asByteVectorRaw() { + return (ByteVector256) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Byte256Vector extends ByteVector { @ForceInline final @Override - Byte256Vector uOp(FUnOp f) { - return (Byte256Vector) super.uOpTemplate(f); // specialize + ByteVector256 uOp(FUnOp f) { + return (ByteVector256) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Byte256Vector uOp(VectorMask m, FUnOp f) { - return (Byte256Vector) - super.uOpTemplate((Byte256Mask)m, f); // specialize + ByteVector256 uOp(VectorMask m, FUnOp f) { + return (ByteVector256) + super.uOpTemplate((ByteMask256)m, f); // specialize } // Binary operator @ForceInline final @Override - Byte256Vector bOp(Vector v, FBinOp f) { - return (Byte256Vector) super.bOpTemplate((Byte256Vector)v, f); // specialize + ByteVector256 bOp(Vector v, FBinOp f) { + return (ByteVector256) super.bOpTemplate((ByteVector256)v, f); // specialize } @ForceInline final @Override - Byte256Vector bOp(Vector v, + ByteVector256 bOp(Vector v, VectorMask m, FBinOp f) { - return (Byte256Vector) - super.bOpTemplate((Byte256Vector)v, (Byte256Mask)m, + return (ByteVector256) + super.bOpTemplate((ByteVector256)v, (ByteMask256)m, f); // specialize } @@ -219,19 +219,19 @@ final class Byte256Vector extends ByteVector { @ForceInline final @Override - Byte256Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Byte256Vector) - super.tOpTemplate((Byte256Vector)v1, (Byte256Vector)v2, + ByteVector256 tOp(Vector v1, Vector v2, FTriOp f) { + return (ByteVector256) + super.tOpTemplate((ByteVector256)v1, (ByteVector256)v2, f); // specialize } @ForceInline final @Override - Byte256Vector tOp(Vector v1, Vector v2, + ByteVector256 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Byte256Vector) - super.tOpTemplate((Byte256Vector)v1, (Byte256Vector)v2, - (Byte256Mask)m, f); // specialize + return (ByteVector256) + super.tOpTemplate((ByteVector256)v1, (ByteVector256)v2, + (ByteMask256)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Byte256Vector extends ByteVector { @Override @ForceInline - public Byte256Vector lanewise(Unary op) { - return (Byte256Vector) super.lanewiseTemplate(op); // specialize + public ByteVector256 lanewise(Unary op) { + return (ByteVector256) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Byte256Vector lanewise(Unary op, VectorMask m) { - return (Byte256Vector) super.lanewiseTemplate(op, Byte256Mask.class, (Byte256Mask) m); // specialize + public ByteVector256 lanewise(Unary op, VectorMask m) { + return (ByteVector256) super.lanewiseTemplate(op, ByteMask256.class, (ByteMask256) m); // specialize } @Override @ForceInline - public Byte256Vector lanewise(Binary op, Vector v) { - return (Byte256Vector) super.lanewiseTemplate(op, v); // specialize + public ByteVector256 lanewise(Binary op, Vector v) { + return (ByteVector256) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Byte256Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Byte256Vector) super.lanewiseTemplate(op, Byte256Mask.class, v, (Byte256Mask) m); // specialize + public ByteVector256 lanewise(Binary op, Vector v, VectorMask m) { + return (ByteVector256) super.lanewiseTemplate(op, ByteMask256.class, v, (ByteMask256) m); // specialize } /*package-private*/ @Override - @ForceInline Byte256Vector + @ForceInline ByteVector256 lanewiseShift(VectorOperators.Binary op, int e) { - return (Byte256Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (ByteVector256) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Byte256Vector + @ForceInline ByteVector256 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Byte256Vector) super.lanewiseShiftTemplate(op, Byte256Mask.class, e, (Byte256Mask) m); // specialize + return (ByteVector256) super.lanewiseShiftTemplate(op, ByteMask256.class, e, (ByteMask256) m); // specialize } /*package-private*/ @Override @ForceInline public final - Byte256Vector + ByteVector256 lanewise(Ternary op, Vector v1, Vector v2) { - return (Byte256Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ByteVector256) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Byte256Vector + ByteVector256 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Byte256Vector) super.lanewiseTemplate(op, Byte256Mask.class, v1, v2, (Byte256Mask) m); // specialize + return (ByteVector256) super.lanewiseTemplate(op, ByteMask256.class, v1, v2, (ByteMask256) m); // specialize } @Override @ForceInline public final - Byte256Vector addIndex(int scale) { - return (Byte256Vector) super.addIndexTemplate(scale); // specialize + ByteVector256 addIndex(int scale) { + return (ByteVector256) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Byte256Vector extends ByteVector { @ForceInline public final byte reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Byte256Mask.class, (Byte256Mask) m); // specialized + return super.reduceLanesTemplate(op, ByteMask256.class, (ByteMask256) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Byte256Vector extends ByteVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Byte256Mask.class, (Byte256Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, ByteMask256.class, (ByteMask256) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Byte256Vector extends ByteVector { @Override @ForceInline - public final Byte256Shuffle toShuffle() { - return (Byte256Shuffle) toShuffle(vspecies(), false); + public final ByteShuffle256 toShuffle() { + return (ByteShuffle256) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Byte256Mask test(Test op) { - return super.testTemplate(Byte256Mask.class, op); // specialize + public final ByteMask256 test(Test op) { + return super.testTemplate(ByteMask256.class, op); // specialize } @Override @ForceInline - public final Byte256Mask test(Test op, VectorMask m) { - return super.testTemplate(Byte256Mask.class, op, (Byte256Mask) m); // specialize + public final ByteMask256 test(Test op, VectorMask m) { + return super.testTemplate(ByteMask256.class, op, (ByteMask256) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Byte256Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Byte256Mask.class, op, v); // specialize + public final ByteMask256 compare(Comparison op, Vector v) { + return super.compareTemplate(ByteMask256.class, op, v); // specialize } @Override @ForceInline - public final Byte256Mask compare(Comparison op, byte s) { - return super.compareTemplate(Byte256Mask.class, op, s); // specialize + public final ByteMask256 compare(Comparison op, byte s) { + return super.compareTemplate(ByteMask256.class, op, s); // specialize } @Override @ForceInline - public final Byte256Mask compare(Comparison op, long s) { - return super.compareTemplate(Byte256Mask.class, op, s); // specialize + public final ByteMask256 compare(Comparison op, long s) { + return super.compareTemplate(ByteMask256.class, op, s); // specialize } @Override @ForceInline - public final Byte256Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Byte256Mask.class, op, v, (Byte256Mask) m); + public final ByteMask256 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ByteMask256.class, op, v, (ByteMask256) m); } @Override @ForceInline - public Byte256Vector blend(Vector v, VectorMask m) { - return (Byte256Vector) - super.blendTemplate(Byte256Mask.class, - (Byte256Vector) v, - (Byte256Mask) m); // specialize + public ByteVector256 blend(Vector v, VectorMask m) { + return (ByteVector256) + super.blendTemplate(ByteMask256.class, + (ByteVector256) v, + (ByteMask256) m); // specialize } @Override @ForceInline - public Byte256Vector slice(int origin, Vector v) { - return (Byte256Vector) super.sliceTemplate(origin, v); // specialize + public ByteVector256 slice(int origin, Vector v) { + return (ByteVector256) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Byte256Vector slice(int origin) { - return (Byte256Vector) super.sliceTemplate(origin); // specialize + public ByteVector256 slice(int origin) { + return (ByteVector256) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Byte256Vector unslice(int origin, Vector w, int part) { - return (Byte256Vector) super.unsliceTemplate(origin, w, part); // specialize + public ByteVector256 unslice(int origin, Vector w, int part) { + return (ByteVector256) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Byte256Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Byte256Vector) - super.unsliceTemplate(Byte256Mask.class, + public ByteVector256 unslice(int origin, Vector w, int part, VectorMask m) { + return (ByteVector256) + super.unsliceTemplate(ByteMask256.class, origin, w, part, - (Byte256Mask) m); // specialize + (ByteMask256) m); // specialize } @Override @ForceInline - public Byte256Vector unslice(int origin) { - return (Byte256Vector) super.unsliceTemplate(origin); // specialize + public ByteVector256 unslice(int origin) { + return (ByteVector256) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Byte256Vector rearrange(VectorShuffle s) { - return (Byte256Vector) - super.rearrangeTemplate(Byte256Shuffle.class, - (Byte256Shuffle) s); // specialize + public ByteVector256 rearrange(VectorShuffle s) { + return (ByteVector256) + super.rearrangeTemplate(ByteShuffle256.class, + (ByteShuffle256) s); // specialize } @Override @ForceInline - public Byte256Vector rearrange(VectorShuffle shuffle, + public ByteVector256 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Byte256Vector) - super.rearrangeTemplate(Byte256Shuffle.class, - Byte256Mask.class, - (Byte256Shuffle) shuffle, - (Byte256Mask) m); // specialize + return (ByteVector256) + super.rearrangeTemplate(ByteShuffle256.class, + ByteMask256.class, + (ByteShuffle256) shuffle, + (ByteMask256) m); // specialize } @Override @ForceInline - public Byte256Vector rearrange(VectorShuffle s, + public ByteVector256 rearrange(VectorShuffle s, Vector v) { - return (Byte256Vector) - super.rearrangeTemplate(Byte256Shuffle.class, - (Byte256Shuffle) s, - (Byte256Vector) v); // specialize + return (ByteVector256) + super.rearrangeTemplate(ByteShuffle256.class, + (ByteShuffle256) s, + (ByteVector256) v); // specialize } @Override @ForceInline - public Byte256Vector compress(VectorMask m) { - return (Byte256Vector) - super.compressTemplate(Byte256Mask.class, - (Byte256Mask) m); // specialize + public ByteVector256 compress(VectorMask m) { + return (ByteVector256) + super.compressTemplate(ByteMask256.class, + (ByteMask256) m); // specialize } @Override @ForceInline - public Byte256Vector expand(VectorMask m) { - return (Byte256Vector) - super.expandTemplate(Byte256Mask.class, - (Byte256Mask) m); // specialize + public ByteVector256 expand(VectorMask m) { + return (ByteVector256) + super.expandTemplate(ByteMask256.class, + (ByteMask256) m); // specialize } @Override @ForceInline - public Byte256Vector selectFrom(Vector v) { - return (Byte256Vector) - super.selectFromTemplate((Byte256Vector) v); // specialize + public ByteVector256 selectFrom(Vector v) { + return (ByteVector256) + super.selectFromTemplate((ByteVector256) v); // specialize } @Override @ForceInline - public Byte256Vector selectFrom(Vector v, + public ByteVector256 selectFrom(Vector v, VectorMask m) { - return (Byte256Vector) - super.selectFromTemplate((Byte256Vector) v, - Byte256Mask.class, (Byte256Mask) m); // specialize + return (ByteVector256) + super.selectFromTemplate((ByteVector256) v, + ByteMask256.class, (ByteMask256) m); // specialize } @Override @ForceInline - public Byte256Vector selectFrom(Vector v1, + public ByteVector256 selectFrom(Vector v1, Vector v2) { - return (Byte256Vector) - super.selectFromTemplate((Byte256Vector) v1, (Byte256Vector) v2); // specialize + return (ByteVector256) + super.selectFromTemplate((ByteVector256) v1, (ByteVector256) v2); // specialize } @ForceInline @@ -574,7 +574,7 @@ final class Byte256Vector extends ByteVector { @ForceInline @Override - public Byte256Vector withLane(int i, byte e) { + public ByteVector256 withLane(int i, byte e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -613,7 +613,7 @@ final class Byte256Vector extends ByteVector { } @ForceInline - public Byte256Vector withLaneHelper(int i, byte e) { + public ByteVector256 withLaneHelper(int i, byte e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -626,19 +626,19 @@ final class Byte256Vector extends ByteVector { // Mask - static final class Byte256Mask extends AbstractMask { + static final class ByteMask256 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - Byte256Mask(boolean[] bits) { + ByteMask256(boolean[] bits) { this(bits, 0); } - Byte256Mask(boolean[] bits, int offset) { + ByteMask256(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Byte256Mask(boolean val) { + ByteMask256(boolean val) { super(prepare(val)); } @@ -671,31 +671,31 @@ final class Byte256Vector extends ByteVector { } @Override - Byte256Mask uOp(MUnOp f) { + ByteMask256 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Byte256Mask(res); + return new ByteMask256(res); } @Override - Byte256Mask bOp(VectorMask m, MBinOp f) { + ByteMask256 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Byte256Mask)m).getBits(); + boolean[] mbits = ((ByteMask256)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Byte256Mask(res); + return new ByteMask256(res); } @ForceInline @Override public final - Byte256Vector toVector() { - return (Byte256Vector) super.toVectorTemplate(); // specialize + ByteVector256 toVector() { + return (ByteVector256) super.toVectorTemplate(); // specialize } /** @@ -728,25 +728,25 @@ final class Byte256Vector extends ByteVector { @Override @ForceInline /*package-private*/ - Byte256Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Byte256Mask) VectorSupport.indexPartiallyInUpperRange( - Byte256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Byte256Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + ByteMask256 indexPartiallyInUpperRange(long offset, long limit) { + return (ByteMask256) VectorSupport.indexPartiallyInUpperRange( + ByteMask256.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ByteMask256) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Byte256Mask not() { + public ByteMask256 not() { return xor(maskAll(true)); } @Override @ForceInline - public Byte256Mask compress() { - return (Byte256Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Byte256Vector.class, Byte256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ByteMask256 compress() { + return (ByteMask256)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ByteVector256.class, ByteMask256.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -755,30 +755,30 @@ final class Byte256Vector extends ByteVector { @Override @ForceInline - public Byte256Mask and(VectorMask mask) { + public ByteMask256 and(VectorMask mask) { Objects.requireNonNull(mask); - Byte256Mask m = (Byte256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Byte256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask256 m = (ByteMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ByteMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Byte256Mask or(VectorMask mask) { + public ByteMask256 or(VectorMask mask) { Objects.requireNonNull(mask); - Byte256Mask m = (Byte256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Byte256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask256 m = (ByteMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ByteMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Byte256Mask xor(VectorMask mask) { + public ByteMask256 xor(VectorMask mask) { Objects.requireNonNull(mask); - Byte256Mask m = (Byte256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask256 m = (ByteMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ByteMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -788,21 +788,21 @@ final class Byte256Vector extends ByteVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Byte256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ByteMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Byte256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ByteMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Byte256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ByteMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -812,7 +812,7 @@ final class Byte256Vector extends ByteVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Byte256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ByteMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -822,7 +822,7 @@ final class Byte256Vector extends ByteVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Byte256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ByteMask256.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -831,48 +831,48 @@ final class Byte256Vector extends ByteVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Byte256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ByteMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Byte256Mask)m).getBits())); + (m, __) -> anyTrueHelper(((ByteMask256)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Byte256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ByteMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Byte256Mask)m).getBits())); + (m, __) -> allTrueHelper(((ByteMask256)m).getBits())); } @ForceInline /*package-private*/ - static Byte256Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Byte256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ByteMask256 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ByteMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Byte256Mask TRUE_MASK = new Byte256Mask(true); - private static final Byte256Mask FALSE_MASK = new Byte256Mask(false); + private static final ByteMask256 TRUE_MASK = new ByteMask256(true); + private static final ByteMask256 FALSE_MASK = new ByteMask256(false); } // Shuffle - static final class Byte256Shuffle extends AbstractShuffle { + static final class ByteShuffle256 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - Byte256Shuffle(byte[] indices) { + ByteShuffle256(byte[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Byte256Shuffle(int[] indices, int i) { + ByteShuffle256(int[] indices, int i) { this(prepare(indices, i)); } - Byte256Shuffle(IntUnaryOperator fn) { + ByteShuffle256(IntUnaryOperator fn) { this(prepare(fn)); } @@ -892,23 +892,23 @@ final class Byte256Vector extends ByteVector { assert(VLENGTH < Byte.MAX_VALUE); assert(Byte.MIN_VALUE <= -VLENGTH); } - static final Byte256Shuffle IOTA = new Byte256Shuffle(IDENTITY); + static final ByteShuffle256 IOTA = new ByteShuffle256(IDENTITY); @Override @ForceInline - public Byte256Vector toVector() { + public ByteVector256 toVector() { return toBitsVector(); } @Override @ForceInline - Byte256Vector toBitsVector() { - return (Byte256Vector) super.toBitsVectorTemplate(); + ByteVector256 toBitsVector() { + return (ByteVector256) super.toBitsVectorTemplate(); } @Override - Byte256Vector toBitsVector0() { - return ((Byte256Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ByteVector256 toBitsVector0() { + return ((ByteVector256) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -957,30 +957,30 @@ final class Byte256Vector extends ByteVector { @Override @ForceInline - public final Byte256Mask laneIsValid() { - return (Byte256Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final ByteMask256 laneIsValid() { + return (ByteMask256) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Byte256Shuffle rearrange(VectorShuffle shuffle) { - Byte256Shuffle concreteShuffle = (Byte256Shuffle) shuffle; - return (Byte256Shuffle) toBitsVector().rearrange(concreteShuffle) + public final ByteShuffle256 rearrange(VectorShuffle shuffle) { + ByteShuffle256 concreteShuffle = (ByteShuffle256) shuffle; + return (ByteShuffle256) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Byte256Shuffle wrapIndexes() { - Byte256Vector v = toBitsVector(); + public final ByteShuffle256 wrapIndexes() { + ByteVector256 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Byte256Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ByteVector256) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Byte256Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ByteVector256) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Byte256Shuffle) v.toShuffle(vspecies(), false); + return (ByteShuffle256) v.toShuffle(vspecies(), false); } private static byte[] prepare(int[] indices, int offset) { @@ -1031,14 +1031,14 @@ final class Byte256Vector extends ByteVector { @Override final ByteVector fromArray0(byte[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Byte256Mask.class, a, offset, (Byte256Mask) m, offsetInRange); // specialize + return super.fromArray0Template(ByteMask256.class, a, offset, (ByteMask256) m, offsetInRange); // specialize } @ForceInline @Override final ByteVector fromArray0(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Byte256Mask.class, a, offset, indexMap, mapOffset, (Byte256Mask) m); + return super.fromArray0Template(ByteMask256.class, a, offset, indexMap, mapOffset, (ByteMask256) m); } @@ -1053,7 +1053,7 @@ final class Byte256Vector extends ByteVector { @Override final ByteVector fromBooleanArray0(boolean[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromBooleanArray0Template(Byte256Mask.class, a, offset, (Byte256Mask) m, offsetInRange); // specialize + return super.fromBooleanArray0Template(ByteMask256.class, a, offset, (ByteMask256) m, offsetInRange); // specialize } @ForceInline @@ -1067,7 +1067,7 @@ final class Byte256Vector extends ByteVector { @Override final ByteVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Byte256Mask.class, ms, offset, (Byte256Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ByteMask256.class, ms, offset, (ByteMask256) m, offsetInRange); // specialize } @ForceInline @@ -1081,7 +1081,7 @@ final class Byte256Vector extends ByteVector { @Override final void intoArray0(byte[] a, int offset, VectorMask m) { - super.intoArray0Template(Byte256Mask.class, a, offset, (Byte256Mask) m); + super.intoArray0Template(ByteMask256.class, a, offset, (ByteMask256) m); } @@ -1089,14 +1089,14 @@ final class Byte256Vector extends ByteVector { @Override final void intoBooleanArray0(boolean[] a, int offset, VectorMask m) { - super.intoBooleanArray0Template(Byte256Mask.class, a, offset, (Byte256Mask) m); + super.intoBooleanArray0Template(ByteMask256.class, a, offset, (ByteMask256) m); } @ForceInline @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Byte256Mask.class, ms, offset, (Byte256Mask) m); + super.intoMemorySegment0Template(ByteMask256.class, ms, offset, (ByteMask256) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector512.java similarity index 71% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector512.java index b1df6949e3a..8d1b65b4837 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector512.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Byte512Vector extends ByteVector { +final class ByteVector512 extends ByteVector { static final ByteSpecies VSPECIES = (ByteSpecies) ByteVector.SPECIES_512; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Byte512Vector.class; + static final Class VCLASS = ByteVector512.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Byte512Vector extends ByteVector { static final Class ETYPE = byte.class; // used by the JVM - Byte512Vector(byte[] v) { + ByteVector512(byte[] v) { super(v); } - // For compatibility as Byte512Vector::new, + // For compatibility as ByteVector512::new, // stored into species.vectorFactory. - Byte512Vector(Object v) { + ByteVector512(Object v) { this((byte[]) v); } - static final Byte512Vector ZERO = new Byte512Vector(new byte[VLENGTH]); - static final Byte512Vector IOTA = new Byte512Vector(VSPECIES.iotaArray()); + static final ByteVector512 ZERO = new ByteVector512(new byte[VLENGTH]); + static final ByteVector512 IOTA = new ByteVector512(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Byte512Vector extends ByteVector { @Override @ForceInline - public final Byte512Vector broadcast(byte e) { - return (Byte512Vector) super.broadcastTemplate(e); // specialize + public final ByteVector512 broadcast(byte e) { + return (ByteVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Byte512Vector broadcast(long e) { - return (Byte512Vector) super.broadcastTemplate(e); // specialize + public final ByteVector512 broadcast(long e) { + return (ByteVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Byte512Mask maskFromArray(boolean[] bits) { - return new Byte512Mask(bits); + ByteMask512 maskFromArray(boolean[] bits) { + return new ByteMask512(bits); } @Override @ForceInline - Byte512Shuffle iotaShuffle() { return Byte512Shuffle.IOTA; } + ByteShuffle512 iotaShuffle() { return ByteShuffle512.IOTA; } @Override @ForceInline - Byte512Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Byte512Shuffle) iotaShuffleTemplate((byte) start, (byte) step, wrap); + ByteShuffle512 iotaShuffle(int start, int step, boolean wrap) { + return (ByteShuffle512) iotaShuffleTemplate((byte) start, (byte) step, wrap); } @Override @ForceInline - Byte512Shuffle shuffleFromArray(int[] indices, int i) { return new Byte512Shuffle(indices, i); } + ByteShuffle512 shuffleFromArray(int[] indices, int i) { return new ByteShuffle512(indices, i); } @Override @ForceInline - Byte512Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Byte512Shuffle(fn); } + ByteShuffle512 shuffleFromOp(IntUnaryOperator fn) { return new ByteShuffle512(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Byte512Vector vectorFactory(byte[] vec) { - return new Byte512Vector(vec); + ByteVector512 vectorFactory(byte[] vec) { + return new ByteVector512(vec); } @ForceInline final @Override - Byte512Vector asByteVectorRaw() { - return (Byte512Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector512 asByteVectorRaw() { + return (ByteVector512) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Byte512Vector extends ByteVector { @ForceInline final @Override - Byte512Vector uOp(FUnOp f) { - return (Byte512Vector) super.uOpTemplate(f); // specialize + ByteVector512 uOp(FUnOp f) { + return (ByteVector512) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Byte512Vector uOp(VectorMask m, FUnOp f) { - return (Byte512Vector) - super.uOpTemplate((Byte512Mask)m, f); // specialize + ByteVector512 uOp(VectorMask m, FUnOp f) { + return (ByteVector512) + super.uOpTemplate((ByteMask512)m, f); // specialize } // Binary operator @ForceInline final @Override - Byte512Vector bOp(Vector v, FBinOp f) { - return (Byte512Vector) super.bOpTemplate((Byte512Vector)v, f); // specialize + ByteVector512 bOp(Vector v, FBinOp f) { + return (ByteVector512) super.bOpTemplate((ByteVector512)v, f); // specialize } @ForceInline final @Override - Byte512Vector bOp(Vector v, + ByteVector512 bOp(Vector v, VectorMask m, FBinOp f) { - return (Byte512Vector) - super.bOpTemplate((Byte512Vector)v, (Byte512Mask)m, + return (ByteVector512) + super.bOpTemplate((ByteVector512)v, (ByteMask512)m, f); // specialize } @@ -219,19 +219,19 @@ final class Byte512Vector extends ByteVector { @ForceInline final @Override - Byte512Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Byte512Vector) - super.tOpTemplate((Byte512Vector)v1, (Byte512Vector)v2, + ByteVector512 tOp(Vector v1, Vector v2, FTriOp f) { + return (ByteVector512) + super.tOpTemplate((ByteVector512)v1, (ByteVector512)v2, f); // specialize } @ForceInline final @Override - Byte512Vector tOp(Vector v1, Vector v2, + ByteVector512 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Byte512Vector) - super.tOpTemplate((Byte512Vector)v1, (Byte512Vector)v2, - (Byte512Mask)m, f); // specialize + return (ByteVector512) + super.tOpTemplate((ByteVector512)v1, (ByteVector512)v2, + (ByteMask512)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Byte512Vector extends ByteVector { @Override @ForceInline - public Byte512Vector lanewise(Unary op) { - return (Byte512Vector) super.lanewiseTemplate(op); // specialize + public ByteVector512 lanewise(Unary op) { + return (ByteVector512) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Byte512Vector lanewise(Unary op, VectorMask m) { - return (Byte512Vector) super.lanewiseTemplate(op, Byte512Mask.class, (Byte512Mask) m); // specialize + public ByteVector512 lanewise(Unary op, VectorMask m) { + return (ByteVector512) super.lanewiseTemplate(op, ByteMask512.class, (ByteMask512) m); // specialize } @Override @ForceInline - public Byte512Vector lanewise(Binary op, Vector v) { - return (Byte512Vector) super.lanewiseTemplate(op, v); // specialize + public ByteVector512 lanewise(Binary op, Vector v) { + return (ByteVector512) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Byte512Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Byte512Vector) super.lanewiseTemplate(op, Byte512Mask.class, v, (Byte512Mask) m); // specialize + public ByteVector512 lanewise(Binary op, Vector v, VectorMask m) { + return (ByteVector512) super.lanewiseTemplate(op, ByteMask512.class, v, (ByteMask512) m); // specialize } /*package-private*/ @Override - @ForceInline Byte512Vector + @ForceInline ByteVector512 lanewiseShift(VectorOperators.Binary op, int e) { - return (Byte512Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (ByteVector512) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Byte512Vector + @ForceInline ByteVector512 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Byte512Vector) super.lanewiseShiftTemplate(op, Byte512Mask.class, e, (Byte512Mask) m); // specialize + return (ByteVector512) super.lanewiseShiftTemplate(op, ByteMask512.class, e, (ByteMask512) m); // specialize } /*package-private*/ @Override @ForceInline public final - Byte512Vector + ByteVector512 lanewise(Ternary op, Vector v1, Vector v2) { - return (Byte512Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ByteVector512) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Byte512Vector + ByteVector512 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Byte512Vector) super.lanewiseTemplate(op, Byte512Mask.class, v1, v2, (Byte512Mask) m); // specialize + return (ByteVector512) super.lanewiseTemplate(op, ByteMask512.class, v1, v2, (ByteMask512) m); // specialize } @Override @ForceInline public final - Byte512Vector addIndex(int scale) { - return (Byte512Vector) super.addIndexTemplate(scale); // specialize + ByteVector512 addIndex(int scale) { + return (ByteVector512) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Byte512Vector extends ByteVector { @ForceInline public final byte reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Byte512Mask.class, (Byte512Mask) m); // specialized + return super.reduceLanesTemplate(op, ByteMask512.class, (ByteMask512) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Byte512Vector extends ByteVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Byte512Mask.class, (Byte512Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, ByteMask512.class, (ByteMask512) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Byte512Vector extends ByteVector { @Override @ForceInline - public final Byte512Shuffle toShuffle() { - return (Byte512Shuffle) toShuffle(vspecies(), false); + public final ByteShuffle512 toShuffle() { + return (ByteShuffle512) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Byte512Mask test(Test op) { - return super.testTemplate(Byte512Mask.class, op); // specialize + public final ByteMask512 test(Test op) { + return super.testTemplate(ByteMask512.class, op); // specialize } @Override @ForceInline - public final Byte512Mask test(Test op, VectorMask m) { - return super.testTemplate(Byte512Mask.class, op, (Byte512Mask) m); // specialize + public final ByteMask512 test(Test op, VectorMask m) { + return super.testTemplate(ByteMask512.class, op, (ByteMask512) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Byte512Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Byte512Mask.class, op, v); // specialize + public final ByteMask512 compare(Comparison op, Vector v) { + return super.compareTemplate(ByteMask512.class, op, v); // specialize } @Override @ForceInline - public final Byte512Mask compare(Comparison op, byte s) { - return super.compareTemplate(Byte512Mask.class, op, s); // specialize + public final ByteMask512 compare(Comparison op, byte s) { + return super.compareTemplate(ByteMask512.class, op, s); // specialize } @Override @ForceInline - public final Byte512Mask compare(Comparison op, long s) { - return super.compareTemplate(Byte512Mask.class, op, s); // specialize + public final ByteMask512 compare(Comparison op, long s) { + return super.compareTemplate(ByteMask512.class, op, s); // specialize } @Override @ForceInline - public final Byte512Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Byte512Mask.class, op, v, (Byte512Mask) m); + public final ByteMask512 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ByteMask512.class, op, v, (ByteMask512) m); } @Override @ForceInline - public Byte512Vector blend(Vector v, VectorMask m) { - return (Byte512Vector) - super.blendTemplate(Byte512Mask.class, - (Byte512Vector) v, - (Byte512Mask) m); // specialize + public ByteVector512 blend(Vector v, VectorMask m) { + return (ByteVector512) + super.blendTemplate(ByteMask512.class, + (ByteVector512) v, + (ByteMask512) m); // specialize } @Override @ForceInline - public Byte512Vector slice(int origin, Vector v) { - return (Byte512Vector) super.sliceTemplate(origin, v); // specialize + public ByteVector512 slice(int origin, Vector v) { + return (ByteVector512) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Byte512Vector slice(int origin) { - return (Byte512Vector) super.sliceTemplate(origin); // specialize + public ByteVector512 slice(int origin) { + return (ByteVector512) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Byte512Vector unslice(int origin, Vector w, int part) { - return (Byte512Vector) super.unsliceTemplate(origin, w, part); // specialize + public ByteVector512 unslice(int origin, Vector w, int part) { + return (ByteVector512) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Byte512Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Byte512Vector) - super.unsliceTemplate(Byte512Mask.class, + public ByteVector512 unslice(int origin, Vector w, int part, VectorMask m) { + return (ByteVector512) + super.unsliceTemplate(ByteMask512.class, origin, w, part, - (Byte512Mask) m); // specialize + (ByteMask512) m); // specialize } @Override @ForceInline - public Byte512Vector unslice(int origin) { - return (Byte512Vector) super.unsliceTemplate(origin); // specialize + public ByteVector512 unslice(int origin) { + return (ByteVector512) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Byte512Vector rearrange(VectorShuffle s) { - return (Byte512Vector) - super.rearrangeTemplate(Byte512Shuffle.class, - (Byte512Shuffle) s); // specialize + public ByteVector512 rearrange(VectorShuffle s) { + return (ByteVector512) + super.rearrangeTemplate(ByteShuffle512.class, + (ByteShuffle512) s); // specialize } @Override @ForceInline - public Byte512Vector rearrange(VectorShuffle shuffle, + public ByteVector512 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Byte512Vector) - super.rearrangeTemplate(Byte512Shuffle.class, - Byte512Mask.class, - (Byte512Shuffle) shuffle, - (Byte512Mask) m); // specialize + return (ByteVector512) + super.rearrangeTemplate(ByteShuffle512.class, + ByteMask512.class, + (ByteShuffle512) shuffle, + (ByteMask512) m); // specialize } @Override @ForceInline - public Byte512Vector rearrange(VectorShuffle s, + public ByteVector512 rearrange(VectorShuffle s, Vector v) { - return (Byte512Vector) - super.rearrangeTemplate(Byte512Shuffle.class, - (Byte512Shuffle) s, - (Byte512Vector) v); // specialize + return (ByteVector512) + super.rearrangeTemplate(ByteShuffle512.class, + (ByteShuffle512) s, + (ByteVector512) v); // specialize } @Override @ForceInline - public Byte512Vector compress(VectorMask m) { - return (Byte512Vector) - super.compressTemplate(Byte512Mask.class, - (Byte512Mask) m); // specialize + public ByteVector512 compress(VectorMask m) { + return (ByteVector512) + super.compressTemplate(ByteMask512.class, + (ByteMask512) m); // specialize } @Override @ForceInline - public Byte512Vector expand(VectorMask m) { - return (Byte512Vector) - super.expandTemplate(Byte512Mask.class, - (Byte512Mask) m); // specialize + public ByteVector512 expand(VectorMask m) { + return (ByteVector512) + super.expandTemplate(ByteMask512.class, + (ByteMask512) m); // specialize } @Override @ForceInline - public Byte512Vector selectFrom(Vector v) { - return (Byte512Vector) - super.selectFromTemplate((Byte512Vector) v); // specialize + public ByteVector512 selectFrom(Vector v) { + return (ByteVector512) + super.selectFromTemplate((ByteVector512) v); // specialize } @Override @ForceInline - public Byte512Vector selectFrom(Vector v, + public ByteVector512 selectFrom(Vector v, VectorMask m) { - return (Byte512Vector) - super.selectFromTemplate((Byte512Vector) v, - Byte512Mask.class, (Byte512Mask) m); // specialize + return (ByteVector512) + super.selectFromTemplate((ByteVector512) v, + ByteMask512.class, (ByteMask512) m); // specialize } @Override @ForceInline - public Byte512Vector selectFrom(Vector v1, + public ByteVector512 selectFrom(Vector v1, Vector v2) { - return (Byte512Vector) - super.selectFromTemplate((Byte512Vector) v1, (Byte512Vector) v2); // specialize + return (ByteVector512) + super.selectFromTemplate((ByteVector512) v1, (ByteVector512) v2); // specialize } @ForceInline @@ -606,7 +606,7 @@ final class Byte512Vector extends ByteVector { @ForceInline @Override - public Byte512Vector withLane(int i, byte e) { + public ByteVector512 withLane(int i, byte e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -677,7 +677,7 @@ final class Byte512Vector extends ByteVector { } @ForceInline - public Byte512Vector withLaneHelper(int i, byte e) { + public ByteVector512 withLaneHelper(int i, byte e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -690,19 +690,19 @@ final class Byte512Vector extends ByteVector { // Mask - static final class Byte512Mask extends AbstractMask { + static final class ByteMask512 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - Byte512Mask(boolean[] bits) { + ByteMask512(boolean[] bits) { this(bits, 0); } - Byte512Mask(boolean[] bits, int offset) { + ByteMask512(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Byte512Mask(boolean val) { + ByteMask512(boolean val) { super(prepare(val)); } @@ -735,31 +735,31 @@ final class Byte512Vector extends ByteVector { } @Override - Byte512Mask uOp(MUnOp f) { + ByteMask512 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Byte512Mask(res); + return new ByteMask512(res); } @Override - Byte512Mask bOp(VectorMask m, MBinOp f) { + ByteMask512 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Byte512Mask)m).getBits(); + boolean[] mbits = ((ByteMask512)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Byte512Mask(res); + return new ByteMask512(res); } @ForceInline @Override public final - Byte512Vector toVector() { - return (Byte512Vector) super.toVectorTemplate(); // specialize + ByteVector512 toVector() { + return (ByteVector512) super.toVectorTemplate(); // specialize } /** @@ -792,25 +792,25 @@ final class Byte512Vector extends ByteVector { @Override @ForceInline /*package-private*/ - Byte512Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Byte512Mask) VectorSupport.indexPartiallyInUpperRange( - Byte512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Byte512Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + ByteMask512 indexPartiallyInUpperRange(long offset, long limit) { + return (ByteMask512) VectorSupport.indexPartiallyInUpperRange( + ByteMask512.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ByteMask512) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Byte512Mask not() { + public ByteMask512 not() { return xor(maskAll(true)); } @Override @ForceInline - public Byte512Mask compress() { - return (Byte512Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Byte512Vector.class, Byte512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ByteMask512 compress() { + return (ByteMask512)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ByteVector512.class, ByteMask512.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -819,30 +819,30 @@ final class Byte512Vector extends ByteVector { @Override @ForceInline - public Byte512Mask and(VectorMask mask) { + public ByteMask512 and(VectorMask mask) { Objects.requireNonNull(mask); - Byte512Mask m = (Byte512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Byte512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask512 m = (ByteMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ByteMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Byte512Mask or(VectorMask mask) { + public ByteMask512 or(VectorMask mask) { Objects.requireNonNull(mask); - Byte512Mask m = (Byte512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Byte512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask512 m = (ByteMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ByteMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Byte512Mask xor(VectorMask mask) { + public ByteMask512 xor(VectorMask mask) { Objects.requireNonNull(mask); - Byte512Mask m = (Byte512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask512 m = (ByteMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ByteMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -852,21 +852,21 @@ final class Byte512Vector extends ByteVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Byte512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ByteMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Byte512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ByteMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Byte512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ByteMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -876,7 +876,7 @@ final class Byte512Vector extends ByteVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Byte512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ByteMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -886,7 +886,7 @@ final class Byte512Vector extends ByteVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Byte512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ByteMask512.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -895,48 +895,48 @@ final class Byte512Vector extends ByteVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Byte512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ByteMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Byte512Mask)m).getBits())); + (m, __) -> anyTrueHelper(((ByteMask512)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Byte512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ByteMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Byte512Mask)m).getBits())); + (m, __) -> allTrueHelper(((ByteMask512)m).getBits())); } @ForceInline /*package-private*/ - static Byte512Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Byte512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ByteMask512 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ByteMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Byte512Mask TRUE_MASK = new Byte512Mask(true); - private static final Byte512Mask FALSE_MASK = new Byte512Mask(false); + private static final ByteMask512 TRUE_MASK = new ByteMask512(true); + private static final ByteMask512 FALSE_MASK = new ByteMask512(false); } // Shuffle - static final class Byte512Shuffle extends AbstractShuffle { + static final class ByteShuffle512 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - Byte512Shuffle(byte[] indices) { + ByteShuffle512(byte[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Byte512Shuffle(int[] indices, int i) { + ByteShuffle512(int[] indices, int i) { this(prepare(indices, i)); } - Byte512Shuffle(IntUnaryOperator fn) { + ByteShuffle512(IntUnaryOperator fn) { this(prepare(fn)); } @@ -956,23 +956,23 @@ final class Byte512Vector extends ByteVector { assert(VLENGTH < Byte.MAX_VALUE); assert(Byte.MIN_VALUE <= -VLENGTH); } - static final Byte512Shuffle IOTA = new Byte512Shuffle(IDENTITY); + static final ByteShuffle512 IOTA = new ByteShuffle512(IDENTITY); @Override @ForceInline - public Byte512Vector toVector() { + public ByteVector512 toVector() { return toBitsVector(); } @Override @ForceInline - Byte512Vector toBitsVector() { - return (Byte512Vector) super.toBitsVectorTemplate(); + ByteVector512 toBitsVector() { + return (ByteVector512) super.toBitsVectorTemplate(); } @Override - Byte512Vector toBitsVector0() { - return ((Byte512Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ByteVector512 toBitsVector0() { + return ((ByteVector512) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -1021,30 +1021,30 @@ final class Byte512Vector extends ByteVector { @Override @ForceInline - public final Byte512Mask laneIsValid() { - return (Byte512Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final ByteMask512 laneIsValid() { + return (ByteMask512) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Byte512Shuffle rearrange(VectorShuffle shuffle) { - Byte512Shuffle concreteShuffle = (Byte512Shuffle) shuffle; - return (Byte512Shuffle) toBitsVector().rearrange(concreteShuffle) + public final ByteShuffle512 rearrange(VectorShuffle shuffle) { + ByteShuffle512 concreteShuffle = (ByteShuffle512) shuffle; + return (ByteShuffle512) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Byte512Shuffle wrapIndexes() { - Byte512Vector v = toBitsVector(); + public final ByteShuffle512 wrapIndexes() { + ByteVector512 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Byte512Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ByteVector512) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Byte512Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ByteVector512) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Byte512Shuffle) v.toShuffle(vspecies(), false); + return (ByteShuffle512) v.toShuffle(vspecies(), false); } private static byte[] prepare(int[] indices, int offset) { @@ -1095,14 +1095,14 @@ final class Byte512Vector extends ByteVector { @Override final ByteVector fromArray0(byte[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Byte512Mask.class, a, offset, (Byte512Mask) m, offsetInRange); // specialize + return super.fromArray0Template(ByteMask512.class, a, offset, (ByteMask512) m, offsetInRange); // specialize } @ForceInline @Override final ByteVector fromArray0(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Byte512Mask.class, a, offset, indexMap, mapOffset, (Byte512Mask) m); + return super.fromArray0Template(ByteMask512.class, a, offset, indexMap, mapOffset, (ByteMask512) m); } @@ -1117,7 +1117,7 @@ final class Byte512Vector extends ByteVector { @Override final ByteVector fromBooleanArray0(boolean[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromBooleanArray0Template(Byte512Mask.class, a, offset, (Byte512Mask) m, offsetInRange); // specialize + return super.fromBooleanArray0Template(ByteMask512.class, a, offset, (ByteMask512) m, offsetInRange); // specialize } @ForceInline @@ -1131,7 +1131,7 @@ final class Byte512Vector extends ByteVector { @Override final ByteVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Byte512Mask.class, ms, offset, (Byte512Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ByteMask512.class, ms, offset, (ByteMask512) m, offsetInRange); // specialize } @ForceInline @@ -1145,7 +1145,7 @@ final class Byte512Vector extends ByteVector { @Override final void intoArray0(byte[] a, int offset, VectorMask m) { - super.intoArray0Template(Byte512Mask.class, a, offset, (Byte512Mask) m); + super.intoArray0Template(ByteMask512.class, a, offset, (ByteMask512) m); } @@ -1153,14 +1153,14 @@ final class Byte512Vector extends ByteVector { @Override final void intoBooleanArray0(boolean[] a, int offset, VectorMask m) { - super.intoBooleanArray0Template(Byte512Mask.class, a, offset, (Byte512Mask) m); + super.intoBooleanArray0Template(ByteMask512.class, a, offset, (ByteMask512) m); } @ForceInline @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Byte512Mask.class, ms, offset, (Byte512Mask) m); + super.intoMemorySegment0Template(ByteMask512.class, ms, offset, (ByteMask512) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector64.java similarity index 67% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector64.java index dfd16e1812a..8b76a54adca 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector64.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Byte64Vector extends ByteVector { +final class ByteVector64 extends ByteVector { static final ByteSpecies VSPECIES = (ByteSpecies) ByteVector.SPECIES_64; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Byte64Vector.class; + static final Class VCLASS = ByteVector64.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Byte64Vector extends ByteVector { static final Class ETYPE = byte.class; // used by the JVM - Byte64Vector(byte[] v) { + ByteVector64(byte[] v) { super(v); } - // For compatibility as Byte64Vector::new, + // For compatibility as ByteVector64::new, // stored into species.vectorFactory. - Byte64Vector(Object v) { + ByteVector64(Object v) { this((byte[]) v); } - static final Byte64Vector ZERO = new Byte64Vector(new byte[VLENGTH]); - static final Byte64Vector IOTA = new Byte64Vector(VSPECIES.iotaArray()); + static final ByteVector64 ZERO = new ByteVector64(new byte[VLENGTH]); + static final ByteVector64 IOTA = new ByteVector64(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Byte64Vector extends ByteVector { @Override @ForceInline - public final Byte64Vector broadcast(byte e) { - return (Byte64Vector) super.broadcastTemplate(e); // specialize + public final ByteVector64 broadcast(byte e) { + return (ByteVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Byte64Vector broadcast(long e) { - return (Byte64Vector) super.broadcastTemplate(e); // specialize + public final ByteVector64 broadcast(long e) { + return (ByteVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Byte64Mask maskFromArray(boolean[] bits) { - return new Byte64Mask(bits); + ByteMask64 maskFromArray(boolean[] bits) { + return new ByteMask64(bits); } @Override @ForceInline - Byte64Shuffle iotaShuffle() { return Byte64Shuffle.IOTA; } + ByteShuffle64 iotaShuffle() { return ByteShuffle64.IOTA; } @Override @ForceInline - Byte64Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Byte64Shuffle) iotaShuffleTemplate((byte) start, (byte) step, wrap); + ByteShuffle64 iotaShuffle(int start, int step, boolean wrap) { + return (ByteShuffle64) iotaShuffleTemplate((byte) start, (byte) step, wrap); } @Override @ForceInline - Byte64Shuffle shuffleFromArray(int[] indices, int i) { return new Byte64Shuffle(indices, i); } + ByteShuffle64 shuffleFromArray(int[] indices, int i) { return new ByteShuffle64(indices, i); } @Override @ForceInline - Byte64Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Byte64Shuffle(fn); } + ByteShuffle64 shuffleFromOp(IntUnaryOperator fn) { return new ByteShuffle64(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Byte64Vector vectorFactory(byte[] vec) { - return new Byte64Vector(vec); + ByteVector64 vectorFactory(byte[] vec) { + return new ByteVector64(vec); } @ForceInline final @Override - Byte64Vector asByteVectorRaw() { - return (Byte64Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector64 asByteVectorRaw() { + return (ByteVector64) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Byte64Vector extends ByteVector { @ForceInline final @Override - Byte64Vector uOp(FUnOp f) { - return (Byte64Vector) super.uOpTemplate(f); // specialize + ByteVector64 uOp(FUnOp f) { + return (ByteVector64) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Byte64Vector uOp(VectorMask m, FUnOp f) { - return (Byte64Vector) - super.uOpTemplate((Byte64Mask)m, f); // specialize + ByteVector64 uOp(VectorMask m, FUnOp f) { + return (ByteVector64) + super.uOpTemplate((ByteMask64)m, f); // specialize } // Binary operator @ForceInline final @Override - Byte64Vector bOp(Vector v, FBinOp f) { - return (Byte64Vector) super.bOpTemplate((Byte64Vector)v, f); // specialize + ByteVector64 bOp(Vector v, FBinOp f) { + return (ByteVector64) super.bOpTemplate((ByteVector64)v, f); // specialize } @ForceInline final @Override - Byte64Vector bOp(Vector v, + ByteVector64 bOp(Vector v, VectorMask m, FBinOp f) { - return (Byte64Vector) - super.bOpTemplate((Byte64Vector)v, (Byte64Mask)m, + return (ByteVector64) + super.bOpTemplate((ByteVector64)v, (ByteMask64)m, f); // specialize } @@ -219,19 +219,19 @@ final class Byte64Vector extends ByteVector { @ForceInline final @Override - Byte64Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Byte64Vector) - super.tOpTemplate((Byte64Vector)v1, (Byte64Vector)v2, + ByteVector64 tOp(Vector v1, Vector v2, FTriOp f) { + return (ByteVector64) + super.tOpTemplate((ByteVector64)v1, (ByteVector64)v2, f); // specialize } @ForceInline final @Override - Byte64Vector tOp(Vector v1, Vector v2, + ByteVector64 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Byte64Vector) - super.tOpTemplate((Byte64Vector)v1, (Byte64Vector)v2, - (Byte64Mask)m, f); // specialize + return (ByteVector64) + super.tOpTemplate((ByteVector64)v1, (ByteVector64)v2, + (ByteMask64)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Byte64Vector extends ByteVector { @Override @ForceInline - public Byte64Vector lanewise(Unary op) { - return (Byte64Vector) super.lanewiseTemplate(op); // specialize + public ByteVector64 lanewise(Unary op) { + return (ByteVector64) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Byte64Vector lanewise(Unary op, VectorMask m) { - return (Byte64Vector) super.lanewiseTemplate(op, Byte64Mask.class, (Byte64Mask) m); // specialize + public ByteVector64 lanewise(Unary op, VectorMask m) { + return (ByteVector64) super.lanewiseTemplate(op, ByteMask64.class, (ByteMask64) m); // specialize } @Override @ForceInline - public Byte64Vector lanewise(Binary op, Vector v) { - return (Byte64Vector) super.lanewiseTemplate(op, v); // specialize + public ByteVector64 lanewise(Binary op, Vector v) { + return (ByteVector64) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Byte64Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Byte64Vector) super.lanewiseTemplate(op, Byte64Mask.class, v, (Byte64Mask) m); // specialize + public ByteVector64 lanewise(Binary op, Vector v, VectorMask m) { + return (ByteVector64) super.lanewiseTemplate(op, ByteMask64.class, v, (ByteMask64) m); // specialize } /*package-private*/ @Override - @ForceInline Byte64Vector + @ForceInline ByteVector64 lanewiseShift(VectorOperators.Binary op, int e) { - return (Byte64Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (ByteVector64) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Byte64Vector + @ForceInline ByteVector64 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Byte64Vector) super.lanewiseShiftTemplate(op, Byte64Mask.class, e, (Byte64Mask) m); // specialize + return (ByteVector64) super.lanewiseShiftTemplate(op, ByteMask64.class, e, (ByteMask64) m); // specialize } /*package-private*/ @Override @ForceInline public final - Byte64Vector + ByteVector64 lanewise(Ternary op, Vector v1, Vector v2) { - return (Byte64Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ByteVector64) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Byte64Vector + ByteVector64 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Byte64Vector) super.lanewiseTemplate(op, Byte64Mask.class, v1, v2, (Byte64Mask) m); // specialize + return (ByteVector64) super.lanewiseTemplate(op, ByteMask64.class, v1, v2, (ByteMask64) m); // specialize } @Override @ForceInline public final - Byte64Vector addIndex(int scale) { - return (Byte64Vector) super.addIndexTemplate(scale); // specialize + ByteVector64 addIndex(int scale) { + return (ByteVector64) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Byte64Vector extends ByteVector { @ForceInline public final byte reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Byte64Mask.class, (Byte64Mask) m); // specialized + return super.reduceLanesTemplate(op, ByteMask64.class, (ByteMask64) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Byte64Vector extends ByteVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Byte64Mask.class, (Byte64Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, ByteMask64.class, (ByteMask64) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Byte64Vector extends ByteVector { @Override @ForceInline - public final Byte64Shuffle toShuffle() { - return (Byte64Shuffle) toShuffle(vspecies(), false); + public final ByteShuffle64 toShuffle() { + return (ByteShuffle64) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Byte64Mask test(Test op) { - return super.testTemplate(Byte64Mask.class, op); // specialize + public final ByteMask64 test(Test op) { + return super.testTemplate(ByteMask64.class, op); // specialize } @Override @ForceInline - public final Byte64Mask test(Test op, VectorMask m) { - return super.testTemplate(Byte64Mask.class, op, (Byte64Mask) m); // specialize + public final ByteMask64 test(Test op, VectorMask m) { + return super.testTemplate(ByteMask64.class, op, (ByteMask64) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Byte64Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Byte64Mask.class, op, v); // specialize + public final ByteMask64 compare(Comparison op, Vector v) { + return super.compareTemplate(ByteMask64.class, op, v); // specialize } @Override @ForceInline - public final Byte64Mask compare(Comparison op, byte s) { - return super.compareTemplate(Byte64Mask.class, op, s); // specialize + public final ByteMask64 compare(Comparison op, byte s) { + return super.compareTemplate(ByteMask64.class, op, s); // specialize } @Override @ForceInline - public final Byte64Mask compare(Comparison op, long s) { - return super.compareTemplate(Byte64Mask.class, op, s); // specialize + public final ByteMask64 compare(Comparison op, long s) { + return super.compareTemplate(ByteMask64.class, op, s); // specialize } @Override @ForceInline - public final Byte64Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Byte64Mask.class, op, v, (Byte64Mask) m); + public final ByteMask64 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ByteMask64.class, op, v, (ByteMask64) m); } @Override @ForceInline - public Byte64Vector blend(Vector v, VectorMask m) { - return (Byte64Vector) - super.blendTemplate(Byte64Mask.class, - (Byte64Vector) v, - (Byte64Mask) m); // specialize + public ByteVector64 blend(Vector v, VectorMask m) { + return (ByteVector64) + super.blendTemplate(ByteMask64.class, + (ByteVector64) v, + (ByteMask64) m); // specialize } @Override @ForceInline - public Byte64Vector slice(int origin, Vector v) { - return (Byte64Vector) super.sliceTemplate(origin, v); // specialize + public ByteVector64 slice(int origin, Vector v) { + return (ByteVector64) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Byte64Vector slice(int origin) { - return (Byte64Vector) super.sliceTemplate(origin); // specialize + public ByteVector64 slice(int origin) { + return (ByteVector64) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Byte64Vector unslice(int origin, Vector w, int part) { - return (Byte64Vector) super.unsliceTemplate(origin, w, part); // specialize + public ByteVector64 unslice(int origin, Vector w, int part) { + return (ByteVector64) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Byte64Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Byte64Vector) - super.unsliceTemplate(Byte64Mask.class, + public ByteVector64 unslice(int origin, Vector w, int part, VectorMask m) { + return (ByteVector64) + super.unsliceTemplate(ByteMask64.class, origin, w, part, - (Byte64Mask) m); // specialize + (ByteMask64) m); // specialize } @Override @ForceInline - public Byte64Vector unslice(int origin) { - return (Byte64Vector) super.unsliceTemplate(origin); // specialize + public ByteVector64 unslice(int origin) { + return (ByteVector64) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Byte64Vector rearrange(VectorShuffle s) { - return (Byte64Vector) - super.rearrangeTemplate(Byte64Shuffle.class, - (Byte64Shuffle) s); // specialize + public ByteVector64 rearrange(VectorShuffle s) { + return (ByteVector64) + super.rearrangeTemplate(ByteShuffle64.class, + (ByteShuffle64) s); // specialize } @Override @ForceInline - public Byte64Vector rearrange(VectorShuffle shuffle, + public ByteVector64 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Byte64Vector) - super.rearrangeTemplate(Byte64Shuffle.class, - Byte64Mask.class, - (Byte64Shuffle) shuffle, - (Byte64Mask) m); // specialize + return (ByteVector64) + super.rearrangeTemplate(ByteShuffle64.class, + ByteMask64.class, + (ByteShuffle64) shuffle, + (ByteMask64) m); // specialize } @Override @ForceInline - public Byte64Vector rearrange(VectorShuffle s, + public ByteVector64 rearrange(VectorShuffle s, Vector v) { - return (Byte64Vector) - super.rearrangeTemplate(Byte64Shuffle.class, - (Byte64Shuffle) s, - (Byte64Vector) v); // specialize + return (ByteVector64) + super.rearrangeTemplate(ByteShuffle64.class, + (ByteShuffle64) s, + (ByteVector64) v); // specialize } @Override @ForceInline - public Byte64Vector compress(VectorMask m) { - return (Byte64Vector) - super.compressTemplate(Byte64Mask.class, - (Byte64Mask) m); // specialize + public ByteVector64 compress(VectorMask m) { + return (ByteVector64) + super.compressTemplate(ByteMask64.class, + (ByteMask64) m); // specialize } @Override @ForceInline - public Byte64Vector expand(VectorMask m) { - return (Byte64Vector) - super.expandTemplate(Byte64Mask.class, - (Byte64Mask) m); // specialize + public ByteVector64 expand(VectorMask m) { + return (ByteVector64) + super.expandTemplate(ByteMask64.class, + (ByteMask64) m); // specialize } @Override @ForceInline - public Byte64Vector selectFrom(Vector v) { - return (Byte64Vector) - super.selectFromTemplate((Byte64Vector) v); // specialize + public ByteVector64 selectFrom(Vector v) { + return (ByteVector64) + super.selectFromTemplate((ByteVector64) v); // specialize } @Override @ForceInline - public Byte64Vector selectFrom(Vector v, + public ByteVector64 selectFrom(Vector v, VectorMask m) { - return (Byte64Vector) - super.selectFromTemplate((Byte64Vector) v, - Byte64Mask.class, (Byte64Mask) m); // specialize + return (ByteVector64) + super.selectFromTemplate((ByteVector64) v, + ByteMask64.class, (ByteMask64) m); // specialize } @Override @ForceInline - public Byte64Vector selectFrom(Vector v1, + public ByteVector64 selectFrom(Vector v1, Vector v2) { - return (Byte64Vector) - super.selectFromTemplate((Byte64Vector) v1, (Byte64Vector) v2); // specialize + return (ByteVector64) + super.selectFromTemplate((ByteVector64) v1, (ByteVector64) v2); // specialize } @ForceInline @@ -550,7 +550,7 @@ final class Byte64Vector extends ByteVector { @ForceInline @Override - public Byte64Vector withLane(int i, byte e) { + public ByteVector64 withLane(int i, byte e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -565,7 +565,7 @@ final class Byte64Vector extends ByteVector { } @ForceInline - public Byte64Vector withLaneHelper(int i, byte e) { + public ByteVector64 withLaneHelper(int i, byte e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -578,19 +578,19 @@ final class Byte64Vector extends ByteVector { // Mask - static final class Byte64Mask extends AbstractMask { + static final class ByteMask64 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - Byte64Mask(boolean[] bits) { + ByteMask64(boolean[] bits) { this(bits, 0); } - Byte64Mask(boolean[] bits, int offset) { + ByteMask64(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Byte64Mask(boolean val) { + ByteMask64(boolean val) { super(prepare(val)); } @@ -623,31 +623,31 @@ final class Byte64Vector extends ByteVector { } @Override - Byte64Mask uOp(MUnOp f) { + ByteMask64 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Byte64Mask(res); + return new ByteMask64(res); } @Override - Byte64Mask bOp(VectorMask m, MBinOp f) { + ByteMask64 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Byte64Mask)m).getBits(); + boolean[] mbits = ((ByteMask64)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Byte64Mask(res); + return new ByteMask64(res); } @ForceInline @Override public final - Byte64Vector toVector() { - return (Byte64Vector) super.toVectorTemplate(); // specialize + ByteVector64 toVector() { + return (ByteVector64) super.toVectorTemplate(); // specialize } /** @@ -680,25 +680,25 @@ final class Byte64Vector extends ByteVector { @Override @ForceInline /*package-private*/ - Byte64Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Byte64Mask) VectorSupport.indexPartiallyInUpperRange( - Byte64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Byte64Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + ByteMask64 indexPartiallyInUpperRange(long offset, long limit) { + return (ByteMask64) VectorSupport.indexPartiallyInUpperRange( + ByteMask64.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ByteMask64) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Byte64Mask not() { + public ByteMask64 not() { return xor(maskAll(true)); } @Override @ForceInline - public Byte64Mask compress() { - return (Byte64Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Byte64Vector.class, Byte64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ByteMask64 compress() { + return (ByteMask64)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ByteVector64.class, ByteMask64.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -707,30 +707,30 @@ final class Byte64Vector extends ByteVector { @Override @ForceInline - public Byte64Mask and(VectorMask mask) { + public ByteMask64 and(VectorMask mask) { Objects.requireNonNull(mask); - Byte64Mask m = (Byte64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Byte64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask64 m = (ByteMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ByteMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Byte64Mask or(VectorMask mask) { + public ByteMask64 or(VectorMask mask) { Objects.requireNonNull(mask); - Byte64Mask m = (Byte64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Byte64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask64 m = (ByteMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ByteMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Byte64Mask xor(VectorMask mask) { + public ByteMask64 xor(VectorMask mask) { Objects.requireNonNull(mask); - Byte64Mask m = (Byte64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMask64 m = (ByteMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ByteMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -740,21 +740,21 @@ final class Byte64Vector extends ByteVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Byte64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ByteMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Byte64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ByteMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Byte64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ByteMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -764,7 +764,7 @@ final class Byte64Vector extends ByteVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Byte64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ByteMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -774,7 +774,7 @@ final class Byte64Vector extends ByteVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Byte64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ByteMask64.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -783,48 +783,48 @@ final class Byte64Vector extends ByteVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Byte64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ByteMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Byte64Mask)m).getBits())); + (m, __) -> anyTrueHelper(((ByteMask64)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Byte64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ByteMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Byte64Mask)m).getBits())); + (m, __) -> allTrueHelper(((ByteMask64)m).getBits())); } @ForceInline /*package-private*/ - static Byte64Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Byte64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ByteMask64 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ByteMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Byte64Mask TRUE_MASK = new Byte64Mask(true); - private static final Byte64Mask FALSE_MASK = new Byte64Mask(false); + private static final ByteMask64 TRUE_MASK = new ByteMask64(true); + private static final ByteMask64 FALSE_MASK = new ByteMask64(false); } // Shuffle - static final class Byte64Shuffle extends AbstractShuffle { + static final class ByteShuffle64 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - Byte64Shuffle(byte[] indices) { + ByteShuffle64(byte[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Byte64Shuffle(int[] indices, int i) { + ByteShuffle64(int[] indices, int i) { this(prepare(indices, i)); } - Byte64Shuffle(IntUnaryOperator fn) { + ByteShuffle64(IntUnaryOperator fn) { this(prepare(fn)); } @@ -844,23 +844,23 @@ final class Byte64Vector extends ByteVector { assert(VLENGTH < Byte.MAX_VALUE); assert(Byte.MIN_VALUE <= -VLENGTH); } - static final Byte64Shuffle IOTA = new Byte64Shuffle(IDENTITY); + static final ByteShuffle64 IOTA = new ByteShuffle64(IDENTITY); @Override @ForceInline - public Byte64Vector toVector() { + public ByteVector64 toVector() { return toBitsVector(); } @Override @ForceInline - Byte64Vector toBitsVector() { - return (Byte64Vector) super.toBitsVectorTemplate(); + ByteVector64 toBitsVector() { + return (ByteVector64) super.toBitsVectorTemplate(); } @Override - Byte64Vector toBitsVector0() { - return ((Byte64Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ByteVector64 toBitsVector0() { + return ((ByteVector64) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -909,30 +909,30 @@ final class Byte64Vector extends ByteVector { @Override @ForceInline - public final Byte64Mask laneIsValid() { - return (Byte64Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final ByteMask64 laneIsValid() { + return (ByteMask64) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Byte64Shuffle rearrange(VectorShuffle shuffle) { - Byte64Shuffle concreteShuffle = (Byte64Shuffle) shuffle; - return (Byte64Shuffle) toBitsVector().rearrange(concreteShuffle) + public final ByteShuffle64 rearrange(VectorShuffle shuffle) { + ByteShuffle64 concreteShuffle = (ByteShuffle64) shuffle; + return (ByteShuffle64) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Byte64Shuffle wrapIndexes() { - Byte64Vector v = toBitsVector(); + public final ByteShuffle64 wrapIndexes() { + ByteVector64 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Byte64Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ByteVector64) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Byte64Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ByteVector64) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Byte64Shuffle) v.toShuffle(vspecies(), false); + return (ByteShuffle64) v.toShuffle(vspecies(), false); } private static byte[] prepare(int[] indices, int offset) { @@ -983,14 +983,14 @@ final class Byte64Vector extends ByteVector { @Override final ByteVector fromArray0(byte[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Byte64Mask.class, a, offset, (Byte64Mask) m, offsetInRange); // specialize + return super.fromArray0Template(ByteMask64.class, a, offset, (ByteMask64) m, offsetInRange); // specialize } @ForceInline @Override final ByteVector fromArray0(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Byte64Mask.class, a, offset, indexMap, mapOffset, (Byte64Mask) m); + return super.fromArray0Template(ByteMask64.class, a, offset, indexMap, mapOffset, (ByteMask64) m); } @@ -1005,7 +1005,7 @@ final class Byte64Vector extends ByteVector { @Override final ByteVector fromBooleanArray0(boolean[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromBooleanArray0Template(Byte64Mask.class, a, offset, (Byte64Mask) m, offsetInRange); // specialize + return super.fromBooleanArray0Template(ByteMask64.class, a, offset, (ByteMask64) m, offsetInRange); // specialize } @ForceInline @@ -1019,7 +1019,7 @@ final class Byte64Vector extends ByteVector { @Override final ByteVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Byte64Mask.class, ms, offset, (Byte64Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ByteMask64.class, ms, offset, (ByteMask64) m, offsetInRange); // specialize } @ForceInline @@ -1033,7 +1033,7 @@ final class Byte64Vector extends ByteVector { @Override final void intoArray0(byte[] a, int offset, VectorMask m) { - super.intoArray0Template(Byte64Mask.class, a, offset, (Byte64Mask) m); + super.intoArray0Template(ByteMask64.class, a, offset, (ByteMask64) m); } @@ -1041,14 +1041,14 @@ final class Byte64Vector extends ByteVector { @Override final void intoBooleanArray0(boolean[] a, int offset, VectorMask m) { - super.intoBooleanArray0Template(Byte64Mask.class, a, offset, (Byte64Mask) m); + super.intoBooleanArray0Template(ByteMask64.class, a, offset, (ByteMask64) m); } @ForceInline @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Byte64Mask.class, ms, offset, (Byte64Mask) m); + super.intoMemorySegment0Template(ByteMask64.class, ms, offset, (ByteMask64) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVectorMax.java similarity index 67% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVectorMax.java index 8c3cc68cece..aaf9da19290 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVectorMax.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class ByteMaxVector extends ByteVector { +final class ByteVectorMax extends ByteVector { static final ByteSpecies VSPECIES = (ByteSpecies) ByteVector.SPECIES_MAX; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = ByteMaxVector.class; + static final Class VCLASS = ByteVectorMax.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class ByteMaxVector extends ByteVector { static final Class ETYPE = byte.class; // used by the JVM - ByteMaxVector(byte[] v) { + ByteVectorMax(byte[] v) { super(v); } - // For compatibility as ByteMaxVector::new, + // For compatibility as ByteVectorMax::new, // stored into species.vectorFactory. - ByteMaxVector(Object v) { + ByteVectorMax(Object v) { this((byte[]) v); } - static final ByteMaxVector ZERO = new ByteMaxVector(new byte[VLENGTH]); - static final ByteMaxVector IOTA = new ByteMaxVector(VSPECIES.iotaArray()); + static final ByteVectorMax ZERO = new ByteVectorMax(new byte[VLENGTH]); + static final ByteVectorMax IOTA = new ByteVectorMax(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class ByteMaxVector extends ByteVector { @Override @ForceInline - public final ByteMaxVector broadcast(byte e) { - return (ByteMaxVector) super.broadcastTemplate(e); // specialize + public final ByteVectorMax broadcast(byte e) { + return (ByteVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final ByteMaxVector broadcast(long e) { - return (ByteMaxVector) super.broadcastTemplate(e); // specialize + public final ByteVectorMax broadcast(long e) { + return (ByteVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - ByteMaxMask maskFromArray(boolean[] bits) { - return new ByteMaxMask(bits); + ByteMaskMax maskFromArray(boolean[] bits) { + return new ByteMaskMax(bits); } @Override @ForceInline - ByteMaxShuffle iotaShuffle() { return ByteMaxShuffle.IOTA; } + ByteShuffleMax iotaShuffle() { return ByteShuffleMax.IOTA; } @Override @ForceInline - ByteMaxShuffle iotaShuffle(int start, int step, boolean wrap) { - return (ByteMaxShuffle) iotaShuffleTemplate((byte) start, (byte) step, wrap); + ByteShuffleMax iotaShuffle(int start, int step, boolean wrap) { + return (ByteShuffleMax) iotaShuffleTemplate((byte) start, (byte) step, wrap); } @Override @ForceInline - ByteMaxShuffle shuffleFromArray(int[] indices, int i) { return new ByteMaxShuffle(indices, i); } + ByteShuffleMax shuffleFromArray(int[] indices, int i) { return new ByteShuffleMax(indices, i); } @Override @ForceInline - ByteMaxShuffle shuffleFromOp(IntUnaryOperator fn) { return new ByteMaxShuffle(fn); } + ByteShuffleMax shuffleFromOp(IntUnaryOperator fn) { return new ByteShuffleMax(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - ByteMaxVector vectorFactory(byte[] vec) { - return new ByteMaxVector(vec); + ByteVectorMax vectorFactory(byte[] vec) { + return new ByteVectorMax(vec); } @ForceInline final @Override - ByteMaxVector asByteVectorRaw() { - return (ByteMaxVector) super.asByteVectorRawTemplate(); // specialize + ByteVectorMax asByteVectorRaw() { + return (ByteVectorMax) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class ByteMaxVector extends ByteVector { @ForceInline final @Override - ByteMaxVector uOp(FUnOp f) { - return (ByteMaxVector) super.uOpTemplate(f); // specialize + ByteVectorMax uOp(FUnOp f) { + return (ByteVectorMax) super.uOpTemplate(f); // specialize } @ForceInline final @Override - ByteMaxVector uOp(VectorMask m, FUnOp f) { - return (ByteMaxVector) - super.uOpTemplate((ByteMaxMask)m, f); // specialize + ByteVectorMax uOp(VectorMask m, FUnOp f) { + return (ByteVectorMax) + super.uOpTemplate((ByteMaskMax)m, f); // specialize } // Binary operator @ForceInline final @Override - ByteMaxVector bOp(Vector v, FBinOp f) { - return (ByteMaxVector) super.bOpTemplate((ByteMaxVector)v, f); // specialize + ByteVectorMax bOp(Vector v, FBinOp f) { + return (ByteVectorMax) super.bOpTemplate((ByteVectorMax)v, f); // specialize } @ForceInline final @Override - ByteMaxVector bOp(Vector v, + ByteVectorMax bOp(Vector v, VectorMask m, FBinOp f) { - return (ByteMaxVector) - super.bOpTemplate((ByteMaxVector)v, (ByteMaxMask)m, + return (ByteVectorMax) + super.bOpTemplate((ByteVectorMax)v, (ByteMaskMax)m, f); // specialize } @@ -219,19 +219,19 @@ final class ByteMaxVector extends ByteVector { @ForceInline final @Override - ByteMaxVector tOp(Vector v1, Vector v2, FTriOp f) { - return (ByteMaxVector) - super.tOpTemplate((ByteMaxVector)v1, (ByteMaxVector)v2, + ByteVectorMax tOp(Vector v1, Vector v2, FTriOp f) { + return (ByteVectorMax) + super.tOpTemplate((ByteVectorMax)v1, (ByteVectorMax)v2, f); // specialize } @ForceInline final @Override - ByteMaxVector tOp(Vector v1, Vector v2, + ByteVectorMax tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (ByteMaxVector) - super.tOpTemplate((ByteMaxVector)v1, (ByteMaxVector)v2, - (ByteMaxMask)m, f); // specialize + return (ByteVectorMax) + super.tOpTemplate((ByteVectorMax)v1, (ByteVectorMax)v2, + (ByteMaskMax)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class ByteMaxVector extends ByteVector { @Override @ForceInline - public ByteMaxVector lanewise(Unary op) { - return (ByteMaxVector) super.lanewiseTemplate(op); // specialize + public ByteVectorMax lanewise(Unary op) { + return (ByteVectorMax) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public ByteMaxVector lanewise(Unary op, VectorMask m) { - return (ByteMaxVector) super.lanewiseTemplate(op, ByteMaxMask.class, (ByteMaxMask) m); // specialize + public ByteVectorMax lanewise(Unary op, VectorMask m) { + return (ByteVectorMax) super.lanewiseTemplate(op, ByteMaskMax.class, (ByteMaskMax) m); // specialize } @Override @ForceInline - public ByteMaxVector lanewise(Binary op, Vector v) { - return (ByteMaxVector) super.lanewiseTemplate(op, v); // specialize + public ByteVectorMax lanewise(Binary op, Vector v) { + return (ByteVectorMax) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public ByteMaxVector lanewise(Binary op, Vector v, VectorMask m) { - return (ByteMaxVector) super.lanewiseTemplate(op, ByteMaxMask.class, v, (ByteMaxMask) m); // specialize + public ByteVectorMax lanewise(Binary op, Vector v, VectorMask m) { + return (ByteVectorMax) super.lanewiseTemplate(op, ByteMaskMax.class, v, (ByteMaskMax) m); // specialize } /*package-private*/ @Override - @ForceInline ByteMaxVector + @ForceInline ByteVectorMax lanewiseShift(VectorOperators.Binary op, int e) { - return (ByteMaxVector) super.lanewiseShiftTemplate(op, e); // specialize + return (ByteVectorMax) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline ByteMaxVector + @ForceInline ByteVectorMax lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (ByteMaxVector) super.lanewiseShiftTemplate(op, ByteMaxMask.class, e, (ByteMaxMask) m); // specialize + return (ByteVectorMax) super.lanewiseShiftTemplate(op, ByteMaskMax.class, e, (ByteMaskMax) m); // specialize } /*package-private*/ @Override @ForceInline public final - ByteMaxVector + ByteVectorMax lanewise(Ternary op, Vector v1, Vector v2) { - return (ByteMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ByteVectorMax) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - ByteMaxVector + ByteVectorMax lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (ByteMaxVector) super.lanewiseTemplate(op, ByteMaxMask.class, v1, v2, (ByteMaxMask) m); // specialize + return (ByteVectorMax) super.lanewiseTemplate(op, ByteMaskMax.class, v1, v2, (ByteMaskMax) m); // specialize } @Override @ForceInline public final - ByteMaxVector addIndex(int scale) { - return (ByteMaxVector) super.addIndexTemplate(scale); // specialize + ByteVectorMax addIndex(int scale) { + return (ByteVectorMax) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class ByteMaxVector extends ByteVector { @ForceInline public final byte reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, ByteMaxMask.class, (ByteMaxMask) m); // specialized + return super.reduceLanesTemplate(op, ByteMaskMax.class, (ByteMaskMax) m); // specialized } @Override @@ -354,7 +354,7 @@ final class ByteMaxVector extends ByteVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, ByteMaxMask.class, (ByteMaxMask) m); // specialized + return (long) super.reduceLanesTemplate(op, ByteMaskMax.class, (ByteMaskMax) m); // specialized } @Override @@ -365,160 +365,160 @@ final class ByteMaxVector extends ByteVector { @Override @ForceInline - public final ByteMaxShuffle toShuffle() { - return (ByteMaxShuffle) toShuffle(vspecies(), false); + public final ByteShuffleMax toShuffle() { + return (ByteShuffleMax) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final ByteMaxMask test(Test op) { - return super.testTemplate(ByteMaxMask.class, op); // specialize + public final ByteMaskMax test(Test op) { + return super.testTemplate(ByteMaskMax.class, op); // specialize } @Override @ForceInline - public final ByteMaxMask test(Test op, VectorMask m) { - return super.testTemplate(ByteMaxMask.class, op, (ByteMaxMask) m); // specialize + public final ByteMaskMax test(Test op, VectorMask m) { + return super.testTemplate(ByteMaskMax.class, op, (ByteMaskMax) m); // specialize } // Specialized comparisons @Override @ForceInline - public final ByteMaxMask compare(Comparison op, Vector v) { - return super.compareTemplate(ByteMaxMask.class, op, v); // specialize + public final ByteMaskMax compare(Comparison op, Vector v) { + return super.compareTemplate(ByteMaskMax.class, op, v); // specialize } @Override @ForceInline - public final ByteMaxMask compare(Comparison op, byte s) { - return super.compareTemplate(ByteMaxMask.class, op, s); // specialize + public final ByteMaskMax compare(Comparison op, byte s) { + return super.compareTemplate(ByteMaskMax.class, op, s); // specialize } @Override @ForceInline - public final ByteMaxMask compare(Comparison op, long s) { - return super.compareTemplate(ByteMaxMask.class, op, s); // specialize + public final ByteMaskMax compare(Comparison op, long s) { + return super.compareTemplate(ByteMaskMax.class, op, s); // specialize } @Override @ForceInline - public final ByteMaxMask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(ByteMaxMask.class, op, v, (ByteMaxMask) m); + public final ByteMaskMax compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ByteMaskMax.class, op, v, (ByteMaskMax) m); } @Override @ForceInline - public ByteMaxVector blend(Vector v, VectorMask m) { - return (ByteMaxVector) - super.blendTemplate(ByteMaxMask.class, - (ByteMaxVector) v, - (ByteMaxMask) m); // specialize + public ByteVectorMax blend(Vector v, VectorMask m) { + return (ByteVectorMax) + super.blendTemplate(ByteMaskMax.class, + (ByteVectorMax) v, + (ByteMaskMax) m); // specialize } @Override @ForceInline - public ByteMaxVector slice(int origin, Vector v) { - return (ByteMaxVector) super.sliceTemplate(origin, v); // specialize + public ByteVectorMax slice(int origin, Vector v) { + return (ByteVectorMax) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public ByteMaxVector slice(int origin) { - return (ByteMaxVector) super.sliceTemplate(origin); // specialize + public ByteVectorMax slice(int origin) { + return (ByteVectorMax) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public ByteMaxVector unslice(int origin, Vector w, int part) { - return (ByteMaxVector) super.unsliceTemplate(origin, w, part); // specialize + public ByteVectorMax unslice(int origin, Vector w, int part) { + return (ByteVectorMax) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public ByteMaxVector unslice(int origin, Vector w, int part, VectorMask m) { - return (ByteMaxVector) - super.unsliceTemplate(ByteMaxMask.class, + public ByteVectorMax unslice(int origin, Vector w, int part, VectorMask m) { + return (ByteVectorMax) + super.unsliceTemplate(ByteMaskMax.class, origin, w, part, - (ByteMaxMask) m); // specialize + (ByteMaskMax) m); // specialize } @Override @ForceInline - public ByteMaxVector unslice(int origin) { - return (ByteMaxVector) super.unsliceTemplate(origin); // specialize + public ByteVectorMax unslice(int origin) { + return (ByteVectorMax) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public ByteMaxVector rearrange(VectorShuffle s) { - return (ByteMaxVector) - super.rearrangeTemplate(ByteMaxShuffle.class, - (ByteMaxShuffle) s); // specialize + public ByteVectorMax rearrange(VectorShuffle s) { + return (ByteVectorMax) + super.rearrangeTemplate(ByteShuffleMax.class, + (ByteShuffleMax) s); // specialize } @Override @ForceInline - public ByteMaxVector rearrange(VectorShuffle shuffle, + public ByteVectorMax rearrange(VectorShuffle shuffle, VectorMask m) { - return (ByteMaxVector) - super.rearrangeTemplate(ByteMaxShuffle.class, - ByteMaxMask.class, - (ByteMaxShuffle) shuffle, - (ByteMaxMask) m); // specialize + return (ByteVectorMax) + super.rearrangeTemplate(ByteShuffleMax.class, + ByteMaskMax.class, + (ByteShuffleMax) shuffle, + (ByteMaskMax) m); // specialize } @Override @ForceInline - public ByteMaxVector rearrange(VectorShuffle s, + public ByteVectorMax rearrange(VectorShuffle s, Vector v) { - return (ByteMaxVector) - super.rearrangeTemplate(ByteMaxShuffle.class, - (ByteMaxShuffle) s, - (ByteMaxVector) v); // specialize + return (ByteVectorMax) + super.rearrangeTemplate(ByteShuffleMax.class, + (ByteShuffleMax) s, + (ByteVectorMax) v); // specialize } @Override @ForceInline - public ByteMaxVector compress(VectorMask m) { - return (ByteMaxVector) - super.compressTemplate(ByteMaxMask.class, - (ByteMaxMask) m); // specialize + public ByteVectorMax compress(VectorMask m) { + return (ByteVectorMax) + super.compressTemplate(ByteMaskMax.class, + (ByteMaskMax) m); // specialize } @Override @ForceInline - public ByteMaxVector expand(VectorMask m) { - return (ByteMaxVector) - super.expandTemplate(ByteMaxMask.class, - (ByteMaxMask) m); // specialize + public ByteVectorMax expand(VectorMask m) { + return (ByteVectorMax) + super.expandTemplate(ByteMaskMax.class, + (ByteMaskMax) m); // specialize } @Override @ForceInline - public ByteMaxVector selectFrom(Vector v) { - return (ByteMaxVector) - super.selectFromTemplate((ByteMaxVector) v); // specialize + public ByteVectorMax selectFrom(Vector v) { + return (ByteVectorMax) + super.selectFromTemplate((ByteVectorMax) v); // specialize } @Override @ForceInline - public ByteMaxVector selectFrom(Vector v, + public ByteVectorMax selectFrom(Vector v, VectorMask m) { - return (ByteMaxVector) - super.selectFromTemplate((ByteMaxVector) v, - ByteMaxMask.class, (ByteMaxMask) m); // specialize + return (ByteVectorMax) + super.selectFromTemplate((ByteVectorMax) v, + ByteMaskMax.class, (ByteMaskMax) m); // specialize } @Override @ForceInline - public ByteMaxVector selectFrom(Vector v1, + public ByteVectorMax selectFrom(Vector v1, Vector v2) { - return (ByteMaxVector) - super.selectFromTemplate((ByteMaxVector) v1, (ByteMaxVector) v2); // specialize + return (ByteVectorMax) + super.selectFromTemplate((ByteVectorMax) v1, (ByteVectorMax) v2); // specialize } @ForceInline @@ -543,7 +543,7 @@ final class ByteMaxVector extends ByteVector { @ForceInline @Override - public ByteMaxVector withLane(int i, byte e) { + public ByteVectorMax withLane(int i, byte e) { if (i < 0 || i >= VLENGTH) { throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); } @@ -551,7 +551,7 @@ final class ByteMaxVector extends ByteVector { } @ForceInline - public ByteMaxVector withLaneHelper(int i, byte e) { + public ByteVectorMax withLaneHelper(int i, byte e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -564,19 +564,19 @@ final class ByteMaxVector extends ByteVector { // Mask - static final class ByteMaxMask extends AbstractMask { + static final class ByteMaskMax extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - ByteMaxMask(boolean[] bits) { + ByteMaskMax(boolean[] bits) { this(bits, 0); } - ByteMaxMask(boolean[] bits, int offset) { + ByteMaskMax(boolean[] bits, int offset) { super(prepare(bits, offset)); } - ByteMaxMask(boolean val) { + ByteMaskMax(boolean val) { super(prepare(val)); } @@ -609,31 +609,31 @@ final class ByteMaxVector extends ByteVector { } @Override - ByteMaxMask uOp(MUnOp f) { + ByteMaskMax uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new ByteMaxMask(res); + return new ByteMaskMax(res); } @Override - ByteMaxMask bOp(VectorMask m, MBinOp f) { + ByteMaskMax bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((ByteMaxMask)m).getBits(); + boolean[] mbits = ((ByteMaskMax)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new ByteMaxMask(res); + return new ByteMaskMax(res); } @ForceInline @Override public final - ByteMaxVector toVector() { - return (ByteMaxVector) super.toVectorTemplate(); // specialize + ByteVectorMax toVector() { + return (ByteVectorMax) super.toVectorTemplate(); // specialize } /** @@ -666,25 +666,25 @@ final class ByteMaxVector extends ByteVector { @Override @ForceInline /*package-private*/ - ByteMaxMask indexPartiallyInUpperRange(long offset, long limit) { - return (ByteMaxMask) VectorSupport.indexPartiallyInUpperRange( - ByteMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (ByteMaxMask) TRUE_MASK.indexPartiallyInRange(o, l)); + ByteMaskMax indexPartiallyInUpperRange(long offset, long limit) { + return (ByteMaskMax) VectorSupport.indexPartiallyInUpperRange( + ByteMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ByteMaskMax) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public ByteMaxMask not() { + public ByteMaskMax not() { return xor(maskAll(true)); } @Override @ForceInline - public ByteMaxMask compress() { - return (ByteMaxMask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - ByteMaxVector.class, ByteMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ByteMaskMax compress() { + return (ByteMaskMax)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ByteVectorMax.class, ByteMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -693,30 +693,30 @@ final class ByteMaxVector extends ByteVector { @Override @ForceInline - public ByteMaxMask and(VectorMask mask) { + public ByteMaskMax and(VectorMask mask) { Objects.requireNonNull(mask); - ByteMaxMask m = (ByteMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, ByteMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMaskMax m = (ByteMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ByteMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public ByteMaxMask or(VectorMask mask) { + public ByteMaskMax or(VectorMask mask) { Objects.requireNonNull(mask); - ByteMaxMask m = (ByteMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, ByteMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMaskMax m = (ByteMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ByteMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public ByteMaxMask xor(VectorMask mask) { + public ByteMaskMax xor(VectorMask mask) { Objects.requireNonNull(mask); - ByteMaxMask m = (ByteMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, ByteMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ByteMaskMax m = (ByteMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ByteMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -726,21 +726,21 @@ final class ByteMaxVector extends ByteVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ByteMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ByteMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ByteMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ByteMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ByteMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ByteMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -750,7 +750,7 @@ final class ByteMaxVector extends ByteVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ByteMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ByteMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -760,7 +760,7 @@ final class ByteMaxVector extends ByteVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(ByteMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ByteMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -769,48 +769,48 @@ final class ByteMaxVector extends ByteVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, ByteMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ByteMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((ByteMaxMask)m).getBits())); + (m, __) -> anyTrueHelper(((ByteMaskMax)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, ByteMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ByteMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((ByteMaxMask)m).getBits())); + (m, __) -> allTrueHelper(((ByteMaskMax)m).getBits())); } @ForceInline /*package-private*/ - static ByteMaxMask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(ByteMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ByteMaskMax maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ByteMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final ByteMaxMask TRUE_MASK = new ByteMaxMask(true); - private static final ByteMaxMask FALSE_MASK = new ByteMaxMask(false); + private static final ByteMaskMax TRUE_MASK = new ByteMaskMax(true); + private static final ByteMaskMax FALSE_MASK = new ByteMaskMax(false); } // Shuffle - static final class ByteMaxShuffle extends AbstractShuffle { + static final class ByteShuffleMax extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = byte.class; // used by the JVM - ByteMaxShuffle(byte[] indices) { + ByteShuffleMax(byte[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - ByteMaxShuffle(int[] indices, int i) { + ByteShuffleMax(int[] indices, int i) { this(prepare(indices, i)); } - ByteMaxShuffle(IntUnaryOperator fn) { + ByteShuffleMax(IntUnaryOperator fn) { this(prepare(fn)); } @@ -830,23 +830,23 @@ final class ByteMaxVector extends ByteVector { assert(VLENGTH < Byte.MAX_VALUE); assert(Byte.MIN_VALUE <= -VLENGTH); } - static final ByteMaxShuffle IOTA = new ByteMaxShuffle(IDENTITY); + static final ByteShuffleMax IOTA = new ByteShuffleMax(IDENTITY); @Override @ForceInline - public ByteMaxVector toVector() { + public ByteVectorMax toVector() { return toBitsVector(); } @Override @ForceInline - ByteMaxVector toBitsVector() { - return (ByteMaxVector) super.toBitsVectorTemplate(); + ByteVectorMax toBitsVector() { + return (ByteVectorMax) super.toBitsVectorTemplate(); } @Override - ByteMaxVector toBitsVector0() { - return ((ByteMaxVector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ByteVectorMax toBitsVector0() { + return ((ByteVectorMax) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -895,30 +895,30 @@ final class ByteMaxVector extends ByteVector { @Override @ForceInline - public final ByteMaxMask laneIsValid() { - return (ByteMaxMask) toBitsVector().compare(VectorOperators.GE, 0) + public final ByteMaskMax laneIsValid() { + return (ByteMaskMax) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final ByteMaxShuffle rearrange(VectorShuffle shuffle) { - ByteMaxShuffle concreteShuffle = (ByteMaxShuffle) shuffle; - return (ByteMaxShuffle) toBitsVector().rearrange(concreteShuffle) + public final ByteShuffleMax rearrange(VectorShuffle shuffle) { + ByteShuffleMax concreteShuffle = (ByteShuffleMax) shuffle; + return (ByteShuffleMax) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final ByteMaxShuffle wrapIndexes() { - ByteMaxVector v = toBitsVector(); + public final ByteShuffleMax wrapIndexes() { + ByteVectorMax v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (ByteMaxVector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ByteVectorMax) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (ByteMaxVector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ByteVectorMax) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (ByteMaxShuffle) v.toShuffle(vspecies(), false); + return (ByteShuffleMax) v.toShuffle(vspecies(), false); } private static byte[] prepare(int[] indices, int offset) { @@ -969,14 +969,14 @@ final class ByteMaxVector extends ByteVector { @Override final ByteVector fromArray0(byte[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(ByteMaxMask.class, a, offset, (ByteMaxMask) m, offsetInRange); // specialize + return super.fromArray0Template(ByteMaskMax.class, a, offset, (ByteMaskMax) m, offsetInRange); // specialize } @ForceInline @Override final ByteVector fromArray0(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(ByteMaxMask.class, a, offset, indexMap, mapOffset, (ByteMaxMask) m); + return super.fromArray0Template(ByteMaskMax.class, a, offset, indexMap, mapOffset, (ByteMaskMax) m); } @@ -991,7 +991,7 @@ final class ByteMaxVector extends ByteVector { @Override final ByteVector fromBooleanArray0(boolean[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromBooleanArray0Template(ByteMaxMask.class, a, offset, (ByteMaxMask) m, offsetInRange); // specialize + return super.fromBooleanArray0Template(ByteMaskMax.class, a, offset, (ByteMaskMax) m, offsetInRange); // specialize } @ForceInline @@ -1005,7 +1005,7 @@ final class ByteMaxVector extends ByteVector { @Override final ByteVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(ByteMaxMask.class, ms, offset, (ByteMaxMask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ByteMaskMax.class, ms, offset, (ByteMaskMax) m, offsetInRange); // specialize } @ForceInline @@ -1019,7 +1019,7 @@ final class ByteMaxVector extends ByteVector { @Override final void intoArray0(byte[] a, int offset, VectorMask m) { - super.intoArray0Template(ByteMaxMask.class, a, offset, (ByteMaxMask) m); + super.intoArray0Template(ByteMaskMax.class, a, offset, (ByteMaskMax) m); } @@ -1027,14 +1027,14 @@ final class ByteMaxVector extends ByteVector { @Override final void intoBooleanArray0(boolean[] a, int offset, VectorMask m) { - super.intoBooleanArray0Template(ByteMaxMask.class, a, offset, (ByteMaxMask) m); + super.intoBooleanArray0Template(ByteMaskMax.class, a, offset, (ByteMaskMax) m); } @ForceInline @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(ByteMaxMask.class, ms, offset, (ByteMaxMask) m); + super.intoMemorySegment0Template(ByteMaskMax.class, ms, offset, (ByteMaskMax) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java index 70be5f829f0..519122b4d28 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java @@ -84,8 +84,8 @@ public abstract class DoubleVector extends AbstractVector { // The various shape-specific subclasses // also specialize them by wrapping // them in a call like this: - // return (Byte128Vector) - // super.bOp((Byte128Vector) o); + // return (ByteVector128) + // super.bOp((ByteVector128) o); // The purpose of that is to forcibly inline // the generic definition from this file // into a sharply-typed and size-specific @@ -2921,7 +2921,7 @@ public abstract class DoubleVector extends AbstractVector { // Index vector: vix[0:n] = k -> offset + indexMap[mapOffset + k] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For DoubleMaxVector, if vector length is non-power-of-two or + // For DoubleVectorMax, if vector length is non-power-of-two or // 2048 bits, indexShape of Double species is S_MAX_BIT. // Assume that vector length is 2048, then the lane count of Double // vector is 32. When converting Double species to int species, @@ -2929,7 +2929,7 @@ public abstract class DoubleVector extends AbstractVector { // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -3212,14 +3212,14 @@ public abstract class DoubleVector extends AbstractVector { // Index vector: vix[0:n] = i -> offset + indexMap[mo + i] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For DoubleMaxVector, if vector length is 2048 bits, indexShape + // For DoubleVectorMax, if vector length is 2048 bits, indexShape // of Double species is S_MAX_BIT. and the lane count of Double // vector is 32. When converting Double species to int species, // indexShape is still S_MAX_BIT, but the lane count of int vector // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -3406,7 +3406,7 @@ public abstract class DoubleVector extends AbstractVector { // Index vector: vix[0:n] = k -> offset + indexMap[mapOffset + k] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For DoubleMaxVector, if vector length is non-power-of-two or + // For DoubleVectorMax, if vector length is non-power-of-two or // 2048 bits, indexShape of Double species is S_MAX_BIT. // Assume that vector length is 2048, then the lane count of Double // vector is 32. When converting Double species to int species, @@ -3414,7 +3414,7 @@ public abstract class DoubleVector extends AbstractVector { // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -3522,14 +3522,14 @@ public abstract class DoubleVector extends AbstractVector { // Index vector: vix[0:n] = i -> offset + indexMap[mo + i] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For DoubleMaxVector, if vector length is 2048 bits, indexShape + // For DoubleVectorMax, if vector length is 2048 bits, indexShape // of Double species is S_MAX_BIT. and the lane count of Double // vector is 32. When converting Double species to int species, // indexShape is still S_MAX_BIT, but the lane count of int vector // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -3976,13 +3976,13 @@ public abstract class DoubleVector extends AbstractVector { @Override @ForceInline public final DoubleVector zero() { - if ((Class) vectorType() == DoubleMaxVector.class) - return DoubleMaxVector.ZERO; + if ((Class) vectorType() == DoubleVectorMax.class) + return DoubleVectorMax.ZERO; switch (vectorBitSize()) { - case 64: return Double64Vector.ZERO; - case 128: return Double128Vector.ZERO; - case 256: return Double256Vector.ZERO; - case 512: return Double512Vector.ZERO; + case 64: return DoubleVector64.ZERO; + case 128: return DoubleVector128.ZERO; + case 256: return DoubleVector256.ZERO; + case 512: return DoubleVector512.ZERO; } throw new AssertionError(); } @@ -3990,13 +3990,13 @@ public abstract class DoubleVector extends AbstractVector { @Override @ForceInline public final DoubleVector iota() { - if ((Class) vectorType() == DoubleMaxVector.class) - return DoubleMaxVector.IOTA; + if ((Class) vectorType() == DoubleVectorMax.class) + return DoubleVectorMax.IOTA; switch (vectorBitSize()) { - case 64: return Double64Vector.IOTA; - case 128: return Double128Vector.IOTA; - case 256: return Double256Vector.IOTA; - case 512: return Double512Vector.IOTA; + case 64: return DoubleVector64.IOTA; + case 128: return DoubleVector128.IOTA; + case 256: return DoubleVector256.IOTA; + case 512: return DoubleVector512.IOTA; } throw new AssertionError(); } @@ -4005,13 +4005,13 @@ public abstract class DoubleVector extends AbstractVector { @Override @ForceInline public final VectorMask maskAll(boolean bit) { - if ((Class) vectorType() == DoubleMaxVector.class) - return DoubleMaxVector.DoubleMaxMask.maskAll(bit); + if ((Class) vectorType() == DoubleVectorMax.class) + return DoubleVectorMax.DoubleMaskMax.maskAll(bit); switch (vectorBitSize()) { - case 64: return Double64Vector.Double64Mask.maskAll(bit); - case 128: return Double128Vector.Double128Mask.maskAll(bit); - case 256: return Double256Vector.Double256Mask.maskAll(bit); - case 512: return Double512Vector.Double512Mask.maskAll(bit); + case 64: return DoubleVector64.DoubleMask64.maskAll(bit); + case 128: return DoubleVector128.DoubleMask128.maskAll(bit); + case 256: return DoubleVector256.DoubleMask256.maskAll(bit); + case 512: return DoubleVector512.DoubleMask512.maskAll(bit); } throw new AssertionError(); } @@ -4039,42 +4039,42 @@ public abstract class DoubleVector extends AbstractVector { /** Species representing {@link DoubleVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ public static final VectorSpecies SPECIES_64 = new DoubleSpecies(VectorShape.S_64_BIT, - Double64Vector.class, - Double64Vector.Double64Mask.class, - Double64Vector.Double64Shuffle.class, - Double64Vector::new); + DoubleVector64.class, + DoubleVector64.DoubleMask64.class, + DoubleVector64.DoubleShuffle64.class, + DoubleVector64::new); /** Species representing {@link DoubleVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ public static final VectorSpecies SPECIES_128 = new DoubleSpecies(VectorShape.S_128_BIT, - Double128Vector.class, - Double128Vector.Double128Mask.class, - Double128Vector.Double128Shuffle.class, - Double128Vector::new); + DoubleVector128.class, + DoubleVector128.DoubleMask128.class, + DoubleVector128.DoubleShuffle128.class, + DoubleVector128::new); /** Species representing {@link DoubleVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ public static final VectorSpecies SPECIES_256 = new DoubleSpecies(VectorShape.S_256_BIT, - Double256Vector.class, - Double256Vector.Double256Mask.class, - Double256Vector.Double256Shuffle.class, - Double256Vector::new); + DoubleVector256.class, + DoubleVector256.DoubleMask256.class, + DoubleVector256.DoubleShuffle256.class, + DoubleVector256::new); /** Species representing {@link DoubleVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ public static final VectorSpecies SPECIES_512 = new DoubleSpecies(VectorShape.S_512_BIT, - Double512Vector.class, - Double512Vector.Double512Mask.class, - Double512Vector.Double512Shuffle.class, - Double512Vector::new); + DoubleVector512.class, + DoubleVector512.DoubleMask512.class, + DoubleVector512.DoubleShuffle512.class, + DoubleVector512::new); /** Species representing {@link DoubleVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ public static final VectorSpecies SPECIES_MAX = new DoubleSpecies(VectorShape.S_Max_BIT, - DoubleMaxVector.class, - DoubleMaxVector.DoubleMaxMask.class, - DoubleMaxVector.DoubleMaxShuffle.class, - DoubleMaxVector::new); + DoubleVectorMax.class, + DoubleVectorMax.DoubleMaskMax.class, + DoubleVectorMax.DoubleShuffleMax.class, + DoubleVectorMax::new); /** * Preferred species for {@link DoubleVector}s. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector128.java similarity index 67% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector128.java index f00efcf5163..1cd47ec6f84 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector128.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Double128Vector extends DoubleVector { +final class DoubleVector128 extends DoubleVector { static final DoubleSpecies VSPECIES = (DoubleSpecies) DoubleVector.SPECIES_128; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Double128Vector.class; + static final Class VCLASS = DoubleVector128.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Double128Vector extends DoubleVector { static final Class ETYPE = double.class; // used by the JVM - Double128Vector(double[] v) { + DoubleVector128(double[] v) { super(v); } - // For compatibility as Double128Vector::new, + // For compatibility as DoubleVector128::new, // stored into species.vectorFactory. - Double128Vector(Object v) { + DoubleVector128(Object v) { this((double[]) v); } - static final Double128Vector ZERO = new Double128Vector(new double[VLENGTH]); - static final Double128Vector IOTA = new Double128Vector(VSPECIES.iotaArray()); + static final DoubleVector128 ZERO = new DoubleVector128(new double[VLENGTH]); + static final DoubleVector128 IOTA = new DoubleVector128(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline - public final Double128Vector broadcast(double e) { - return (Double128Vector) super.broadcastTemplate(e); // specialize + public final DoubleVector128 broadcast(double e) { + return (DoubleVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Double128Vector broadcast(long e) { - return (Double128Vector) super.broadcastTemplate(e); // specialize + public final DoubleVector128 broadcast(long e) { + return (DoubleVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Double128Mask maskFromArray(boolean[] bits) { - return new Double128Mask(bits); + DoubleMask128 maskFromArray(boolean[] bits) { + return new DoubleMask128(bits); } @Override @ForceInline - Double128Shuffle iotaShuffle() { return Double128Shuffle.IOTA; } + DoubleShuffle128 iotaShuffle() { return DoubleShuffle128.IOTA; } @Override @ForceInline - Double128Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Double128Shuffle) iotaShuffleTemplate(start, step, wrap); + DoubleShuffle128 iotaShuffle(int start, int step, boolean wrap) { + return (DoubleShuffle128) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Double128Shuffle shuffleFromArray(int[] indices, int i) { return new Double128Shuffle(indices, i); } + DoubleShuffle128 shuffleFromArray(int[] indices, int i) { return new DoubleShuffle128(indices, i); } @Override @ForceInline - Double128Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Double128Shuffle(fn); } + DoubleShuffle128 shuffleFromOp(IntUnaryOperator fn) { return new DoubleShuffle128(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Double128Vector vectorFactory(double[] vec) { - return new Double128Vector(vec); + DoubleVector128 vectorFactory(double[] vec) { + return new DoubleVector128(vec); } @ForceInline final @Override - Byte128Vector asByteVectorRaw() { - return (Byte128Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector128 asByteVectorRaw() { + return (ByteVector128) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Double128Vector extends DoubleVector { @ForceInline final @Override - Double128Vector uOp(FUnOp f) { - return (Double128Vector) super.uOpTemplate(f); // specialize + DoubleVector128 uOp(FUnOp f) { + return (DoubleVector128) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Double128Vector uOp(VectorMask m, FUnOp f) { - return (Double128Vector) - super.uOpTemplate((Double128Mask)m, f); // specialize + DoubleVector128 uOp(VectorMask m, FUnOp f) { + return (DoubleVector128) + super.uOpTemplate((DoubleMask128)m, f); // specialize } // Binary operator @ForceInline final @Override - Double128Vector bOp(Vector v, FBinOp f) { - return (Double128Vector) super.bOpTemplate((Double128Vector)v, f); // specialize + DoubleVector128 bOp(Vector v, FBinOp f) { + return (DoubleVector128) super.bOpTemplate((DoubleVector128)v, f); // specialize } @ForceInline final @Override - Double128Vector bOp(Vector v, + DoubleVector128 bOp(Vector v, VectorMask m, FBinOp f) { - return (Double128Vector) - super.bOpTemplate((Double128Vector)v, (Double128Mask)m, + return (DoubleVector128) + super.bOpTemplate((DoubleVector128)v, (DoubleMask128)m, f); // specialize } @@ -219,19 +219,19 @@ final class Double128Vector extends DoubleVector { @ForceInline final @Override - Double128Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Double128Vector) - super.tOpTemplate((Double128Vector)v1, (Double128Vector)v2, + DoubleVector128 tOp(Vector v1, Vector v2, FTriOp f) { + return (DoubleVector128) + super.tOpTemplate((DoubleVector128)v1, (DoubleVector128)v2, f); // specialize } @ForceInline final @Override - Double128Vector tOp(Vector v1, Vector v2, + DoubleVector128 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Double128Vector) - super.tOpTemplate((Double128Vector)v1, (Double128Vector)v2, - (Double128Mask)m, f); // specialize + return (DoubleVector128) + super.tOpTemplate((DoubleVector128)v1, (DoubleVector128)v2, + (DoubleMask128)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline - public Double128Vector lanewise(Unary op) { - return (Double128Vector) super.lanewiseTemplate(op); // specialize + public DoubleVector128 lanewise(Unary op) { + return (DoubleVector128) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Double128Vector lanewise(Unary op, VectorMask m) { - return (Double128Vector) super.lanewiseTemplate(op, Double128Mask.class, (Double128Mask) m); // specialize + public DoubleVector128 lanewise(Unary op, VectorMask m) { + return (DoubleVector128) super.lanewiseTemplate(op, DoubleMask128.class, (DoubleMask128) m); // specialize } @Override @ForceInline - public Double128Vector lanewise(Binary op, Vector v) { - return (Double128Vector) super.lanewiseTemplate(op, v); // specialize + public DoubleVector128 lanewise(Binary op, Vector v) { + return (DoubleVector128) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Double128Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Double128Vector) super.lanewiseTemplate(op, Double128Mask.class, v, (Double128Mask) m); // specialize + public DoubleVector128 lanewise(Binary op, Vector v, VectorMask m) { + return (DoubleVector128) super.lanewiseTemplate(op, DoubleMask128.class, v, (DoubleMask128) m); // specialize } @@ -296,24 +296,24 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline public final - Double128Vector + DoubleVector128 lanewise(Ternary op, Vector v1, Vector v2) { - return (Double128Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (DoubleVector128) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Double128Vector + DoubleVector128 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Double128Vector) super.lanewiseTemplate(op, Double128Mask.class, v1, v2, (Double128Mask) m); // specialize + return (DoubleVector128) super.lanewiseTemplate(op, DoubleMask128.class, v1, v2, (DoubleMask128) m); // specialize } @Override @ForceInline public final - Double128Vector addIndex(int scale) { - return (Double128Vector) super.addIndexTemplate(scale); // specialize + DoubleVector128 addIndex(int scale) { + return (DoubleVector128) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class Double128Vector extends DoubleVector { @ForceInline public final double reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Double128Mask.class, (Double128Mask) m); // specialized + return super.reduceLanesTemplate(op, DoubleMask128.class, (DoubleMask128) m); // specialized } @Override @@ -341,7 +341,7 @@ final class Double128Vector extends DoubleVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Double128Mask.class, (Double128Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, DoubleMask128.class, (DoubleMask128) m); // specialized } @Override @@ -352,160 +352,160 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline - public final Double128Shuffle toShuffle() { - return (Double128Shuffle) toShuffle(vspecies(), false); + public final DoubleShuffle128 toShuffle() { + return (DoubleShuffle128) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Double128Mask test(Test op) { - return super.testTemplate(Double128Mask.class, op); // specialize + public final DoubleMask128 test(Test op) { + return super.testTemplate(DoubleMask128.class, op); // specialize } @Override @ForceInline - public final Double128Mask test(Test op, VectorMask m) { - return super.testTemplate(Double128Mask.class, op, (Double128Mask) m); // specialize + public final DoubleMask128 test(Test op, VectorMask m) { + return super.testTemplate(DoubleMask128.class, op, (DoubleMask128) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Double128Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Double128Mask.class, op, v); // specialize + public final DoubleMask128 compare(Comparison op, Vector v) { + return super.compareTemplate(DoubleMask128.class, op, v); // specialize } @Override @ForceInline - public final Double128Mask compare(Comparison op, double s) { - return super.compareTemplate(Double128Mask.class, op, s); // specialize + public final DoubleMask128 compare(Comparison op, double s) { + return super.compareTemplate(DoubleMask128.class, op, s); // specialize } @Override @ForceInline - public final Double128Mask compare(Comparison op, long s) { - return super.compareTemplate(Double128Mask.class, op, s); // specialize + public final DoubleMask128 compare(Comparison op, long s) { + return super.compareTemplate(DoubleMask128.class, op, s); // specialize } @Override @ForceInline - public final Double128Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Double128Mask.class, op, v, (Double128Mask) m); + public final DoubleMask128 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(DoubleMask128.class, op, v, (DoubleMask128) m); } @Override @ForceInline - public Double128Vector blend(Vector v, VectorMask m) { - return (Double128Vector) - super.blendTemplate(Double128Mask.class, - (Double128Vector) v, - (Double128Mask) m); // specialize + public DoubleVector128 blend(Vector v, VectorMask m) { + return (DoubleVector128) + super.blendTemplate(DoubleMask128.class, + (DoubleVector128) v, + (DoubleMask128) m); // specialize } @Override @ForceInline - public Double128Vector slice(int origin, Vector v) { - return (Double128Vector) super.sliceTemplate(origin, v); // specialize + public DoubleVector128 slice(int origin, Vector v) { + return (DoubleVector128) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Double128Vector slice(int origin) { - return (Double128Vector) super.sliceTemplate(origin); // specialize + public DoubleVector128 slice(int origin) { + return (DoubleVector128) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Double128Vector unslice(int origin, Vector w, int part) { - return (Double128Vector) super.unsliceTemplate(origin, w, part); // specialize + public DoubleVector128 unslice(int origin, Vector w, int part) { + return (DoubleVector128) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Double128Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Double128Vector) - super.unsliceTemplate(Double128Mask.class, + public DoubleVector128 unslice(int origin, Vector w, int part, VectorMask m) { + return (DoubleVector128) + super.unsliceTemplate(DoubleMask128.class, origin, w, part, - (Double128Mask) m); // specialize + (DoubleMask128) m); // specialize } @Override @ForceInline - public Double128Vector unslice(int origin) { - return (Double128Vector) super.unsliceTemplate(origin); // specialize + public DoubleVector128 unslice(int origin) { + return (DoubleVector128) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Double128Vector rearrange(VectorShuffle s) { - return (Double128Vector) - super.rearrangeTemplate(Double128Shuffle.class, - (Double128Shuffle) s); // specialize + public DoubleVector128 rearrange(VectorShuffle s) { + return (DoubleVector128) + super.rearrangeTemplate(DoubleShuffle128.class, + (DoubleShuffle128) s); // specialize } @Override @ForceInline - public Double128Vector rearrange(VectorShuffle shuffle, + public DoubleVector128 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Double128Vector) - super.rearrangeTemplate(Double128Shuffle.class, - Double128Mask.class, - (Double128Shuffle) shuffle, - (Double128Mask) m); // specialize + return (DoubleVector128) + super.rearrangeTemplate(DoubleShuffle128.class, + DoubleMask128.class, + (DoubleShuffle128) shuffle, + (DoubleMask128) m); // specialize } @Override @ForceInline - public Double128Vector rearrange(VectorShuffle s, + public DoubleVector128 rearrange(VectorShuffle s, Vector v) { - return (Double128Vector) - super.rearrangeTemplate(Double128Shuffle.class, - (Double128Shuffle) s, - (Double128Vector) v); // specialize + return (DoubleVector128) + super.rearrangeTemplate(DoubleShuffle128.class, + (DoubleShuffle128) s, + (DoubleVector128) v); // specialize } @Override @ForceInline - public Double128Vector compress(VectorMask m) { - return (Double128Vector) - super.compressTemplate(Double128Mask.class, - (Double128Mask) m); // specialize + public DoubleVector128 compress(VectorMask m) { + return (DoubleVector128) + super.compressTemplate(DoubleMask128.class, + (DoubleMask128) m); // specialize } @Override @ForceInline - public Double128Vector expand(VectorMask m) { - return (Double128Vector) - super.expandTemplate(Double128Mask.class, - (Double128Mask) m); // specialize + public DoubleVector128 expand(VectorMask m) { + return (DoubleVector128) + super.expandTemplate(DoubleMask128.class, + (DoubleMask128) m); // specialize } @Override @ForceInline - public Double128Vector selectFrom(Vector v) { - return (Double128Vector) - super.selectFromTemplate((Double128Vector) v); // specialize + public DoubleVector128 selectFrom(Vector v) { + return (DoubleVector128) + super.selectFromTemplate((DoubleVector128) v); // specialize } @Override @ForceInline - public Double128Vector selectFrom(Vector v, + public DoubleVector128 selectFrom(Vector v, VectorMask m) { - return (Double128Vector) - super.selectFromTemplate((Double128Vector) v, - Double128Mask.class, (Double128Mask) m); // specialize + return (DoubleVector128) + super.selectFromTemplate((DoubleVector128) v, + DoubleMask128.class, (DoubleMask128) m); // specialize } @Override @ForceInline - public Double128Vector selectFrom(Vector v1, + public DoubleVector128 selectFrom(Vector v1, Vector v2) { - return (Double128Vector) - super.selectFromTemplate((Double128Vector) v1, (Double128Vector) v2); // specialize + return (DoubleVector128) + super.selectFromTemplate((DoubleVector128) v1, (DoubleVector128) v2); // specialize } @ForceInline @@ -533,7 +533,7 @@ final class Double128Vector extends DoubleVector { @ForceInline @Override - public Double128Vector withLane(int i, double e) { + public DoubleVector128 withLane(int i, double e) { switch(i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -542,7 +542,7 @@ final class Double128Vector extends DoubleVector { } @ForceInline - public Double128Vector withLaneHelper(int i, double e) { + public DoubleVector128 withLaneHelper(int i, double e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Double.doubleToRawLongBits(e), @@ -555,19 +555,19 @@ final class Double128Vector extends DoubleVector { // Mask - static final class Double128Mask extends AbstractMask { + static final class DoubleMask128 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = double.class; // used by the JVM - Double128Mask(boolean[] bits) { + DoubleMask128(boolean[] bits) { this(bits, 0); } - Double128Mask(boolean[] bits, int offset) { + DoubleMask128(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Double128Mask(boolean val) { + DoubleMask128(boolean val) { super(prepare(val)); } @@ -600,31 +600,31 @@ final class Double128Vector extends DoubleVector { } @Override - Double128Mask uOp(MUnOp f) { + DoubleMask128 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Double128Mask(res); + return new DoubleMask128(res); } @Override - Double128Mask bOp(VectorMask m, MBinOp f) { + DoubleMask128 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Double128Mask)m).getBits(); + boolean[] mbits = ((DoubleMask128)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Double128Mask(res); + return new DoubleMask128(res); } @ForceInline @Override public final - Double128Vector toVector() { - return (Double128Vector) super.toVectorTemplate(); // specialize + DoubleVector128 toVector() { + return (DoubleVector128) super.toVectorTemplate(); // specialize } /** @@ -657,25 +657,25 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline /*package-private*/ - Double128Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Double128Mask) VectorSupport.indexPartiallyInUpperRange( - Double128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Double128Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + DoubleMask128 indexPartiallyInUpperRange(long offset, long limit) { + return (DoubleMask128) VectorSupport.indexPartiallyInUpperRange( + DoubleMask128.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (DoubleMask128) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Double128Mask not() { + public DoubleMask128 not() { return xor(maskAll(true)); } @Override @ForceInline - public Double128Mask compress() { - return (Double128Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Double128Vector.class, Double128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public DoubleMask128 compress() { + return (DoubleMask128)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + DoubleVector128.class, DoubleMask128.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -684,30 +684,30 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline - public Double128Mask and(VectorMask mask) { + public DoubleMask128 and(VectorMask mask) { Objects.requireNonNull(mask); - Double128Mask m = (Double128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Double128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask128 m = (DoubleMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, DoubleMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Double128Mask or(VectorMask mask) { + public DoubleMask128 or(VectorMask mask) { Objects.requireNonNull(mask); - Double128Mask m = (Double128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Double128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask128 m = (DoubleMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, DoubleMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Double128Mask xor(VectorMask mask) { + public DoubleMask128 xor(VectorMask mask) { Objects.requireNonNull(mask); - Double128Mask m = (Double128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Double128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask128 m = (DoubleMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -717,21 +717,21 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Double128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, DoubleMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Double128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, DoubleMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Double128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, DoubleMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -741,7 +741,7 @@ final class Double128Vector extends DoubleVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Double128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, DoubleMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -751,7 +751,7 @@ final class Double128Vector extends DoubleVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Double128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(DoubleMask128.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -760,48 +760,48 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Double128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, DoubleMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Double128Mask)m).getBits())); + (m, __) -> anyTrueHelper(((DoubleMask128)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Double128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, DoubleMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Double128Mask)m).getBits())); + (m, __) -> allTrueHelper(((DoubleMask128)m).getBits())); } @ForceInline /*package-private*/ - static Double128Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Double128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static DoubleMask128 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(DoubleMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Double128Mask TRUE_MASK = new Double128Mask(true); - private static final Double128Mask FALSE_MASK = new Double128Mask(false); + private static final DoubleMask128 TRUE_MASK = new DoubleMask128(true); + private static final DoubleMask128 FALSE_MASK = new DoubleMask128(false); } // Shuffle - static final class Double128Shuffle extends AbstractShuffle { + static final class DoubleShuffle128 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Double128Shuffle(long[] indices) { + DoubleShuffle128(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Double128Shuffle(int[] indices, int i) { + DoubleShuffle128(int[] indices, int i) { this(prepare(indices, i)); } - Double128Shuffle(IntUnaryOperator fn) { + DoubleShuffle128(IntUnaryOperator fn) { this(prepare(fn)); } @@ -821,23 +821,23 @@ final class Double128Vector extends DoubleVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final Double128Shuffle IOTA = new Double128Shuffle(IDENTITY); + static final DoubleShuffle128 IOTA = new DoubleShuffle128(IDENTITY); @Override @ForceInline - public Double128Vector toVector() { - return (Double128Vector) toBitsVector().castShape(vspecies(), 0); + public DoubleVector128 toVector() { + return (DoubleVector128) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - Long128Vector toBitsVector() { - return (Long128Vector) super.toBitsVectorTemplate(); + LongVector128 toBitsVector() { + return (LongVector128) super.toBitsVectorTemplate(); } @Override - Long128Vector toBitsVector0() { - return ((Long128Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVector128 toBitsVector0() { + return ((LongVector128) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -909,30 +909,30 @@ final class Double128Vector extends DoubleVector { @Override @ForceInline - public final Double128Mask laneIsValid() { - return (Double128Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final DoubleMask128 laneIsValid() { + return (DoubleMask128) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Double128Shuffle rearrange(VectorShuffle shuffle) { - Double128Shuffle concreteShuffle = (Double128Shuffle) shuffle; - return (Double128Shuffle) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_128)) + public final DoubleShuffle128 rearrange(VectorShuffle shuffle) { + DoubleShuffle128 concreteShuffle = (DoubleShuffle128) shuffle; + return (DoubleShuffle128) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_128)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Double128Shuffle wrapIndexes() { - Long128Vector v = toBitsVector(); + public final DoubleShuffle128 wrapIndexes() { + LongVector128 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Long128Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVector128) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Long128Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVector128) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Double128Shuffle) v.toShuffle(vspecies(), false); + return (DoubleShuffle128) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -983,14 +983,14 @@ final class Double128Vector extends DoubleVector { @Override final DoubleVector fromArray0(double[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Double128Mask.class, a, offset, (Double128Mask) m, offsetInRange); // specialize + return super.fromArray0Template(DoubleMask128.class, a, offset, (DoubleMask128) m, offsetInRange); // specialize } @ForceInline @Override final DoubleVector fromArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Double128Mask.class, a, offset, indexMap, mapOffset, (Double128Mask) m); + return super.fromArray0Template(DoubleMask128.class, a, offset, indexMap, mapOffset, (DoubleMask128) m); } @@ -1006,7 +1006,7 @@ final class Double128Vector extends DoubleVector { @Override final DoubleVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Double128Mask.class, ms, offset, (Double128Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(DoubleMask128.class, ms, offset, (DoubleMask128) m, offsetInRange); // specialize } @ForceInline @@ -1020,14 +1020,14 @@ final class Double128Vector extends DoubleVector { @Override final void intoArray0(double[] a, int offset, VectorMask m) { - super.intoArray0Template(Double128Mask.class, a, offset, (Double128Mask) m); + super.intoArray0Template(DoubleMask128.class, a, offset, (DoubleMask128) m); } @ForceInline @Override final void intoArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Double128Mask.class, a, offset, indexMap, mapOffset, (Double128Mask) m); + super.intoArray0Template(DoubleMask128.class, a, offset, indexMap, mapOffset, (DoubleMask128) m); } @@ -1035,7 +1035,7 @@ final class Double128Vector extends DoubleVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Double128Mask.class, ms, offset, (Double128Mask) m); + super.intoMemorySegment0Template(DoubleMask128.class, ms, offset, (DoubleMask128) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector256.java similarity index 67% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector256.java index 0f145bf06e2..ab9c6ee0557 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector256.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Double256Vector extends DoubleVector { +final class DoubleVector256 extends DoubleVector { static final DoubleSpecies VSPECIES = (DoubleSpecies) DoubleVector.SPECIES_256; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Double256Vector.class; + static final Class VCLASS = DoubleVector256.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Double256Vector extends DoubleVector { static final Class ETYPE = double.class; // used by the JVM - Double256Vector(double[] v) { + DoubleVector256(double[] v) { super(v); } - // For compatibility as Double256Vector::new, + // For compatibility as DoubleVector256::new, // stored into species.vectorFactory. - Double256Vector(Object v) { + DoubleVector256(Object v) { this((double[]) v); } - static final Double256Vector ZERO = new Double256Vector(new double[VLENGTH]); - static final Double256Vector IOTA = new Double256Vector(VSPECIES.iotaArray()); + static final DoubleVector256 ZERO = new DoubleVector256(new double[VLENGTH]); + static final DoubleVector256 IOTA = new DoubleVector256(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline - public final Double256Vector broadcast(double e) { - return (Double256Vector) super.broadcastTemplate(e); // specialize + public final DoubleVector256 broadcast(double e) { + return (DoubleVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Double256Vector broadcast(long e) { - return (Double256Vector) super.broadcastTemplate(e); // specialize + public final DoubleVector256 broadcast(long e) { + return (DoubleVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Double256Mask maskFromArray(boolean[] bits) { - return new Double256Mask(bits); + DoubleMask256 maskFromArray(boolean[] bits) { + return new DoubleMask256(bits); } @Override @ForceInline - Double256Shuffle iotaShuffle() { return Double256Shuffle.IOTA; } + DoubleShuffle256 iotaShuffle() { return DoubleShuffle256.IOTA; } @Override @ForceInline - Double256Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Double256Shuffle) iotaShuffleTemplate(start, step, wrap); + DoubleShuffle256 iotaShuffle(int start, int step, boolean wrap) { + return (DoubleShuffle256) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Double256Shuffle shuffleFromArray(int[] indices, int i) { return new Double256Shuffle(indices, i); } + DoubleShuffle256 shuffleFromArray(int[] indices, int i) { return new DoubleShuffle256(indices, i); } @Override @ForceInline - Double256Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Double256Shuffle(fn); } + DoubleShuffle256 shuffleFromOp(IntUnaryOperator fn) { return new DoubleShuffle256(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Double256Vector vectorFactory(double[] vec) { - return new Double256Vector(vec); + DoubleVector256 vectorFactory(double[] vec) { + return new DoubleVector256(vec); } @ForceInline final @Override - Byte256Vector asByteVectorRaw() { - return (Byte256Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector256 asByteVectorRaw() { + return (ByteVector256) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Double256Vector extends DoubleVector { @ForceInline final @Override - Double256Vector uOp(FUnOp f) { - return (Double256Vector) super.uOpTemplate(f); // specialize + DoubleVector256 uOp(FUnOp f) { + return (DoubleVector256) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Double256Vector uOp(VectorMask m, FUnOp f) { - return (Double256Vector) - super.uOpTemplate((Double256Mask)m, f); // specialize + DoubleVector256 uOp(VectorMask m, FUnOp f) { + return (DoubleVector256) + super.uOpTemplate((DoubleMask256)m, f); // specialize } // Binary operator @ForceInline final @Override - Double256Vector bOp(Vector v, FBinOp f) { - return (Double256Vector) super.bOpTemplate((Double256Vector)v, f); // specialize + DoubleVector256 bOp(Vector v, FBinOp f) { + return (DoubleVector256) super.bOpTemplate((DoubleVector256)v, f); // specialize } @ForceInline final @Override - Double256Vector bOp(Vector v, + DoubleVector256 bOp(Vector v, VectorMask m, FBinOp f) { - return (Double256Vector) - super.bOpTemplate((Double256Vector)v, (Double256Mask)m, + return (DoubleVector256) + super.bOpTemplate((DoubleVector256)v, (DoubleMask256)m, f); // specialize } @@ -219,19 +219,19 @@ final class Double256Vector extends DoubleVector { @ForceInline final @Override - Double256Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Double256Vector) - super.tOpTemplate((Double256Vector)v1, (Double256Vector)v2, + DoubleVector256 tOp(Vector v1, Vector v2, FTriOp f) { + return (DoubleVector256) + super.tOpTemplate((DoubleVector256)v1, (DoubleVector256)v2, f); // specialize } @ForceInline final @Override - Double256Vector tOp(Vector v1, Vector v2, + DoubleVector256 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Double256Vector) - super.tOpTemplate((Double256Vector)v1, (Double256Vector)v2, - (Double256Mask)m, f); // specialize + return (DoubleVector256) + super.tOpTemplate((DoubleVector256)v1, (DoubleVector256)v2, + (DoubleMask256)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline - public Double256Vector lanewise(Unary op) { - return (Double256Vector) super.lanewiseTemplate(op); // specialize + public DoubleVector256 lanewise(Unary op) { + return (DoubleVector256) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Double256Vector lanewise(Unary op, VectorMask m) { - return (Double256Vector) super.lanewiseTemplate(op, Double256Mask.class, (Double256Mask) m); // specialize + public DoubleVector256 lanewise(Unary op, VectorMask m) { + return (DoubleVector256) super.lanewiseTemplate(op, DoubleMask256.class, (DoubleMask256) m); // specialize } @Override @ForceInline - public Double256Vector lanewise(Binary op, Vector v) { - return (Double256Vector) super.lanewiseTemplate(op, v); // specialize + public DoubleVector256 lanewise(Binary op, Vector v) { + return (DoubleVector256) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Double256Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Double256Vector) super.lanewiseTemplate(op, Double256Mask.class, v, (Double256Mask) m); // specialize + public DoubleVector256 lanewise(Binary op, Vector v, VectorMask m) { + return (DoubleVector256) super.lanewiseTemplate(op, DoubleMask256.class, v, (DoubleMask256) m); // specialize } @@ -296,24 +296,24 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline public final - Double256Vector + DoubleVector256 lanewise(Ternary op, Vector v1, Vector v2) { - return (Double256Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (DoubleVector256) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Double256Vector + DoubleVector256 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Double256Vector) super.lanewiseTemplate(op, Double256Mask.class, v1, v2, (Double256Mask) m); // specialize + return (DoubleVector256) super.lanewiseTemplate(op, DoubleMask256.class, v1, v2, (DoubleMask256) m); // specialize } @Override @ForceInline public final - Double256Vector addIndex(int scale) { - return (Double256Vector) super.addIndexTemplate(scale); // specialize + DoubleVector256 addIndex(int scale) { + return (DoubleVector256) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class Double256Vector extends DoubleVector { @ForceInline public final double reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Double256Mask.class, (Double256Mask) m); // specialized + return super.reduceLanesTemplate(op, DoubleMask256.class, (DoubleMask256) m); // specialized } @Override @@ -341,7 +341,7 @@ final class Double256Vector extends DoubleVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Double256Mask.class, (Double256Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, DoubleMask256.class, (DoubleMask256) m); // specialized } @Override @@ -352,160 +352,160 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline - public final Double256Shuffle toShuffle() { - return (Double256Shuffle) toShuffle(vspecies(), false); + public final DoubleShuffle256 toShuffle() { + return (DoubleShuffle256) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Double256Mask test(Test op) { - return super.testTemplate(Double256Mask.class, op); // specialize + public final DoubleMask256 test(Test op) { + return super.testTemplate(DoubleMask256.class, op); // specialize } @Override @ForceInline - public final Double256Mask test(Test op, VectorMask m) { - return super.testTemplate(Double256Mask.class, op, (Double256Mask) m); // specialize + public final DoubleMask256 test(Test op, VectorMask m) { + return super.testTemplate(DoubleMask256.class, op, (DoubleMask256) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Double256Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Double256Mask.class, op, v); // specialize + public final DoubleMask256 compare(Comparison op, Vector v) { + return super.compareTemplate(DoubleMask256.class, op, v); // specialize } @Override @ForceInline - public final Double256Mask compare(Comparison op, double s) { - return super.compareTemplate(Double256Mask.class, op, s); // specialize + public final DoubleMask256 compare(Comparison op, double s) { + return super.compareTemplate(DoubleMask256.class, op, s); // specialize } @Override @ForceInline - public final Double256Mask compare(Comparison op, long s) { - return super.compareTemplate(Double256Mask.class, op, s); // specialize + public final DoubleMask256 compare(Comparison op, long s) { + return super.compareTemplate(DoubleMask256.class, op, s); // specialize } @Override @ForceInline - public final Double256Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Double256Mask.class, op, v, (Double256Mask) m); + public final DoubleMask256 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(DoubleMask256.class, op, v, (DoubleMask256) m); } @Override @ForceInline - public Double256Vector blend(Vector v, VectorMask m) { - return (Double256Vector) - super.blendTemplate(Double256Mask.class, - (Double256Vector) v, - (Double256Mask) m); // specialize + public DoubleVector256 blend(Vector v, VectorMask m) { + return (DoubleVector256) + super.blendTemplate(DoubleMask256.class, + (DoubleVector256) v, + (DoubleMask256) m); // specialize } @Override @ForceInline - public Double256Vector slice(int origin, Vector v) { - return (Double256Vector) super.sliceTemplate(origin, v); // specialize + public DoubleVector256 slice(int origin, Vector v) { + return (DoubleVector256) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Double256Vector slice(int origin) { - return (Double256Vector) super.sliceTemplate(origin); // specialize + public DoubleVector256 slice(int origin) { + return (DoubleVector256) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Double256Vector unslice(int origin, Vector w, int part) { - return (Double256Vector) super.unsliceTemplate(origin, w, part); // specialize + public DoubleVector256 unslice(int origin, Vector w, int part) { + return (DoubleVector256) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Double256Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Double256Vector) - super.unsliceTemplate(Double256Mask.class, + public DoubleVector256 unslice(int origin, Vector w, int part, VectorMask m) { + return (DoubleVector256) + super.unsliceTemplate(DoubleMask256.class, origin, w, part, - (Double256Mask) m); // specialize + (DoubleMask256) m); // specialize } @Override @ForceInline - public Double256Vector unslice(int origin) { - return (Double256Vector) super.unsliceTemplate(origin); // specialize + public DoubleVector256 unslice(int origin) { + return (DoubleVector256) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Double256Vector rearrange(VectorShuffle s) { - return (Double256Vector) - super.rearrangeTemplate(Double256Shuffle.class, - (Double256Shuffle) s); // specialize + public DoubleVector256 rearrange(VectorShuffle s) { + return (DoubleVector256) + super.rearrangeTemplate(DoubleShuffle256.class, + (DoubleShuffle256) s); // specialize } @Override @ForceInline - public Double256Vector rearrange(VectorShuffle shuffle, + public DoubleVector256 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Double256Vector) - super.rearrangeTemplate(Double256Shuffle.class, - Double256Mask.class, - (Double256Shuffle) shuffle, - (Double256Mask) m); // specialize + return (DoubleVector256) + super.rearrangeTemplate(DoubleShuffle256.class, + DoubleMask256.class, + (DoubleShuffle256) shuffle, + (DoubleMask256) m); // specialize } @Override @ForceInline - public Double256Vector rearrange(VectorShuffle s, + public DoubleVector256 rearrange(VectorShuffle s, Vector v) { - return (Double256Vector) - super.rearrangeTemplate(Double256Shuffle.class, - (Double256Shuffle) s, - (Double256Vector) v); // specialize + return (DoubleVector256) + super.rearrangeTemplate(DoubleShuffle256.class, + (DoubleShuffle256) s, + (DoubleVector256) v); // specialize } @Override @ForceInline - public Double256Vector compress(VectorMask m) { - return (Double256Vector) - super.compressTemplate(Double256Mask.class, - (Double256Mask) m); // specialize + public DoubleVector256 compress(VectorMask m) { + return (DoubleVector256) + super.compressTemplate(DoubleMask256.class, + (DoubleMask256) m); // specialize } @Override @ForceInline - public Double256Vector expand(VectorMask m) { - return (Double256Vector) - super.expandTemplate(Double256Mask.class, - (Double256Mask) m); // specialize + public DoubleVector256 expand(VectorMask m) { + return (DoubleVector256) + super.expandTemplate(DoubleMask256.class, + (DoubleMask256) m); // specialize } @Override @ForceInline - public Double256Vector selectFrom(Vector v) { - return (Double256Vector) - super.selectFromTemplate((Double256Vector) v); // specialize + public DoubleVector256 selectFrom(Vector v) { + return (DoubleVector256) + super.selectFromTemplate((DoubleVector256) v); // specialize } @Override @ForceInline - public Double256Vector selectFrom(Vector v, + public DoubleVector256 selectFrom(Vector v, VectorMask m) { - return (Double256Vector) - super.selectFromTemplate((Double256Vector) v, - Double256Mask.class, (Double256Mask) m); // specialize + return (DoubleVector256) + super.selectFromTemplate((DoubleVector256) v, + DoubleMask256.class, (DoubleMask256) m); // specialize } @Override @ForceInline - public Double256Vector selectFrom(Vector v1, + public DoubleVector256 selectFrom(Vector v1, Vector v2) { - return (Double256Vector) - super.selectFromTemplate((Double256Vector) v1, (Double256Vector) v2); // specialize + return (DoubleVector256) + super.selectFromTemplate((DoubleVector256) v1, (DoubleVector256) v2); // specialize } @ForceInline @@ -535,7 +535,7 @@ final class Double256Vector extends DoubleVector { @ForceInline @Override - public Double256Vector withLane(int i, double e) { + public DoubleVector256 withLane(int i, double e) { switch(i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -546,7 +546,7 @@ final class Double256Vector extends DoubleVector { } @ForceInline - public Double256Vector withLaneHelper(int i, double e) { + public DoubleVector256 withLaneHelper(int i, double e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Double.doubleToRawLongBits(e), @@ -559,19 +559,19 @@ final class Double256Vector extends DoubleVector { // Mask - static final class Double256Mask extends AbstractMask { + static final class DoubleMask256 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = double.class; // used by the JVM - Double256Mask(boolean[] bits) { + DoubleMask256(boolean[] bits) { this(bits, 0); } - Double256Mask(boolean[] bits, int offset) { + DoubleMask256(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Double256Mask(boolean val) { + DoubleMask256(boolean val) { super(prepare(val)); } @@ -604,31 +604,31 @@ final class Double256Vector extends DoubleVector { } @Override - Double256Mask uOp(MUnOp f) { + DoubleMask256 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Double256Mask(res); + return new DoubleMask256(res); } @Override - Double256Mask bOp(VectorMask m, MBinOp f) { + DoubleMask256 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Double256Mask)m).getBits(); + boolean[] mbits = ((DoubleMask256)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Double256Mask(res); + return new DoubleMask256(res); } @ForceInline @Override public final - Double256Vector toVector() { - return (Double256Vector) super.toVectorTemplate(); // specialize + DoubleVector256 toVector() { + return (DoubleVector256) super.toVectorTemplate(); // specialize } /** @@ -661,25 +661,25 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline /*package-private*/ - Double256Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Double256Mask) VectorSupport.indexPartiallyInUpperRange( - Double256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Double256Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + DoubleMask256 indexPartiallyInUpperRange(long offset, long limit) { + return (DoubleMask256) VectorSupport.indexPartiallyInUpperRange( + DoubleMask256.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (DoubleMask256) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Double256Mask not() { + public DoubleMask256 not() { return xor(maskAll(true)); } @Override @ForceInline - public Double256Mask compress() { - return (Double256Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Double256Vector.class, Double256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public DoubleMask256 compress() { + return (DoubleMask256)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + DoubleVector256.class, DoubleMask256.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -688,30 +688,30 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline - public Double256Mask and(VectorMask mask) { + public DoubleMask256 and(VectorMask mask) { Objects.requireNonNull(mask); - Double256Mask m = (Double256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Double256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask256 m = (DoubleMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, DoubleMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Double256Mask or(VectorMask mask) { + public DoubleMask256 or(VectorMask mask) { Objects.requireNonNull(mask); - Double256Mask m = (Double256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Double256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask256 m = (DoubleMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, DoubleMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Double256Mask xor(VectorMask mask) { + public DoubleMask256 xor(VectorMask mask) { Objects.requireNonNull(mask); - Double256Mask m = (Double256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Double256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask256 m = (DoubleMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -721,21 +721,21 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Double256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, DoubleMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Double256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, DoubleMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Double256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, DoubleMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -745,7 +745,7 @@ final class Double256Vector extends DoubleVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Double256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, DoubleMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -755,7 +755,7 @@ final class Double256Vector extends DoubleVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Double256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(DoubleMask256.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -764,48 +764,48 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Double256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, DoubleMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Double256Mask)m).getBits())); + (m, __) -> anyTrueHelper(((DoubleMask256)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Double256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, DoubleMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Double256Mask)m).getBits())); + (m, __) -> allTrueHelper(((DoubleMask256)m).getBits())); } @ForceInline /*package-private*/ - static Double256Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Double256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static DoubleMask256 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(DoubleMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Double256Mask TRUE_MASK = new Double256Mask(true); - private static final Double256Mask FALSE_MASK = new Double256Mask(false); + private static final DoubleMask256 TRUE_MASK = new DoubleMask256(true); + private static final DoubleMask256 FALSE_MASK = new DoubleMask256(false); } // Shuffle - static final class Double256Shuffle extends AbstractShuffle { + static final class DoubleShuffle256 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Double256Shuffle(long[] indices) { + DoubleShuffle256(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Double256Shuffle(int[] indices, int i) { + DoubleShuffle256(int[] indices, int i) { this(prepare(indices, i)); } - Double256Shuffle(IntUnaryOperator fn) { + DoubleShuffle256(IntUnaryOperator fn) { this(prepare(fn)); } @@ -825,23 +825,23 @@ final class Double256Vector extends DoubleVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final Double256Shuffle IOTA = new Double256Shuffle(IDENTITY); + static final DoubleShuffle256 IOTA = new DoubleShuffle256(IDENTITY); @Override @ForceInline - public Double256Vector toVector() { - return (Double256Vector) toBitsVector().castShape(vspecies(), 0); + public DoubleVector256 toVector() { + return (DoubleVector256) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - Long256Vector toBitsVector() { - return (Long256Vector) super.toBitsVectorTemplate(); + LongVector256 toBitsVector() { + return (LongVector256) super.toBitsVectorTemplate(); } @Override - Long256Vector toBitsVector0() { - return ((Long256Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVector256 toBitsVector0() { + return ((LongVector256) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -913,30 +913,30 @@ final class Double256Vector extends DoubleVector { @Override @ForceInline - public final Double256Mask laneIsValid() { - return (Double256Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final DoubleMask256 laneIsValid() { + return (DoubleMask256) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Double256Shuffle rearrange(VectorShuffle shuffle) { - Double256Shuffle concreteShuffle = (Double256Shuffle) shuffle; - return (Double256Shuffle) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_256)) + public final DoubleShuffle256 rearrange(VectorShuffle shuffle) { + DoubleShuffle256 concreteShuffle = (DoubleShuffle256) shuffle; + return (DoubleShuffle256) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_256)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Double256Shuffle wrapIndexes() { - Long256Vector v = toBitsVector(); + public final DoubleShuffle256 wrapIndexes() { + LongVector256 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Long256Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVector256) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Long256Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVector256) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Double256Shuffle) v.toShuffle(vspecies(), false); + return (DoubleShuffle256) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -987,14 +987,14 @@ final class Double256Vector extends DoubleVector { @Override final DoubleVector fromArray0(double[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Double256Mask.class, a, offset, (Double256Mask) m, offsetInRange); // specialize + return super.fromArray0Template(DoubleMask256.class, a, offset, (DoubleMask256) m, offsetInRange); // specialize } @ForceInline @Override final DoubleVector fromArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Double256Mask.class, a, offset, indexMap, mapOffset, (Double256Mask) m); + return super.fromArray0Template(DoubleMask256.class, a, offset, indexMap, mapOffset, (DoubleMask256) m); } @@ -1010,7 +1010,7 @@ final class Double256Vector extends DoubleVector { @Override final DoubleVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Double256Mask.class, ms, offset, (Double256Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(DoubleMask256.class, ms, offset, (DoubleMask256) m, offsetInRange); // specialize } @ForceInline @@ -1024,14 +1024,14 @@ final class Double256Vector extends DoubleVector { @Override final void intoArray0(double[] a, int offset, VectorMask m) { - super.intoArray0Template(Double256Mask.class, a, offset, (Double256Mask) m); + super.intoArray0Template(DoubleMask256.class, a, offset, (DoubleMask256) m); } @ForceInline @Override final void intoArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Double256Mask.class, a, offset, indexMap, mapOffset, (Double256Mask) m); + super.intoArray0Template(DoubleMask256.class, a, offset, indexMap, mapOffset, (DoubleMask256) m); } @@ -1039,7 +1039,7 @@ final class Double256Vector extends DoubleVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Double256Mask.class, ms, offset, (Double256Mask) m); + super.intoMemorySegment0Template(DoubleMask256.class, ms, offset, (DoubleMask256) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector512.java similarity index 68% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector512.java index 581a3ac7329..93477cd7470 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector512.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Double512Vector extends DoubleVector { +final class DoubleVector512 extends DoubleVector { static final DoubleSpecies VSPECIES = (DoubleSpecies) DoubleVector.SPECIES_512; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Double512Vector.class; + static final Class VCLASS = DoubleVector512.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Double512Vector extends DoubleVector { static final Class ETYPE = double.class; // used by the JVM - Double512Vector(double[] v) { + DoubleVector512(double[] v) { super(v); } - // For compatibility as Double512Vector::new, + // For compatibility as DoubleVector512::new, // stored into species.vectorFactory. - Double512Vector(Object v) { + DoubleVector512(Object v) { this((double[]) v); } - static final Double512Vector ZERO = new Double512Vector(new double[VLENGTH]); - static final Double512Vector IOTA = new Double512Vector(VSPECIES.iotaArray()); + static final DoubleVector512 ZERO = new DoubleVector512(new double[VLENGTH]); + static final DoubleVector512 IOTA = new DoubleVector512(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline - public final Double512Vector broadcast(double e) { - return (Double512Vector) super.broadcastTemplate(e); // specialize + public final DoubleVector512 broadcast(double e) { + return (DoubleVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Double512Vector broadcast(long e) { - return (Double512Vector) super.broadcastTemplate(e); // specialize + public final DoubleVector512 broadcast(long e) { + return (DoubleVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Double512Mask maskFromArray(boolean[] bits) { - return new Double512Mask(bits); + DoubleMask512 maskFromArray(boolean[] bits) { + return new DoubleMask512(bits); } @Override @ForceInline - Double512Shuffle iotaShuffle() { return Double512Shuffle.IOTA; } + DoubleShuffle512 iotaShuffle() { return DoubleShuffle512.IOTA; } @Override @ForceInline - Double512Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Double512Shuffle) iotaShuffleTemplate(start, step, wrap); + DoubleShuffle512 iotaShuffle(int start, int step, boolean wrap) { + return (DoubleShuffle512) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Double512Shuffle shuffleFromArray(int[] indices, int i) { return new Double512Shuffle(indices, i); } + DoubleShuffle512 shuffleFromArray(int[] indices, int i) { return new DoubleShuffle512(indices, i); } @Override @ForceInline - Double512Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Double512Shuffle(fn); } + DoubleShuffle512 shuffleFromOp(IntUnaryOperator fn) { return new DoubleShuffle512(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Double512Vector vectorFactory(double[] vec) { - return new Double512Vector(vec); + DoubleVector512 vectorFactory(double[] vec) { + return new DoubleVector512(vec); } @ForceInline final @Override - Byte512Vector asByteVectorRaw() { - return (Byte512Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector512 asByteVectorRaw() { + return (ByteVector512) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Double512Vector extends DoubleVector { @ForceInline final @Override - Double512Vector uOp(FUnOp f) { - return (Double512Vector) super.uOpTemplate(f); // specialize + DoubleVector512 uOp(FUnOp f) { + return (DoubleVector512) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Double512Vector uOp(VectorMask m, FUnOp f) { - return (Double512Vector) - super.uOpTemplate((Double512Mask)m, f); // specialize + DoubleVector512 uOp(VectorMask m, FUnOp f) { + return (DoubleVector512) + super.uOpTemplate((DoubleMask512)m, f); // specialize } // Binary operator @ForceInline final @Override - Double512Vector bOp(Vector v, FBinOp f) { - return (Double512Vector) super.bOpTemplate((Double512Vector)v, f); // specialize + DoubleVector512 bOp(Vector v, FBinOp f) { + return (DoubleVector512) super.bOpTemplate((DoubleVector512)v, f); // specialize } @ForceInline final @Override - Double512Vector bOp(Vector v, + DoubleVector512 bOp(Vector v, VectorMask m, FBinOp f) { - return (Double512Vector) - super.bOpTemplate((Double512Vector)v, (Double512Mask)m, + return (DoubleVector512) + super.bOpTemplate((DoubleVector512)v, (DoubleMask512)m, f); // specialize } @@ -219,19 +219,19 @@ final class Double512Vector extends DoubleVector { @ForceInline final @Override - Double512Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Double512Vector) - super.tOpTemplate((Double512Vector)v1, (Double512Vector)v2, + DoubleVector512 tOp(Vector v1, Vector v2, FTriOp f) { + return (DoubleVector512) + super.tOpTemplate((DoubleVector512)v1, (DoubleVector512)v2, f); // specialize } @ForceInline final @Override - Double512Vector tOp(Vector v1, Vector v2, + DoubleVector512 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Double512Vector) - super.tOpTemplate((Double512Vector)v1, (Double512Vector)v2, - (Double512Mask)m, f); // specialize + return (DoubleVector512) + super.tOpTemplate((DoubleVector512)v1, (DoubleVector512)v2, + (DoubleMask512)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline - public Double512Vector lanewise(Unary op) { - return (Double512Vector) super.lanewiseTemplate(op); // specialize + public DoubleVector512 lanewise(Unary op) { + return (DoubleVector512) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Double512Vector lanewise(Unary op, VectorMask m) { - return (Double512Vector) super.lanewiseTemplate(op, Double512Mask.class, (Double512Mask) m); // specialize + public DoubleVector512 lanewise(Unary op, VectorMask m) { + return (DoubleVector512) super.lanewiseTemplate(op, DoubleMask512.class, (DoubleMask512) m); // specialize } @Override @ForceInline - public Double512Vector lanewise(Binary op, Vector v) { - return (Double512Vector) super.lanewiseTemplate(op, v); // specialize + public DoubleVector512 lanewise(Binary op, Vector v) { + return (DoubleVector512) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Double512Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Double512Vector) super.lanewiseTemplate(op, Double512Mask.class, v, (Double512Mask) m); // specialize + public DoubleVector512 lanewise(Binary op, Vector v, VectorMask m) { + return (DoubleVector512) super.lanewiseTemplate(op, DoubleMask512.class, v, (DoubleMask512) m); // specialize } @@ -296,24 +296,24 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline public final - Double512Vector + DoubleVector512 lanewise(Ternary op, Vector v1, Vector v2) { - return (Double512Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (DoubleVector512) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Double512Vector + DoubleVector512 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Double512Vector) super.lanewiseTemplate(op, Double512Mask.class, v1, v2, (Double512Mask) m); // specialize + return (DoubleVector512) super.lanewiseTemplate(op, DoubleMask512.class, v1, v2, (DoubleMask512) m); // specialize } @Override @ForceInline public final - Double512Vector addIndex(int scale) { - return (Double512Vector) super.addIndexTemplate(scale); // specialize + DoubleVector512 addIndex(int scale) { + return (DoubleVector512) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class Double512Vector extends DoubleVector { @ForceInline public final double reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Double512Mask.class, (Double512Mask) m); // specialized + return super.reduceLanesTemplate(op, DoubleMask512.class, (DoubleMask512) m); // specialized } @Override @@ -341,7 +341,7 @@ final class Double512Vector extends DoubleVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Double512Mask.class, (Double512Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, DoubleMask512.class, (DoubleMask512) m); // specialized } @Override @@ -352,160 +352,160 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline - public final Double512Shuffle toShuffle() { - return (Double512Shuffle) toShuffle(vspecies(), false); + public final DoubleShuffle512 toShuffle() { + return (DoubleShuffle512) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Double512Mask test(Test op) { - return super.testTemplate(Double512Mask.class, op); // specialize + public final DoubleMask512 test(Test op) { + return super.testTemplate(DoubleMask512.class, op); // specialize } @Override @ForceInline - public final Double512Mask test(Test op, VectorMask m) { - return super.testTemplate(Double512Mask.class, op, (Double512Mask) m); // specialize + public final DoubleMask512 test(Test op, VectorMask m) { + return super.testTemplate(DoubleMask512.class, op, (DoubleMask512) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Double512Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Double512Mask.class, op, v); // specialize + public final DoubleMask512 compare(Comparison op, Vector v) { + return super.compareTemplate(DoubleMask512.class, op, v); // specialize } @Override @ForceInline - public final Double512Mask compare(Comparison op, double s) { - return super.compareTemplate(Double512Mask.class, op, s); // specialize + public final DoubleMask512 compare(Comparison op, double s) { + return super.compareTemplate(DoubleMask512.class, op, s); // specialize } @Override @ForceInline - public final Double512Mask compare(Comparison op, long s) { - return super.compareTemplate(Double512Mask.class, op, s); // specialize + public final DoubleMask512 compare(Comparison op, long s) { + return super.compareTemplate(DoubleMask512.class, op, s); // specialize } @Override @ForceInline - public final Double512Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Double512Mask.class, op, v, (Double512Mask) m); + public final DoubleMask512 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(DoubleMask512.class, op, v, (DoubleMask512) m); } @Override @ForceInline - public Double512Vector blend(Vector v, VectorMask m) { - return (Double512Vector) - super.blendTemplate(Double512Mask.class, - (Double512Vector) v, - (Double512Mask) m); // specialize + public DoubleVector512 blend(Vector v, VectorMask m) { + return (DoubleVector512) + super.blendTemplate(DoubleMask512.class, + (DoubleVector512) v, + (DoubleMask512) m); // specialize } @Override @ForceInline - public Double512Vector slice(int origin, Vector v) { - return (Double512Vector) super.sliceTemplate(origin, v); // specialize + public DoubleVector512 slice(int origin, Vector v) { + return (DoubleVector512) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Double512Vector slice(int origin) { - return (Double512Vector) super.sliceTemplate(origin); // specialize + public DoubleVector512 slice(int origin) { + return (DoubleVector512) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Double512Vector unslice(int origin, Vector w, int part) { - return (Double512Vector) super.unsliceTemplate(origin, w, part); // specialize + public DoubleVector512 unslice(int origin, Vector w, int part) { + return (DoubleVector512) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Double512Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Double512Vector) - super.unsliceTemplate(Double512Mask.class, + public DoubleVector512 unslice(int origin, Vector w, int part, VectorMask m) { + return (DoubleVector512) + super.unsliceTemplate(DoubleMask512.class, origin, w, part, - (Double512Mask) m); // specialize + (DoubleMask512) m); // specialize } @Override @ForceInline - public Double512Vector unslice(int origin) { - return (Double512Vector) super.unsliceTemplate(origin); // specialize + public DoubleVector512 unslice(int origin) { + return (DoubleVector512) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Double512Vector rearrange(VectorShuffle s) { - return (Double512Vector) - super.rearrangeTemplate(Double512Shuffle.class, - (Double512Shuffle) s); // specialize + public DoubleVector512 rearrange(VectorShuffle s) { + return (DoubleVector512) + super.rearrangeTemplate(DoubleShuffle512.class, + (DoubleShuffle512) s); // specialize } @Override @ForceInline - public Double512Vector rearrange(VectorShuffle shuffle, + public DoubleVector512 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Double512Vector) - super.rearrangeTemplate(Double512Shuffle.class, - Double512Mask.class, - (Double512Shuffle) shuffle, - (Double512Mask) m); // specialize + return (DoubleVector512) + super.rearrangeTemplate(DoubleShuffle512.class, + DoubleMask512.class, + (DoubleShuffle512) shuffle, + (DoubleMask512) m); // specialize } @Override @ForceInline - public Double512Vector rearrange(VectorShuffle s, + public DoubleVector512 rearrange(VectorShuffle s, Vector v) { - return (Double512Vector) - super.rearrangeTemplate(Double512Shuffle.class, - (Double512Shuffle) s, - (Double512Vector) v); // specialize + return (DoubleVector512) + super.rearrangeTemplate(DoubleShuffle512.class, + (DoubleShuffle512) s, + (DoubleVector512) v); // specialize } @Override @ForceInline - public Double512Vector compress(VectorMask m) { - return (Double512Vector) - super.compressTemplate(Double512Mask.class, - (Double512Mask) m); // specialize + public DoubleVector512 compress(VectorMask m) { + return (DoubleVector512) + super.compressTemplate(DoubleMask512.class, + (DoubleMask512) m); // specialize } @Override @ForceInline - public Double512Vector expand(VectorMask m) { - return (Double512Vector) - super.expandTemplate(Double512Mask.class, - (Double512Mask) m); // specialize + public DoubleVector512 expand(VectorMask m) { + return (DoubleVector512) + super.expandTemplate(DoubleMask512.class, + (DoubleMask512) m); // specialize } @Override @ForceInline - public Double512Vector selectFrom(Vector v) { - return (Double512Vector) - super.selectFromTemplate((Double512Vector) v); // specialize + public DoubleVector512 selectFrom(Vector v) { + return (DoubleVector512) + super.selectFromTemplate((DoubleVector512) v); // specialize } @Override @ForceInline - public Double512Vector selectFrom(Vector v, + public DoubleVector512 selectFrom(Vector v, VectorMask m) { - return (Double512Vector) - super.selectFromTemplate((Double512Vector) v, - Double512Mask.class, (Double512Mask) m); // specialize + return (DoubleVector512) + super.selectFromTemplate((DoubleVector512) v, + DoubleMask512.class, (DoubleMask512) m); // specialize } @Override @ForceInline - public Double512Vector selectFrom(Vector v1, + public DoubleVector512 selectFrom(Vector v1, Vector v2) { - return (Double512Vector) - super.selectFromTemplate((Double512Vector) v1, (Double512Vector) v2); // specialize + return (DoubleVector512) + super.selectFromTemplate((DoubleVector512) v1, (DoubleVector512) v2); // specialize } @ForceInline @@ -539,7 +539,7 @@ final class Double512Vector extends DoubleVector { @ForceInline @Override - public Double512Vector withLane(int i, double e) { + public DoubleVector512 withLane(int i, double e) { switch(i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -554,7 +554,7 @@ final class Double512Vector extends DoubleVector { } @ForceInline - public Double512Vector withLaneHelper(int i, double e) { + public DoubleVector512 withLaneHelper(int i, double e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Double.doubleToRawLongBits(e), @@ -567,19 +567,19 @@ final class Double512Vector extends DoubleVector { // Mask - static final class Double512Mask extends AbstractMask { + static final class DoubleMask512 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = double.class; // used by the JVM - Double512Mask(boolean[] bits) { + DoubleMask512(boolean[] bits) { this(bits, 0); } - Double512Mask(boolean[] bits, int offset) { + DoubleMask512(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Double512Mask(boolean val) { + DoubleMask512(boolean val) { super(prepare(val)); } @@ -612,31 +612,31 @@ final class Double512Vector extends DoubleVector { } @Override - Double512Mask uOp(MUnOp f) { + DoubleMask512 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Double512Mask(res); + return new DoubleMask512(res); } @Override - Double512Mask bOp(VectorMask m, MBinOp f) { + DoubleMask512 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Double512Mask)m).getBits(); + boolean[] mbits = ((DoubleMask512)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Double512Mask(res); + return new DoubleMask512(res); } @ForceInline @Override public final - Double512Vector toVector() { - return (Double512Vector) super.toVectorTemplate(); // specialize + DoubleVector512 toVector() { + return (DoubleVector512) super.toVectorTemplate(); // specialize } /** @@ -669,25 +669,25 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline /*package-private*/ - Double512Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Double512Mask) VectorSupport.indexPartiallyInUpperRange( - Double512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Double512Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + DoubleMask512 indexPartiallyInUpperRange(long offset, long limit) { + return (DoubleMask512) VectorSupport.indexPartiallyInUpperRange( + DoubleMask512.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (DoubleMask512) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Double512Mask not() { + public DoubleMask512 not() { return xor(maskAll(true)); } @Override @ForceInline - public Double512Mask compress() { - return (Double512Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Double512Vector.class, Double512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public DoubleMask512 compress() { + return (DoubleMask512)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + DoubleVector512.class, DoubleMask512.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -696,30 +696,30 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline - public Double512Mask and(VectorMask mask) { + public DoubleMask512 and(VectorMask mask) { Objects.requireNonNull(mask); - Double512Mask m = (Double512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Double512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask512 m = (DoubleMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, DoubleMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Double512Mask or(VectorMask mask) { + public DoubleMask512 or(VectorMask mask) { Objects.requireNonNull(mask); - Double512Mask m = (Double512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Double512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask512 m = (DoubleMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, DoubleMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Double512Mask xor(VectorMask mask) { + public DoubleMask512 xor(VectorMask mask) { Objects.requireNonNull(mask); - Double512Mask m = (Double512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Double512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask512 m = (DoubleMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -729,21 +729,21 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Double512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, DoubleMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Double512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, DoubleMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Double512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, DoubleMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -753,7 +753,7 @@ final class Double512Vector extends DoubleVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Double512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, DoubleMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -763,7 +763,7 @@ final class Double512Vector extends DoubleVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Double512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(DoubleMask512.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -772,48 +772,48 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Double512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, DoubleMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Double512Mask)m).getBits())); + (m, __) -> anyTrueHelper(((DoubleMask512)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Double512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, DoubleMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Double512Mask)m).getBits())); + (m, __) -> allTrueHelper(((DoubleMask512)m).getBits())); } @ForceInline /*package-private*/ - static Double512Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Double512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static DoubleMask512 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(DoubleMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Double512Mask TRUE_MASK = new Double512Mask(true); - private static final Double512Mask FALSE_MASK = new Double512Mask(false); + private static final DoubleMask512 TRUE_MASK = new DoubleMask512(true); + private static final DoubleMask512 FALSE_MASK = new DoubleMask512(false); } // Shuffle - static final class Double512Shuffle extends AbstractShuffle { + static final class DoubleShuffle512 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Double512Shuffle(long[] indices) { + DoubleShuffle512(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Double512Shuffle(int[] indices, int i) { + DoubleShuffle512(int[] indices, int i) { this(prepare(indices, i)); } - Double512Shuffle(IntUnaryOperator fn) { + DoubleShuffle512(IntUnaryOperator fn) { this(prepare(fn)); } @@ -833,23 +833,23 @@ final class Double512Vector extends DoubleVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final Double512Shuffle IOTA = new Double512Shuffle(IDENTITY); + static final DoubleShuffle512 IOTA = new DoubleShuffle512(IDENTITY); @Override @ForceInline - public Double512Vector toVector() { - return (Double512Vector) toBitsVector().castShape(vspecies(), 0); + public DoubleVector512 toVector() { + return (DoubleVector512) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - Long512Vector toBitsVector() { - return (Long512Vector) super.toBitsVectorTemplate(); + LongVector512 toBitsVector() { + return (LongVector512) super.toBitsVectorTemplate(); } @Override - Long512Vector toBitsVector0() { - return ((Long512Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVector512 toBitsVector0() { + return ((LongVector512) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -921,30 +921,30 @@ final class Double512Vector extends DoubleVector { @Override @ForceInline - public final Double512Mask laneIsValid() { - return (Double512Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final DoubleMask512 laneIsValid() { + return (DoubleMask512) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Double512Shuffle rearrange(VectorShuffle shuffle) { - Double512Shuffle concreteShuffle = (Double512Shuffle) shuffle; - return (Double512Shuffle) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_512)) + public final DoubleShuffle512 rearrange(VectorShuffle shuffle) { + DoubleShuffle512 concreteShuffle = (DoubleShuffle512) shuffle; + return (DoubleShuffle512) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_512)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Double512Shuffle wrapIndexes() { - Long512Vector v = toBitsVector(); + public final DoubleShuffle512 wrapIndexes() { + LongVector512 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Long512Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVector512) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Long512Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVector512) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Double512Shuffle) v.toShuffle(vspecies(), false); + return (DoubleShuffle512) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -995,14 +995,14 @@ final class Double512Vector extends DoubleVector { @Override final DoubleVector fromArray0(double[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Double512Mask.class, a, offset, (Double512Mask) m, offsetInRange); // specialize + return super.fromArray0Template(DoubleMask512.class, a, offset, (DoubleMask512) m, offsetInRange); // specialize } @ForceInline @Override final DoubleVector fromArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Double512Mask.class, a, offset, indexMap, mapOffset, (Double512Mask) m); + return super.fromArray0Template(DoubleMask512.class, a, offset, indexMap, mapOffset, (DoubleMask512) m); } @@ -1018,7 +1018,7 @@ final class Double512Vector extends DoubleVector { @Override final DoubleVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Double512Mask.class, ms, offset, (Double512Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(DoubleMask512.class, ms, offset, (DoubleMask512) m, offsetInRange); // specialize } @ForceInline @@ -1032,14 +1032,14 @@ final class Double512Vector extends DoubleVector { @Override final void intoArray0(double[] a, int offset, VectorMask m) { - super.intoArray0Template(Double512Mask.class, a, offset, (Double512Mask) m); + super.intoArray0Template(DoubleMask512.class, a, offset, (DoubleMask512) m); } @ForceInline @Override final void intoArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Double512Mask.class, a, offset, indexMap, mapOffset, (Double512Mask) m); + super.intoArray0Template(DoubleMask512.class, a, offset, indexMap, mapOffset, (DoubleMask512) m); } @@ -1047,7 +1047,7 @@ final class Double512Vector extends DoubleVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Double512Mask.class, ms, offset, (Double512Mask) m); + super.intoMemorySegment0Template(DoubleMask512.class, ms, offset, (DoubleMask512) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector64.java similarity index 67% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector64.java index 9535f112ada..2b55198a050 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector64.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Double64Vector extends DoubleVector { +final class DoubleVector64 extends DoubleVector { static final DoubleSpecies VSPECIES = (DoubleSpecies) DoubleVector.SPECIES_64; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Double64Vector.class; + static final Class VCLASS = DoubleVector64.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Double64Vector extends DoubleVector { static final Class ETYPE = double.class; // used by the JVM - Double64Vector(double[] v) { + DoubleVector64(double[] v) { super(v); } - // For compatibility as Double64Vector::new, + // For compatibility as DoubleVector64::new, // stored into species.vectorFactory. - Double64Vector(Object v) { + DoubleVector64(Object v) { this((double[]) v); } - static final Double64Vector ZERO = new Double64Vector(new double[VLENGTH]); - static final Double64Vector IOTA = new Double64Vector(VSPECIES.iotaArray()); + static final DoubleVector64 ZERO = new DoubleVector64(new double[VLENGTH]); + static final DoubleVector64 IOTA = new DoubleVector64(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline - public final Double64Vector broadcast(double e) { - return (Double64Vector) super.broadcastTemplate(e); // specialize + public final DoubleVector64 broadcast(double e) { + return (DoubleVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Double64Vector broadcast(long e) { - return (Double64Vector) super.broadcastTemplate(e); // specialize + public final DoubleVector64 broadcast(long e) { + return (DoubleVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Double64Mask maskFromArray(boolean[] bits) { - return new Double64Mask(bits); + DoubleMask64 maskFromArray(boolean[] bits) { + return new DoubleMask64(bits); } @Override @ForceInline - Double64Shuffle iotaShuffle() { return Double64Shuffle.IOTA; } + DoubleShuffle64 iotaShuffle() { return DoubleShuffle64.IOTA; } @Override @ForceInline - Double64Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Double64Shuffle) iotaShuffleTemplate(start, step, wrap); + DoubleShuffle64 iotaShuffle(int start, int step, boolean wrap) { + return (DoubleShuffle64) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Double64Shuffle shuffleFromArray(int[] indices, int i) { return new Double64Shuffle(indices, i); } + DoubleShuffle64 shuffleFromArray(int[] indices, int i) { return new DoubleShuffle64(indices, i); } @Override @ForceInline - Double64Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Double64Shuffle(fn); } + DoubleShuffle64 shuffleFromOp(IntUnaryOperator fn) { return new DoubleShuffle64(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Double64Vector vectorFactory(double[] vec) { - return new Double64Vector(vec); + DoubleVector64 vectorFactory(double[] vec) { + return new DoubleVector64(vec); } @ForceInline final @Override - Byte64Vector asByteVectorRaw() { - return (Byte64Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector64 asByteVectorRaw() { + return (ByteVector64) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Double64Vector extends DoubleVector { @ForceInline final @Override - Double64Vector uOp(FUnOp f) { - return (Double64Vector) super.uOpTemplate(f); // specialize + DoubleVector64 uOp(FUnOp f) { + return (DoubleVector64) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Double64Vector uOp(VectorMask m, FUnOp f) { - return (Double64Vector) - super.uOpTemplate((Double64Mask)m, f); // specialize + DoubleVector64 uOp(VectorMask m, FUnOp f) { + return (DoubleVector64) + super.uOpTemplate((DoubleMask64)m, f); // specialize } // Binary operator @ForceInline final @Override - Double64Vector bOp(Vector v, FBinOp f) { - return (Double64Vector) super.bOpTemplate((Double64Vector)v, f); // specialize + DoubleVector64 bOp(Vector v, FBinOp f) { + return (DoubleVector64) super.bOpTemplate((DoubleVector64)v, f); // specialize } @ForceInline final @Override - Double64Vector bOp(Vector v, + DoubleVector64 bOp(Vector v, VectorMask m, FBinOp f) { - return (Double64Vector) - super.bOpTemplate((Double64Vector)v, (Double64Mask)m, + return (DoubleVector64) + super.bOpTemplate((DoubleVector64)v, (DoubleMask64)m, f); // specialize } @@ -219,19 +219,19 @@ final class Double64Vector extends DoubleVector { @ForceInline final @Override - Double64Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Double64Vector) - super.tOpTemplate((Double64Vector)v1, (Double64Vector)v2, + DoubleVector64 tOp(Vector v1, Vector v2, FTriOp f) { + return (DoubleVector64) + super.tOpTemplate((DoubleVector64)v1, (DoubleVector64)v2, f); // specialize } @ForceInline final @Override - Double64Vector tOp(Vector v1, Vector v2, + DoubleVector64 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Double64Vector) - super.tOpTemplate((Double64Vector)v1, (Double64Vector)v2, - (Double64Mask)m, f); // specialize + return (DoubleVector64) + super.tOpTemplate((DoubleVector64)v1, (DoubleVector64)v2, + (DoubleMask64)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline - public Double64Vector lanewise(Unary op) { - return (Double64Vector) super.lanewiseTemplate(op); // specialize + public DoubleVector64 lanewise(Unary op) { + return (DoubleVector64) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Double64Vector lanewise(Unary op, VectorMask m) { - return (Double64Vector) super.lanewiseTemplate(op, Double64Mask.class, (Double64Mask) m); // specialize + public DoubleVector64 lanewise(Unary op, VectorMask m) { + return (DoubleVector64) super.lanewiseTemplate(op, DoubleMask64.class, (DoubleMask64) m); // specialize } @Override @ForceInline - public Double64Vector lanewise(Binary op, Vector v) { - return (Double64Vector) super.lanewiseTemplate(op, v); // specialize + public DoubleVector64 lanewise(Binary op, Vector v) { + return (DoubleVector64) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Double64Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Double64Vector) super.lanewiseTemplate(op, Double64Mask.class, v, (Double64Mask) m); // specialize + public DoubleVector64 lanewise(Binary op, Vector v, VectorMask m) { + return (DoubleVector64) super.lanewiseTemplate(op, DoubleMask64.class, v, (DoubleMask64) m); // specialize } @@ -296,24 +296,24 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline public final - Double64Vector + DoubleVector64 lanewise(Ternary op, Vector v1, Vector v2) { - return (Double64Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (DoubleVector64) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Double64Vector + DoubleVector64 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Double64Vector) super.lanewiseTemplate(op, Double64Mask.class, v1, v2, (Double64Mask) m); // specialize + return (DoubleVector64) super.lanewiseTemplate(op, DoubleMask64.class, v1, v2, (DoubleMask64) m); // specialize } @Override @ForceInline public final - Double64Vector addIndex(int scale) { - return (Double64Vector) super.addIndexTemplate(scale); // specialize + DoubleVector64 addIndex(int scale) { + return (DoubleVector64) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class Double64Vector extends DoubleVector { @ForceInline public final double reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Double64Mask.class, (Double64Mask) m); // specialized + return super.reduceLanesTemplate(op, DoubleMask64.class, (DoubleMask64) m); // specialized } @Override @@ -341,7 +341,7 @@ final class Double64Vector extends DoubleVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Double64Mask.class, (Double64Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, DoubleMask64.class, (DoubleMask64) m); // specialized } @Override @@ -352,160 +352,160 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline - public final Double64Shuffle toShuffle() { - return (Double64Shuffle) toShuffle(vspecies(), false); + public final DoubleShuffle64 toShuffle() { + return (DoubleShuffle64) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Double64Mask test(Test op) { - return super.testTemplate(Double64Mask.class, op); // specialize + public final DoubleMask64 test(Test op) { + return super.testTemplate(DoubleMask64.class, op); // specialize } @Override @ForceInline - public final Double64Mask test(Test op, VectorMask m) { - return super.testTemplate(Double64Mask.class, op, (Double64Mask) m); // specialize + public final DoubleMask64 test(Test op, VectorMask m) { + return super.testTemplate(DoubleMask64.class, op, (DoubleMask64) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Double64Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Double64Mask.class, op, v); // specialize + public final DoubleMask64 compare(Comparison op, Vector v) { + return super.compareTemplate(DoubleMask64.class, op, v); // specialize } @Override @ForceInline - public final Double64Mask compare(Comparison op, double s) { - return super.compareTemplate(Double64Mask.class, op, s); // specialize + public final DoubleMask64 compare(Comparison op, double s) { + return super.compareTemplate(DoubleMask64.class, op, s); // specialize } @Override @ForceInline - public final Double64Mask compare(Comparison op, long s) { - return super.compareTemplate(Double64Mask.class, op, s); // specialize + public final DoubleMask64 compare(Comparison op, long s) { + return super.compareTemplate(DoubleMask64.class, op, s); // specialize } @Override @ForceInline - public final Double64Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Double64Mask.class, op, v, (Double64Mask) m); + public final DoubleMask64 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(DoubleMask64.class, op, v, (DoubleMask64) m); } @Override @ForceInline - public Double64Vector blend(Vector v, VectorMask m) { - return (Double64Vector) - super.blendTemplate(Double64Mask.class, - (Double64Vector) v, - (Double64Mask) m); // specialize + public DoubleVector64 blend(Vector v, VectorMask m) { + return (DoubleVector64) + super.blendTemplate(DoubleMask64.class, + (DoubleVector64) v, + (DoubleMask64) m); // specialize } @Override @ForceInline - public Double64Vector slice(int origin, Vector v) { - return (Double64Vector) super.sliceTemplate(origin, v); // specialize + public DoubleVector64 slice(int origin, Vector v) { + return (DoubleVector64) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Double64Vector slice(int origin) { - return (Double64Vector) super.sliceTemplate(origin); // specialize + public DoubleVector64 slice(int origin) { + return (DoubleVector64) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Double64Vector unslice(int origin, Vector w, int part) { - return (Double64Vector) super.unsliceTemplate(origin, w, part); // specialize + public DoubleVector64 unslice(int origin, Vector w, int part) { + return (DoubleVector64) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Double64Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Double64Vector) - super.unsliceTemplate(Double64Mask.class, + public DoubleVector64 unslice(int origin, Vector w, int part, VectorMask m) { + return (DoubleVector64) + super.unsliceTemplate(DoubleMask64.class, origin, w, part, - (Double64Mask) m); // specialize + (DoubleMask64) m); // specialize } @Override @ForceInline - public Double64Vector unslice(int origin) { - return (Double64Vector) super.unsliceTemplate(origin); // specialize + public DoubleVector64 unslice(int origin) { + return (DoubleVector64) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Double64Vector rearrange(VectorShuffle s) { - return (Double64Vector) - super.rearrangeTemplate(Double64Shuffle.class, - (Double64Shuffle) s); // specialize + public DoubleVector64 rearrange(VectorShuffle s) { + return (DoubleVector64) + super.rearrangeTemplate(DoubleShuffle64.class, + (DoubleShuffle64) s); // specialize } @Override @ForceInline - public Double64Vector rearrange(VectorShuffle shuffle, + public DoubleVector64 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Double64Vector) - super.rearrangeTemplate(Double64Shuffle.class, - Double64Mask.class, - (Double64Shuffle) shuffle, - (Double64Mask) m); // specialize + return (DoubleVector64) + super.rearrangeTemplate(DoubleShuffle64.class, + DoubleMask64.class, + (DoubleShuffle64) shuffle, + (DoubleMask64) m); // specialize } @Override @ForceInline - public Double64Vector rearrange(VectorShuffle s, + public DoubleVector64 rearrange(VectorShuffle s, Vector v) { - return (Double64Vector) - super.rearrangeTemplate(Double64Shuffle.class, - (Double64Shuffle) s, - (Double64Vector) v); // specialize + return (DoubleVector64) + super.rearrangeTemplate(DoubleShuffle64.class, + (DoubleShuffle64) s, + (DoubleVector64) v); // specialize } @Override @ForceInline - public Double64Vector compress(VectorMask m) { - return (Double64Vector) - super.compressTemplate(Double64Mask.class, - (Double64Mask) m); // specialize + public DoubleVector64 compress(VectorMask m) { + return (DoubleVector64) + super.compressTemplate(DoubleMask64.class, + (DoubleMask64) m); // specialize } @Override @ForceInline - public Double64Vector expand(VectorMask m) { - return (Double64Vector) - super.expandTemplate(Double64Mask.class, - (Double64Mask) m); // specialize + public DoubleVector64 expand(VectorMask m) { + return (DoubleVector64) + super.expandTemplate(DoubleMask64.class, + (DoubleMask64) m); // specialize } @Override @ForceInline - public Double64Vector selectFrom(Vector v) { - return (Double64Vector) - super.selectFromTemplate((Double64Vector) v); // specialize + public DoubleVector64 selectFrom(Vector v) { + return (DoubleVector64) + super.selectFromTemplate((DoubleVector64) v); // specialize } @Override @ForceInline - public Double64Vector selectFrom(Vector v, + public DoubleVector64 selectFrom(Vector v, VectorMask m) { - return (Double64Vector) - super.selectFromTemplate((Double64Vector) v, - Double64Mask.class, (Double64Mask) m); // specialize + return (DoubleVector64) + super.selectFromTemplate((DoubleVector64) v, + DoubleMask64.class, (DoubleMask64) m); // specialize } @Override @ForceInline - public Double64Vector selectFrom(Vector v1, + public DoubleVector64 selectFrom(Vector v1, Vector v2) { - return (Double64Vector) - super.selectFromTemplate((Double64Vector) v1, (Double64Vector) v2); // specialize + return (DoubleVector64) + super.selectFromTemplate((DoubleVector64) v1, (DoubleVector64) v2); // specialize } @ForceInline @@ -532,7 +532,7 @@ final class Double64Vector extends DoubleVector { @ForceInline @Override - public Double64Vector withLane(int i, double e) { + public DoubleVector64 withLane(int i, double e) { switch(i) { case 0: return withLaneHelper(0, e); default: throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); @@ -540,7 +540,7 @@ final class Double64Vector extends DoubleVector { } @ForceInline - public Double64Vector withLaneHelper(int i, double e) { + public DoubleVector64 withLaneHelper(int i, double e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Double.doubleToRawLongBits(e), @@ -553,19 +553,19 @@ final class Double64Vector extends DoubleVector { // Mask - static final class Double64Mask extends AbstractMask { + static final class DoubleMask64 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = double.class; // used by the JVM - Double64Mask(boolean[] bits) { + DoubleMask64(boolean[] bits) { this(bits, 0); } - Double64Mask(boolean[] bits, int offset) { + DoubleMask64(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Double64Mask(boolean val) { + DoubleMask64(boolean val) { super(prepare(val)); } @@ -598,31 +598,31 @@ final class Double64Vector extends DoubleVector { } @Override - Double64Mask uOp(MUnOp f) { + DoubleMask64 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Double64Mask(res); + return new DoubleMask64(res); } @Override - Double64Mask bOp(VectorMask m, MBinOp f) { + DoubleMask64 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Double64Mask)m).getBits(); + boolean[] mbits = ((DoubleMask64)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Double64Mask(res); + return new DoubleMask64(res); } @ForceInline @Override public final - Double64Vector toVector() { - return (Double64Vector) super.toVectorTemplate(); // specialize + DoubleVector64 toVector() { + return (DoubleVector64) super.toVectorTemplate(); // specialize } /** @@ -655,25 +655,25 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline /*package-private*/ - Double64Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Double64Mask) VectorSupport.indexPartiallyInUpperRange( - Double64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Double64Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + DoubleMask64 indexPartiallyInUpperRange(long offset, long limit) { + return (DoubleMask64) VectorSupport.indexPartiallyInUpperRange( + DoubleMask64.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (DoubleMask64) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Double64Mask not() { + public DoubleMask64 not() { return xor(maskAll(true)); } @Override @ForceInline - public Double64Mask compress() { - return (Double64Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Double64Vector.class, Double64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public DoubleMask64 compress() { + return (DoubleMask64)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + DoubleVector64.class, DoubleMask64.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -682,30 +682,30 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline - public Double64Mask and(VectorMask mask) { + public DoubleMask64 and(VectorMask mask) { Objects.requireNonNull(mask); - Double64Mask m = (Double64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Double64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask64 m = (DoubleMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, DoubleMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Double64Mask or(VectorMask mask) { + public DoubleMask64 or(VectorMask mask) { Objects.requireNonNull(mask); - Double64Mask m = (Double64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Double64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask64 m = (DoubleMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, DoubleMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Double64Mask xor(VectorMask mask) { + public DoubleMask64 xor(VectorMask mask) { Objects.requireNonNull(mask); - Double64Mask m = (Double64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Double64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMask64 m = (DoubleMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -715,21 +715,21 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Double64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, DoubleMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Double64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, DoubleMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Double64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, DoubleMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -739,7 +739,7 @@ final class Double64Vector extends DoubleVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Double64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, DoubleMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -749,7 +749,7 @@ final class Double64Vector extends DoubleVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Double64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(DoubleMask64.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -758,48 +758,48 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Double64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, DoubleMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Double64Mask)m).getBits())); + (m, __) -> anyTrueHelper(((DoubleMask64)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Double64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, DoubleMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Double64Mask)m).getBits())); + (m, __) -> allTrueHelper(((DoubleMask64)m).getBits())); } @ForceInline /*package-private*/ - static Double64Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Double64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static DoubleMask64 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(DoubleMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Double64Mask TRUE_MASK = new Double64Mask(true); - private static final Double64Mask FALSE_MASK = new Double64Mask(false); + private static final DoubleMask64 TRUE_MASK = new DoubleMask64(true); + private static final DoubleMask64 FALSE_MASK = new DoubleMask64(false); } // Shuffle - static final class Double64Shuffle extends AbstractShuffle { + static final class DoubleShuffle64 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Double64Shuffle(long[] indices) { + DoubleShuffle64(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Double64Shuffle(int[] indices, int i) { + DoubleShuffle64(int[] indices, int i) { this(prepare(indices, i)); } - Double64Shuffle(IntUnaryOperator fn) { + DoubleShuffle64(IntUnaryOperator fn) { this(prepare(fn)); } @@ -819,23 +819,23 @@ final class Double64Vector extends DoubleVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final Double64Shuffle IOTA = new Double64Shuffle(IDENTITY); + static final DoubleShuffle64 IOTA = new DoubleShuffle64(IDENTITY); @Override @ForceInline - public Double64Vector toVector() { - return (Double64Vector) toBitsVector().castShape(vspecies(), 0); + public DoubleVector64 toVector() { + return (DoubleVector64) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - Long64Vector toBitsVector() { - return (Long64Vector) super.toBitsVectorTemplate(); + LongVector64 toBitsVector() { + return (LongVector64) super.toBitsVectorTemplate(); } @Override - Long64Vector toBitsVector0() { - return ((Long64Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVector64 toBitsVector0() { + return ((LongVector64) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -907,30 +907,30 @@ final class Double64Vector extends DoubleVector { @Override @ForceInline - public final Double64Mask laneIsValid() { - return (Double64Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final DoubleMask64 laneIsValid() { + return (DoubleMask64) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Double64Shuffle rearrange(VectorShuffle shuffle) { - Double64Shuffle concreteShuffle = (Double64Shuffle) shuffle; - return (Double64Shuffle) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_64)) + public final DoubleShuffle64 rearrange(VectorShuffle shuffle) { + DoubleShuffle64 concreteShuffle = (DoubleShuffle64) shuffle; + return (DoubleShuffle64) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_64)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Double64Shuffle wrapIndexes() { - Long64Vector v = toBitsVector(); + public final DoubleShuffle64 wrapIndexes() { + LongVector64 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Long64Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVector64) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Long64Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVector64) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Double64Shuffle) v.toShuffle(vspecies(), false); + return (DoubleShuffle64) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -981,14 +981,14 @@ final class Double64Vector extends DoubleVector { @Override final DoubleVector fromArray0(double[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Double64Mask.class, a, offset, (Double64Mask) m, offsetInRange); // specialize + return super.fromArray0Template(DoubleMask64.class, a, offset, (DoubleMask64) m, offsetInRange); // specialize } @ForceInline @Override final DoubleVector fromArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Double64Mask.class, a, offset, indexMap, mapOffset, (Double64Mask) m); + return super.fromArray0Template(DoubleMask64.class, a, offset, indexMap, mapOffset, (DoubleMask64) m); } @@ -1004,7 +1004,7 @@ final class Double64Vector extends DoubleVector { @Override final DoubleVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Double64Mask.class, ms, offset, (Double64Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(DoubleMask64.class, ms, offset, (DoubleMask64) m, offsetInRange); // specialize } @ForceInline @@ -1018,14 +1018,14 @@ final class Double64Vector extends DoubleVector { @Override final void intoArray0(double[] a, int offset, VectorMask m) { - super.intoArray0Template(Double64Mask.class, a, offset, (Double64Mask) m); + super.intoArray0Template(DoubleMask64.class, a, offset, (DoubleMask64) m); } @ForceInline @Override final void intoArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Double64Mask.class, a, offset, indexMap, mapOffset, (Double64Mask) m); + super.intoArray0Template(DoubleMask64.class, a, offset, indexMap, mapOffset, (DoubleMask64) m); } @@ -1033,7 +1033,7 @@ final class Double64Vector extends DoubleVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Double64Mask.class, ms, offset, (Double64Mask) m); + super.intoMemorySegment0Template(DoubleMask64.class, ms, offset, (DoubleMask64) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVectorMax.java similarity index 68% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVectorMax.java index 8daa77dfc49..15166c6e5e5 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVectorMax.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class DoubleMaxVector extends DoubleVector { +final class DoubleVectorMax extends DoubleVector { static final DoubleSpecies VSPECIES = (DoubleSpecies) DoubleVector.SPECIES_MAX; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = DoubleMaxVector.class; + static final Class VCLASS = DoubleVectorMax.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class DoubleMaxVector extends DoubleVector { static final Class ETYPE = double.class; // used by the JVM - DoubleMaxVector(double[] v) { + DoubleVectorMax(double[] v) { super(v); } - // For compatibility as DoubleMaxVector::new, + // For compatibility as DoubleVectorMax::new, // stored into species.vectorFactory. - DoubleMaxVector(Object v) { + DoubleVectorMax(Object v) { this((double[]) v); } - static final DoubleMaxVector ZERO = new DoubleMaxVector(new double[VLENGTH]); - static final DoubleMaxVector IOTA = new DoubleMaxVector(VSPECIES.iotaArray()); + static final DoubleVectorMax ZERO = new DoubleVectorMax(new double[VLENGTH]); + static final DoubleVectorMax IOTA = new DoubleVectorMax(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline - public final DoubleMaxVector broadcast(double e) { - return (DoubleMaxVector) super.broadcastTemplate(e); // specialize + public final DoubleVectorMax broadcast(double e) { + return (DoubleVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final DoubleMaxVector broadcast(long e) { - return (DoubleMaxVector) super.broadcastTemplate(e); // specialize + public final DoubleVectorMax broadcast(long e) { + return (DoubleVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - DoubleMaxMask maskFromArray(boolean[] bits) { - return new DoubleMaxMask(bits); + DoubleMaskMax maskFromArray(boolean[] bits) { + return new DoubleMaskMax(bits); } @Override @ForceInline - DoubleMaxShuffle iotaShuffle() { return DoubleMaxShuffle.IOTA; } + DoubleShuffleMax iotaShuffle() { return DoubleShuffleMax.IOTA; } @Override @ForceInline - DoubleMaxShuffle iotaShuffle(int start, int step, boolean wrap) { - return (DoubleMaxShuffle) iotaShuffleTemplate(start, step, wrap); + DoubleShuffleMax iotaShuffle(int start, int step, boolean wrap) { + return (DoubleShuffleMax) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - DoubleMaxShuffle shuffleFromArray(int[] indices, int i) { return new DoubleMaxShuffle(indices, i); } + DoubleShuffleMax shuffleFromArray(int[] indices, int i) { return new DoubleShuffleMax(indices, i); } @Override @ForceInline - DoubleMaxShuffle shuffleFromOp(IntUnaryOperator fn) { return new DoubleMaxShuffle(fn); } + DoubleShuffleMax shuffleFromOp(IntUnaryOperator fn) { return new DoubleShuffleMax(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - DoubleMaxVector vectorFactory(double[] vec) { - return new DoubleMaxVector(vec); + DoubleVectorMax vectorFactory(double[] vec) { + return new DoubleVectorMax(vec); } @ForceInline final @Override - ByteMaxVector asByteVectorRaw() { - return (ByteMaxVector) super.asByteVectorRawTemplate(); // specialize + ByteVectorMax asByteVectorRaw() { + return (ByteVectorMax) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class DoubleMaxVector extends DoubleVector { @ForceInline final @Override - DoubleMaxVector uOp(FUnOp f) { - return (DoubleMaxVector) super.uOpTemplate(f); // specialize + DoubleVectorMax uOp(FUnOp f) { + return (DoubleVectorMax) super.uOpTemplate(f); // specialize } @ForceInline final @Override - DoubleMaxVector uOp(VectorMask m, FUnOp f) { - return (DoubleMaxVector) - super.uOpTemplate((DoubleMaxMask)m, f); // specialize + DoubleVectorMax uOp(VectorMask m, FUnOp f) { + return (DoubleVectorMax) + super.uOpTemplate((DoubleMaskMax)m, f); // specialize } // Binary operator @ForceInline final @Override - DoubleMaxVector bOp(Vector v, FBinOp f) { - return (DoubleMaxVector) super.bOpTemplate((DoubleMaxVector)v, f); // specialize + DoubleVectorMax bOp(Vector v, FBinOp f) { + return (DoubleVectorMax) super.bOpTemplate((DoubleVectorMax)v, f); // specialize } @ForceInline final @Override - DoubleMaxVector bOp(Vector v, + DoubleVectorMax bOp(Vector v, VectorMask m, FBinOp f) { - return (DoubleMaxVector) - super.bOpTemplate((DoubleMaxVector)v, (DoubleMaxMask)m, + return (DoubleVectorMax) + super.bOpTemplate((DoubleVectorMax)v, (DoubleMaskMax)m, f); // specialize } @@ -219,19 +219,19 @@ final class DoubleMaxVector extends DoubleVector { @ForceInline final @Override - DoubleMaxVector tOp(Vector v1, Vector v2, FTriOp f) { - return (DoubleMaxVector) - super.tOpTemplate((DoubleMaxVector)v1, (DoubleMaxVector)v2, + DoubleVectorMax tOp(Vector v1, Vector v2, FTriOp f) { + return (DoubleVectorMax) + super.tOpTemplate((DoubleVectorMax)v1, (DoubleVectorMax)v2, f); // specialize } @ForceInline final @Override - DoubleMaxVector tOp(Vector v1, Vector v2, + DoubleVectorMax tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (DoubleMaxVector) - super.tOpTemplate((DoubleMaxVector)v1, (DoubleMaxVector)v2, - (DoubleMaxMask)m, f); // specialize + return (DoubleVectorMax) + super.tOpTemplate((DoubleVectorMax)v1, (DoubleVectorMax)v2, + (DoubleMaskMax)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline - public DoubleMaxVector lanewise(Unary op) { - return (DoubleMaxVector) super.lanewiseTemplate(op); // specialize + public DoubleVectorMax lanewise(Unary op) { + return (DoubleVectorMax) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public DoubleMaxVector lanewise(Unary op, VectorMask m) { - return (DoubleMaxVector) super.lanewiseTemplate(op, DoubleMaxMask.class, (DoubleMaxMask) m); // specialize + public DoubleVectorMax lanewise(Unary op, VectorMask m) { + return (DoubleVectorMax) super.lanewiseTemplate(op, DoubleMaskMax.class, (DoubleMaskMax) m); // specialize } @Override @ForceInline - public DoubleMaxVector lanewise(Binary op, Vector v) { - return (DoubleMaxVector) super.lanewiseTemplate(op, v); // specialize + public DoubleVectorMax lanewise(Binary op, Vector v) { + return (DoubleVectorMax) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public DoubleMaxVector lanewise(Binary op, Vector v, VectorMask m) { - return (DoubleMaxVector) super.lanewiseTemplate(op, DoubleMaxMask.class, v, (DoubleMaxMask) m); // specialize + public DoubleVectorMax lanewise(Binary op, Vector v, VectorMask m) { + return (DoubleVectorMax) super.lanewiseTemplate(op, DoubleMaskMax.class, v, (DoubleMaskMax) m); // specialize } @@ -296,24 +296,24 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline public final - DoubleMaxVector + DoubleVectorMax lanewise(Ternary op, Vector v1, Vector v2) { - return (DoubleMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize + return (DoubleVectorMax) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - DoubleMaxVector + DoubleVectorMax lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (DoubleMaxVector) super.lanewiseTemplate(op, DoubleMaxMask.class, v1, v2, (DoubleMaxMask) m); // specialize + return (DoubleVectorMax) super.lanewiseTemplate(op, DoubleMaskMax.class, v1, v2, (DoubleMaskMax) m); // specialize } @Override @ForceInline public final - DoubleMaxVector addIndex(int scale) { - return (DoubleMaxVector) super.addIndexTemplate(scale); // specialize + DoubleVectorMax addIndex(int scale) { + return (DoubleVectorMax) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class DoubleMaxVector extends DoubleVector { @ForceInline public final double reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, DoubleMaxMask.class, (DoubleMaxMask) m); // specialized + return super.reduceLanesTemplate(op, DoubleMaskMax.class, (DoubleMaskMax) m); // specialized } @Override @@ -341,7 +341,7 @@ final class DoubleMaxVector extends DoubleVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, DoubleMaxMask.class, (DoubleMaxMask) m); // specialized + return (long) super.reduceLanesTemplate(op, DoubleMaskMax.class, (DoubleMaskMax) m); // specialized } @Override @@ -352,160 +352,160 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline - public final DoubleMaxShuffle toShuffle() { - return (DoubleMaxShuffle) toShuffle(vspecies(), false); + public final DoubleShuffleMax toShuffle() { + return (DoubleShuffleMax) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final DoubleMaxMask test(Test op) { - return super.testTemplate(DoubleMaxMask.class, op); // specialize + public final DoubleMaskMax test(Test op) { + return super.testTemplate(DoubleMaskMax.class, op); // specialize } @Override @ForceInline - public final DoubleMaxMask test(Test op, VectorMask m) { - return super.testTemplate(DoubleMaxMask.class, op, (DoubleMaxMask) m); // specialize + public final DoubleMaskMax test(Test op, VectorMask m) { + return super.testTemplate(DoubleMaskMax.class, op, (DoubleMaskMax) m); // specialize } // Specialized comparisons @Override @ForceInline - public final DoubleMaxMask compare(Comparison op, Vector v) { - return super.compareTemplate(DoubleMaxMask.class, op, v); // specialize + public final DoubleMaskMax compare(Comparison op, Vector v) { + return super.compareTemplate(DoubleMaskMax.class, op, v); // specialize } @Override @ForceInline - public final DoubleMaxMask compare(Comparison op, double s) { - return super.compareTemplate(DoubleMaxMask.class, op, s); // specialize + public final DoubleMaskMax compare(Comparison op, double s) { + return super.compareTemplate(DoubleMaskMax.class, op, s); // specialize } @Override @ForceInline - public final DoubleMaxMask compare(Comparison op, long s) { - return super.compareTemplate(DoubleMaxMask.class, op, s); // specialize + public final DoubleMaskMax compare(Comparison op, long s) { + return super.compareTemplate(DoubleMaskMax.class, op, s); // specialize } @Override @ForceInline - public final DoubleMaxMask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(DoubleMaxMask.class, op, v, (DoubleMaxMask) m); + public final DoubleMaskMax compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(DoubleMaskMax.class, op, v, (DoubleMaskMax) m); } @Override @ForceInline - public DoubleMaxVector blend(Vector v, VectorMask m) { - return (DoubleMaxVector) - super.blendTemplate(DoubleMaxMask.class, - (DoubleMaxVector) v, - (DoubleMaxMask) m); // specialize + public DoubleVectorMax blend(Vector v, VectorMask m) { + return (DoubleVectorMax) + super.blendTemplate(DoubleMaskMax.class, + (DoubleVectorMax) v, + (DoubleMaskMax) m); // specialize } @Override @ForceInline - public DoubleMaxVector slice(int origin, Vector v) { - return (DoubleMaxVector) super.sliceTemplate(origin, v); // specialize + public DoubleVectorMax slice(int origin, Vector v) { + return (DoubleVectorMax) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public DoubleMaxVector slice(int origin) { - return (DoubleMaxVector) super.sliceTemplate(origin); // specialize + public DoubleVectorMax slice(int origin) { + return (DoubleVectorMax) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public DoubleMaxVector unslice(int origin, Vector w, int part) { - return (DoubleMaxVector) super.unsliceTemplate(origin, w, part); // specialize + public DoubleVectorMax unslice(int origin, Vector w, int part) { + return (DoubleVectorMax) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public DoubleMaxVector unslice(int origin, Vector w, int part, VectorMask m) { - return (DoubleMaxVector) - super.unsliceTemplate(DoubleMaxMask.class, + public DoubleVectorMax unslice(int origin, Vector w, int part, VectorMask m) { + return (DoubleVectorMax) + super.unsliceTemplate(DoubleMaskMax.class, origin, w, part, - (DoubleMaxMask) m); // specialize + (DoubleMaskMax) m); // specialize } @Override @ForceInline - public DoubleMaxVector unslice(int origin) { - return (DoubleMaxVector) super.unsliceTemplate(origin); // specialize + public DoubleVectorMax unslice(int origin) { + return (DoubleVectorMax) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public DoubleMaxVector rearrange(VectorShuffle s) { - return (DoubleMaxVector) - super.rearrangeTemplate(DoubleMaxShuffle.class, - (DoubleMaxShuffle) s); // specialize + public DoubleVectorMax rearrange(VectorShuffle s) { + return (DoubleVectorMax) + super.rearrangeTemplate(DoubleShuffleMax.class, + (DoubleShuffleMax) s); // specialize } @Override @ForceInline - public DoubleMaxVector rearrange(VectorShuffle shuffle, + public DoubleVectorMax rearrange(VectorShuffle shuffle, VectorMask m) { - return (DoubleMaxVector) - super.rearrangeTemplate(DoubleMaxShuffle.class, - DoubleMaxMask.class, - (DoubleMaxShuffle) shuffle, - (DoubleMaxMask) m); // specialize + return (DoubleVectorMax) + super.rearrangeTemplate(DoubleShuffleMax.class, + DoubleMaskMax.class, + (DoubleShuffleMax) shuffle, + (DoubleMaskMax) m); // specialize } @Override @ForceInline - public DoubleMaxVector rearrange(VectorShuffle s, + public DoubleVectorMax rearrange(VectorShuffle s, Vector v) { - return (DoubleMaxVector) - super.rearrangeTemplate(DoubleMaxShuffle.class, - (DoubleMaxShuffle) s, - (DoubleMaxVector) v); // specialize + return (DoubleVectorMax) + super.rearrangeTemplate(DoubleShuffleMax.class, + (DoubleShuffleMax) s, + (DoubleVectorMax) v); // specialize } @Override @ForceInline - public DoubleMaxVector compress(VectorMask m) { - return (DoubleMaxVector) - super.compressTemplate(DoubleMaxMask.class, - (DoubleMaxMask) m); // specialize + public DoubleVectorMax compress(VectorMask m) { + return (DoubleVectorMax) + super.compressTemplate(DoubleMaskMax.class, + (DoubleMaskMax) m); // specialize } @Override @ForceInline - public DoubleMaxVector expand(VectorMask m) { - return (DoubleMaxVector) - super.expandTemplate(DoubleMaxMask.class, - (DoubleMaxMask) m); // specialize + public DoubleVectorMax expand(VectorMask m) { + return (DoubleVectorMax) + super.expandTemplate(DoubleMaskMax.class, + (DoubleMaskMax) m); // specialize } @Override @ForceInline - public DoubleMaxVector selectFrom(Vector v) { - return (DoubleMaxVector) - super.selectFromTemplate((DoubleMaxVector) v); // specialize + public DoubleVectorMax selectFrom(Vector v) { + return (DoubleVectorMax) + super.selectFromTemplate((DoubleVectorMax) v); // specialize } @Override @ForceInline - public DoubleMaxVector selectFrom(Vector v, + public DoubleVectorMax selectFrom(Vector v, VectorMask m) { - return (DoubleMaxVector) - super.selectFromTemplate((DoubleMaxVector) v, - DoubleMaxMask.class, (DoubleMaxMask) m); // specialize + return (DoubleVectorMax) + super.selectFromTemplate((DoubleVectorMax) v, + DoubleMaskMax.class, (DoubleMaskMax) m); // specialize } @Override @ForceInline - public DoubleMaxVector selectFrom(Vector v1, + public DoubleVectorMax selectFrom(Vector v1, Vector v2) { - return (DoubleMaxVector) - super.selectFromTemplate((DoubleMaxVector) v1, (DoubleMaxVector) v2); // specialize + return (DoubleVectorMax) + super.selectFromTemplate((DoubleVectorMax) v1, (DoubleVectorMax) v2); // specialize } @ForceInline @@ -531,7 +531,7 @@ final class DoubleMaxVector extends DoubleVector { @ForceInline @Override - public DoubleMaxVector withLane(int i, double e) { + public DoubleVectorMax withLane(int i, double e) { if (i < 0 || i >= VLENGTH) { throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); } @@ -539,7 +539,7 @@ final class DoubleMaxVector extends DoubleVector { } @ForceInline - public DoubleMaxVector withLaneHelper(int i, double e) { + public DoubleVectorMax withLaneHelper(int i, double e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Double.doubleToRawLongBits(e), @@ -552,19 +552,19 @@ final class DoubleMaxVector extends DoubleVector { // Mask - static final class DoubleMaxMask extends AbstractMask { + static final class DoubleMaskMax extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = double.class; // used by the JVM - DoubleMaxMask(boolean[] bits) { + DoubleMaskMax(boolean[] bits) { this(bits, 0); } - DoubleMaxMask(boolean[] bits, int offset) { + DoubleMaskMax(boolean[] bits, int offset) { super(prepare(bits, offset)); } - DoubleMaxMask(boolean val) { + DoubleMaskMax(boolean val) { super(prepare(val)); } @@ -597,31 +597,31 @@ final class DoubleMaxVector extends DoubleVector { } @Override - DoubleMaxMask uOp(MUnOp f) { + DoubleMaskMax uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new DoubleMaxMask(res); + return new DoubleMaskMax(res); } @Override - DoubleMaxMask bOp(VectorMask m, MBinOp f) { + DoubleMaskMax bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((DoubleMaxMask)m).getBits(); + boolean[] mbits = ((DoubleMaskMax)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new DoubleMaxMask(res); + return new DoubleMaskMax(res); } @ForceInline @Override public final - DoubleMaxVector toVector() { - return (DoubleMaxVector) super.toVectorTemplate(); // specialize + DoubleVectorMax toVector() { + return (DoubleVectorMax) super.toVectorTemplate(); // specialize } /** @@ -654,25 +654,25 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline /*package-private*/ - DoubleMaxMask indexPartiallyInUpperRange(long offset, long limit) { - return (DoubleMaxMask) VectorSupport.indexPartiallyInUpperRange( - DoubleMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (DoubleMaxMask) TRUE_MASK.indexPartiallyInRange(o, l)); + DoubleMaskMax indexPartiallyInUpperRange(long offset, long limit) { + return (DoubleMaskMax) VectorSupport.indexPartiallyInUpperRange( + DoubleMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (DoubleMaskMax) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public DoubleMaxMask not() { + public DoubleMaskMax not() { return xor(maskAll(true)); } @Override @ForceInline - public DoubleMaxMask compress() { - return (DoubleMaxMask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - DoubleMaxVector.class, DoubleMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public DoubleMaskMax compress() { + return (DoubleMaskMax)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + DoubleVectorMax.class, DoubleMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -681,30 +681,30 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline - public DoubleMaxMask and(VectorMask mask) { + public DoubleMaskMax and(VectorMask mask) { Objects.requireNonNull(mask); - DoubleMaxMask m = (DoubleMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, DoubleMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMaskMax m = (DoubleMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, DoubleMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public DoubleMaxMask or(VectorMask mask) { + public DoubleMaskMax or(VectorMask mask) { Objects.requireNonNull(mask); - DoubleMaxMask m = (DoubleMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, DoubleMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMaskMax m = (DoubleMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, DoubleMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public DoubleMaxMask xor(VectorMask mask) { + public DoubleMaskMax xor(VectorMask mask) { Objects.requireNonNull(mask); - DoubleMaxMask m = (DoubleMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + DoubleMaskMax m = (DoubleMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -714,21 +714,21 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, DoubleMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, DoubleMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, DoubleMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, DoubleMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, DoubleMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, DoubleMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -738,7 +738,7 @@ final class DoubleMaxVector extends DoubleVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, DoubleMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, DoubleMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -748,7 +748,7 @@ final class DoubleMaxVector extends DoubleVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(DoubleMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(DoubleMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -757,48 +757,48 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, DoubleMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, DoubleMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((DoubleMaxMask)m).getBits())); + (m, __) -> anyTrueHelper(((DoubleMaskMax)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, DoubleMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, DoubleMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((DoubleMaxMask)m).getBits())); + (m, __) -> allTrueHelper(((DoubleMaskMax)m).getBits())); } @ForceInline /*package-private*/ - static DoubleMaxMask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(DoubleMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static DoubleMaskMax maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(DoubleMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final DoubleMaxMask TRUE_MASK = new DoubleMaxMask(true); - private static final DoubleMaxMask FALSE_MASK = new DoubleMaxMask(false); + private static final DoubleMaskMax TRUE_MASK = new DoubleMaskMax(true); + private static final DoubleMaskMax FALSE_MASK = new DoubleMaskMax(false); } // Shuffle - static final class DoubleMaxShuffle extends AbstractShuffle { + static final class DoubleShuffleMax extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - DoubleMaxShuffle(long[] indices) { + DoubleShuffleMax(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - DoubleMaxShuffle(int[] indices, int i) { + DoubleShuffleMax(int[] indices, int i) { this(prepare(indices, i)); } - DoubleMaxShuffle(IntUnaryOperator fn) { + DoubleShuffleMax(IntUnaryOperator fn) { this(prepare(fn)); } @@ -818,23 +818,23 @@ final class DoubleMaxVector extends DoubleVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final DoubleMaxShuffle IOTA = new DoubleMaxShuffle(IDENTITY); + static final DoubleShuffleMax IOTA = new DoubleShuffleMax(IDENTITY); @Override @ForceInline - public DoubleMaxVector toVector() { - return (DoubleMaxVector) toBitsVector().castShape(vspecies(), 0); + public DoubleVectorMax toVector() { + return (DoubleVectorMax) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - LongMaxVector toBitsVector() { - return (LongMaxVector) super.toBitsVectorTemplate(); + LongVectorMax toBitsVector() { + return (LongVectorMax) super.toBitsVectorTemplate(); } @Override - LongMaxVector toBitsVector0() { - return ((LongMaxVector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVectorMax toBitsVector0() { + return ((LongVectorMax) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -906,30 +906,30 @@ final class DoubleMaxVector extends DoubleVector { @Override @ForceInline - public final DoubleMaxMask laneIsValid() { - return (DoubleMaxMask) toBitsVector().compare(VectorOperators.GE, 0) + public final DoubleMaskMax laneIsValid() { + return (DoubleMaskMax) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final DoubleMaxShuffle rearrange(VectorShuffle shuffle) { - DoubleMaxShuffle concreteShuffle = (DoubleMaxShuffle) shuffle; - return (DoubleMaxShuffle) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_MAX)) + public final DoubleShuffleMax rearrange(VectorShuffle shuffle) { + DoubleShuffleMax concreteShuffle = (DoubleShuffleMax) shuffle; + return (DoubleShuffleMax) toBitsVector().rearrange(concreteShuffle.cast(LongVector.SPECIES_MAX)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final DoubleMaxShuffle wrapIndexes() { - LongMaxVector v = toBitsVector(); + public final DoubleShuffleMax wrapIndexes() { + LongVectorMax v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (LongMaxVector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVectorMax) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (LongMaxVector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVectorMax) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (DoubleMaxShuffle) v.toShuffle(vspecies(), false); + return (DoubleShuffleMax) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -980,14 +980,14 @@ final class DoubleMaxVector extends DoubleVector { @Override final DoubleVector fromArray0(double[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(DoubleMaxMask.class, a, offset, (DoubleMaxMask) m, offsetInRange); // specialize + return super.fromArray0Template(DoubleMaskMax.class, a, offset, (DoubleMaskMax) m, offsetInRange); // specialize } @ForceInline @Override final DoubleVector fromArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(DoubleMaxMask.class, a, offset, indexMap, mapOffset, (DoubleMaxMask) m); + return super.fromArray0Template(DoubleMaskMax.class, a, offset, indexMap, mapOffset, (DoubleMaskMax) m); } @@ -1003,7 +1003,7 @@ final class DoubleMaxVector extends DoubleVector { @Override final DoubleVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(DoubleMaxMask.class, ms, offset, (DoubleMaxMask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(DoubleMaskMax.class, ms, offset, (DoubleMaskMax) m, offsetInRange); // specialize } @ForceInline @@ -1017,14 +1017,14 @@ final class DoubleMaxVector extends DoubleVector { @Override final void intoArray0(double[] a, int offset, VectorMask m) { - super.intoArray0Template(DoubleMaxMask.class, a, offset, (DoubleMaxMask) m); + super.intoArray0Template(DoubleMaskMax.class, a, offset, (DoubleMaskMax) m); } @ForceInline @Override final void intoArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(DoubleMaxMask.class, a, offset, indexMap, mapOffset, (DoubleMaxMask) m); + super.intoArray0Template(DoubleMaskMax.class, a, offset, indexMap, mapOffset, (DoubleMaskMax) m); } @@ -1032,7 +1032,7 @@ final class DoubleMaxVector extends DoubleVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(DoubleMaxMask.class, ms, offset, (DoubleMaxMask) m); + super.intoMemorySegment0Template(DoubleMaskMax.class, ms, offset, (DoubleMaskMax) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java index ee9cb9119fd..9950abf696d 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java @@ -84,8 +84,8 @@ public abstract class FloatVector extends AbstractVector { // The various shape-specific subclasses // also specialize them by wrapping // them in a call like this: - // return (Byte128Vector) - // super.bOp((Byte128Vector) o); + // return (ByteVector128) + // super.bOp((ByteVector128) o); // The purpose of that is to forcibly inline // the generic definition from this file // into a sharply-typed and size-specific @@ -3926,13 +3926,13 @@ public abstract class FloatVector extends AbstractVector { @Override @ForceInline public final FloatVector zero() { - if ((Class) vectorType() == FloatMaxVector.class) - return FloatMaxVector.ZERO; + if ((Class) vectorType() == FloatVectorMax.class) + return FloatVectorMax.ZERO; switch (vectorBitSize()) { - case 64: return Float64Vector.ZERO; - case 128: return Float128Vector.ZERO; - case 256: return Float256Vector.ZERO; - case 512: return Float512Vector.ZERO; + case 64: return FloatVector64.ZERO; + case 128: return FloatVector128.ZERO; + case 256: return FloatVector256.ZERO; + case 512: return FloatVector512.ZERO; } throw new AssertionError(); } @@ -3940,13 +3940,13 @@ public abstract class FloatVector extends AbstractVector { @Override @ForceInline public final FloatVector iota() { - if ((Class) vectorType() == FloatMaxVector.class) - return FloatMaxVector.IOTA; + if ((Class) vectorType() == FloatVectorMax.class) + return FloatVectorMax.IOTA; switch (vectorBitSize()) { - case 64: return Float64Vector.IOTA; - case 128: return Float128Vector.IOTA; - case 256: return Float256Vector.IOTA; - case 512: return Float512Vector.IOTA; + case 64: return FloatVector64.IOTA; + case 128: return FloatVector128.IOTA; + case 256: return FloatVector256.IOTA; + case 512: return FloatVector512.IOTA; } throw new AssertionError(); } @@ -3955,13 +3955,13 @@ public abstract class FloatVector extends AbstractVector { @Override @ForceInline public final VectorMask maskAll(boolean bit) { - if ((Class) vectorType() == FloatMaxVector.class) - return FloatMaxVector.FloatMaxMask.maskAll(bit); + if ((Class) vectorType() == FloatVectorMax.class) + return FloatVectorMax.FloatMaskMax.maskAll(bit); switch (vectorBitSize()) { - case 64: return Float64Vector.Float64Mask.maskAll(bit); - case 128: return Float128Vector.Float128Mask.maskAll(bit); - case 256: return Float256Vector.Float256Mask.maskAll(bit); - case 512: return Float512Vector.Float512Mask.maskAll(bit); + case 64: return FloatVector64.FloatMask64.maskAll(bit); + case 128: return FloatVector128.FloatMask128.maskAll(bit); + case 256: return FloatVector256.FloatMask256.maskAll(bit); + case 512: return FloatVector512.FloatMask512.maskAll(bit); } throw new AssertionError(); } @@ -3989,42 +3989,42 @@ public abstract class FloatVector extends AbstractVector { /** Species representing {@link FloatVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ public static final VectorSpecies SPECIES_64 = new FloatSpecies(VectorShape.S_64_BIT, - Float64Vector.class, - Float64Vector.Float64Mask.class, - Float64Vector.Float64Shuffle.class, - Float64Vector::new); + FloatVector64.class, + FloatVector64.FloatMask64.class, + FloatVector64.FloatShuffle64.class, + FloatVector64::new); /** Species representing {@link FloatVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ public static final VectorSpecies SPECIES_128 = new FloatSpecies(VectorShape.S_128_BIT, - Float128Vector.class, - Float128Vector.Float128Mask.class, - Float128Vector.Float128Shuffle.class, - Float128Vector::new); + FloatVector128.class, + FloatVector128.FloatMask128.class, + FloatVector128.FloatShuffle128.class, + FloatVector128::new); /** Species representing {@link FloatVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ public static final VectorSpecies SPECIES_256 = new FloatSpecies(VectorShape.S_256_BIT, - Float256Vector.class, - Float256Vector.Float256Mask.class, - Float256Vector.Float256Shuffle.class, - Float256Vector::new); + FloatVector256.class, + FloatVector256.FloatMask256.class, + FloatVector256.FloatShuffle256.class, + FloatVector256::new); /** Species representing {@link FloatVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ public static final VectorSpecies SPECIES_512 = new FloatSpecies(VectorShape.S_512_BIT, - Float512Vector.class, - Float512Vector.Float512Mask.class, - Float512Vector.Float512Shuffle.class, - Float512Vector::new); + FloatVector512.class, + FloatVector512.FloatMask512.class, + FloatVector512.FloatShuffle512.class, + FloatVector512::new); /** Species representing {@link FloatVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ public static final VectorSpecies SPECIES_MAX = new FloatSpecies(VectorShape.S_Max_BIT, - FloatMaxVector.class, - FloatMaxVector.FloatMaxMask.class, - FloatMaxVector.FloatMaxShuffle.class, - FloatMaxVector::new); + FloatVectorMax.class, + FloatVectorMax.FloatMaskMax.class, + FloatVectorMax.FloatShuffleMax.class, + FloatVectorMax::new); /** * Preferred species for {@link FloatVector}s. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector128.java similarity index 65% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector128.java index 62c7d535fc7..809e947c6d8 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector128.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Float128Vector extends FloatVector { +final class FloatVector128 extends FloatVector { static final FloatSpecies VSPECIES = (FloatSpecies) FloatVector.SPECIES_128; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Float128Vector.class; + static final Class VCLASS = FloatVector128.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Float128Vector extends FloatVector { static final Class ETYPE = float.class; // used by the JVM - Float128Vector(float[] v) { + FloatVector128(float[] v) { super(v); } - // For compatibility as Float128Vector::new, + // For compatibility as FloatVector128::new, // stored into species.vectorFactory. - Float128Vector(Object v) { + FloatVector128(Object v) { this((float[]) v); } - static final Float128Vector ZERO = new Float128Vector(new float[VLENGTH]); - static final Float128Vector IOTA = new Float128Vector(VSPECIES.iotaArray()); + static final FloatVector128 ZERO = new FloatVector128(new float[VLENGTH]); + static final FloatVector128 IOTA = new FloatVector128(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Float128Vector extends FloatVector { @Override @ForceInline - public final Float128Vector broadcast(float e) { - return (Float128Vector) super.broadcastTemplate(e); // specialize + public final FloatVector128 broadcast(float e) { + return (FloatVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Float128Vector broadcast(long e) { - return (Float128Vector) super.broadcastTemplate(e); // specialize + public final FloatVector128 broadcast(long e) { + return (FloatVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Float128Mask maskFromArray(boolean[] bits) { - return new Float128Mask(bits); + FloatMask128 maskFromArray(boolean[] bits) { + return new FloatMask128(bits); } @Override @ForceInline - Float128Shuffle iotaShuffle() { return Float128Shuffle.IOTA; } + FloatShuffle128 iotaShuffle() { return FloatShuffle128.IOTA; } @Override @ForceInline - Float128Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Float128Shuffle) iotaShuffleTemplate(start, step, wrap); + FloatShuffle128 iotaShuffle(int start, int step, boolean wrap) { + return (FloatShuffle128) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Float128Shuffle shuffleFromArray(int[] indices, int i) { return new Float128Shuffle(indices, i); } + FloatShuffle128 shuffleFromArray(int[] indices, int i) { return new FloatShuffle128(indices, i); } @Override @ForceInline - Float128Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Float128Shuffle(fn); } + FloatShuffle128 shuffleFromOp(IntUnaryOperator fn) { return new FloatShuffle128(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Float128Vector vectorFactory(float[] vec) { - return new Float128Vector(vec); + FloatVector128 vectorFactory(float[] vec) { + return new FloatVector128(vec); } @ForceInline final @Override - Byte128Vector asByteVectorRaw() { - return (Byte128Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector128 asByteVectorRaw() { + return (ByteVector128) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Float128Vector extends FloatVector { @ForceInline final @Override - Float128Vector uOp(FUnOp f) { - return (Float128Vector) super.uOpTemplate(f); // specialize + FloatVector128 uOp(FUnOp f) { + return (FloatVector128) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Float128Vector uOp(VectorMask m, FUnOp f) { - return (Float128Vector) - super.uOpTemplate((Float128Mask)m, f); // specialize + FloatVector128 uOp(VectorMask m, FUnOp f) { + return (FloatVector128) + super.uOpTemplate((FloatMask128)m, f); // specialize } // Binary operator @ForceInline final @Override - Float128Vector bOp(Vector v, FBinOp f) { - return (Float128Vector) super.bOpTemplate((Float128Vector)v, f); // specialize + FloatVector128 bOp(Vector v, FBinOp f) { + return (FloatVector128) super.bOpTemplate((FloatVector128)v, f); // specialize } @ForceInline final @Override - Float128Vector bOp(Vector v, + FloatVector128 bOp(Vector v, VectorMask m, FBinOp f) { - return (Float128Vector) - super.bOpTemplate((Float128Vector)v, (Float128Mask)m, + return (FloatVector128) + super.bOpTemplate((FloatVector128)v, (FloatMask128)m, f); // specialize } @@ -219,19 +219,19 @@ final class Float128Vector extends FloatVector { @ForceInline final @Override - Float128Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Float128Vector) - super.tOpTemplate((Float128Vector)v1, (Float128Vector)v2, + FloatVector128 tOp(Vector v1, Vector v2, FTriOp f) { + return (FloatVector128) + super.tOpTemplate((FloatVector128)v1, (FloatVector128)v2, f); // specialize } @ForceInline final @Override - Float128Vector tOp(Vector v1, Vector v2, + FloatVector128 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Float128Vector) - super.tOpTemplate((Float128Vector)v1, (Float128Vector)v2, - (Float128Mask)m, f); // specialize + return (FloatVector128) + super.tOpTemplate((FloatVector128)v1, (FloatVector128)v2, + (FloatMask128)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class Float128Vector extends FloatVector { @Override @ForceInline - public Float128Vector lanewise(Unary op) { - return (Float128Vector) super.lanewiseTemplate(op); // specialize + public FloatVector128 lanewise(Unary op) { + return (FloatVector128) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Float128Vector lanewise(Unary op, VectorMask m) { - return (Float128Vector) super.lanewiseTemplate(op, Float128Mask.class, (Float128Mask) m); // specialize + public FloatVector128 lanewise(Unary op, VectorMask m) { + return (FloatVector128) super.lanewiseTemplate(op, FloatMask128.class, (FloatMask128) m); // specialize } @Override @ForceInline - public Float128Vector lanewise(Binary op, Vector v) { - return (Float128Vector) super.lanewiseTemplate(op, v); // specialize + public FloatVector128 lanewise(Binary op, Vector v) { + return (FloatVector128) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Float128Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Float128Vector) super.lanewiseTemplate(op, Float128Mask.class, v, (Float128Mask) m); // specialize + public FloatVector128 lanewise(Binary op, Vector v, VectorMask m) { + return (FloatVector128) super.lanewiseTemplate(op, FloatMask128.class, v, (FloatMask128) m); // specialize } @@ -296,24 +296,24 @@ final class Float128Vector extends FloatVector { @Override @ForceInline public final - Float128Vector + FloatVector128 lanewise(Ternary op, Vector v1, Vector v2) { - return (Float128Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (FloatVector128) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Float128Vector + FloatVector128 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Float128Vector) super.lanewiseTemplate(op, Float128Mask.class, v1, v2, (Float128Mask) m); // specialize + return (FloatVector128) super.lanewiseTemplate(op, FloatMask128.class, v1, v2, (FloatMask128) m); // specialize } @Override @ForceInline public final - Float128Vector addIndex(int scale) { - return (Float128Vector) super.addIndexTemplate(scale); // specialize + FloatVector128 addIndex(int scale) { + return (FloatVector128) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class Float128Vector extends FloatVector { @ForceInline public final float reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Float128Mask.class, (Float128Mask) m); // specialized + return super.reduceLanesTemplate(op, FloatMask128.class, (FloatMask128) m); // specialized } @Override @@ -341,7 +341,7 @@ final class Float128Vector extends FloatVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Float128Mask.class, (Float128Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, FloatMask128.class, (FloatMask128) m); // specialized } @Override @@ -352,160 +352,160 @@ final class Float128Vector extends FloatVector { @Override @ForceInline - public final Float128Shuffle toShuffle() { - return (Float128Shuffle) toShuffle(vspecies(), false); + public final FloatShuffle128 toShuffle() { + return (FloatShuffle128) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Float128Mask test(Test op) { - return super.testTemplate(Float128Mask.class, op); // specialize + public final FloatMask128 test(Test op) { + return super.testTemplate(FloatMask128.class, op); // specialize } @Override @ForceInline - public final Float128Mask test(Test op, VectorMask m) { - return super.testTemplate(Float128Mask.class, op, (Float128Mask) m); // specialize + public final FloatMask128 test(Test op, VectorMask m) { + return super.testTemplate(FloatMask128.class, op, (FloatMask128) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Float128Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Float128Mask.class, op, v); // specialize + public final FloatMask128 compare(Comparison op, Vector v) { + return super.compareTemplate(FloatMask128.class, op, v); // specialize } @Override @ForceInline - public final Float128Mask compare(Comparison op, float s) { - return super.compareTemplate(Float128Mask.class, op, s); // specialize + public final FloatMask128 compare(Comparison op, float s) { + return super.compareTemplate(FloatMask128.class, op, s); // specialize } @Override @ForceInline - public final Float128Mask compare(Comparison op, long s) { - return super.compareTemplate(Float128Mask.class, op, s); // specialize + public final FloatMask128 compare(Comparison op, long s) { + return super.compareTemplate(FloatMask128.class, op, s); // specialize } @Override @ForceInline - public final Float128Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Float128Mask.class, op, v, (Float128Mask) m); + public final FloatMask128 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(FloatMask128.class, op, v, (FloatMask128) m); } @Override @ForceInline - public Float128Vector blend(Vector v, VectorMask m) { - return (Float128Vector) - super.blendTemplate(Float128Mask.class, - (Float128Vector) v, - (Float128Mask) m); // specialize + public FloatVector128 blend(Vector v, VectorMask m) { + return (FloatVector128) + super.blendTemplate(FloatMask128.class, + (FloatVector128) v, + (FloatMask128) m); // specialize } @Override @ForceInline - public Float128Vector slice(int origin, Vector v) { - return (Float128Vector) super.sliceTemplate(origin, v); // specialize + public FloatVector128 slice(int origin, Vector v) { + return (FloatVector128) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Float128Vector slice(int origin) { - return (Float128Vector) super.sliceTemplate(origin); // specialize + public FloatVector128 slice(int origin) { + return (FloatVector128) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Float128Vector unslice(int origin, Vector w, int part) { - return (Float128Vector) super.unsliceTemplate(origin, w, part); // specialize + public FloatVector128 unslice(int origin, Vector w, int part) { + return (FloatVector128) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Float128Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Float128Vector) - super.unsliceTemplate(Float128Mask.class, + public FloatVector128 unslice(int origin, Vector w, int part, VectorMask m) { + return (FloatVector128) + super.unsliceTemplate(FloatMask128.class, origin, w, part, - (Float128Mask) m); // specialize + (FloatMask128) m); // specialize } @Override @ForceInline - public Float128Vector unslice(int origin) { - return (Float128Vector) super.unsliceTemplate(origin); // specialize + public FloatVector128 unslice(int origin) { + return (FloatVector128) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Float128Vector rearrange(VectorShuffle s) { - return (Float128Vector) - super.rearrangeTemplate(Float128Shuffle.class, - (Float128Shuffle) s); // specialize + public FloatVector128 rearrange(VectorShuffle s) { + return (FloatVector128) + super.rearrangeTemplate(FloatShuffle128.class, + (FloatShuffle128) s); // specialize } @Override @ForceInline - public Float128Vector rearrange(VectorShuffle shuffle, + public FloatVector128 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Float128Vector) - super.rearrangeTemplate(Float128Shuffle.class, - Float128Mask.class, - (Float128Shuffle) shuffle, - (Float128Mask) m); // specialize + return (FloatVector128) + super.rearrangeTemplate(FloatShuffle128.class, + FloatMask128.class, + (FloatShuffle128) shuffle, + (FloatMask128) m); // specialize } @Override @ForceInline - public Float128Vector rearrange(VectorShuffle s, + public FloatVector128 rearrange(VectorShuffle s, Vector v) { - return (Float128Vector) - super.rearrangeTemplate(Float128Shuffle.class, - (Float128Shuffle) s, - (Float128Vector) v); // specialize + return (FloatVector128) + super.rearrangeTemplate(FloatShuffle128.class, + (FloatShuffle128) s, + (FloatVector128) v); // specialize } @Override @ForceInline - public Float128Vector compress(VectorMask m) { - return (Float128Vector) - super.compressTemplate(Float128Mask.class, - (Float128Mask) m); // specialize + public FloatVector128 compress(VectorMask m) { + return (FloatVector128) + super.compressTemplate(FloatMask128.class, + (FloatMask128) m); // specialize } @Override @ForceInline - public Float128Vector expand(VectorMask m) { - return (Float128Vector) - super.expandTemplate(Float128Mask.class, - (Float128Mask) m); // specialize + public FloatVector128 expand(VectorMask m) { + return (FloatVector128) + super.expandTemplate(FloatMask128.class, + (FloatMask128) m); // specialize } @Override @ForceInline - public Float128Vector selectFrom(Vector v) { - return (Float128Vector) - super.selectFromTemplate((Float128Vector) v); // specialize + public FloatVector128 selectFrom(Vector v) { + return (FloatVector128) + super.selectFromTemplate((FloatVector128) v); // specialize } @Override @ForceInline - public Float128Vector selectFrom(Vector v, + public FloatVector128 selectFrom(Vector v, VectorMask m) { - return (Float128Vector) - super.selectFromTemplate((Float128Vector) v, - Float128Mask.class, (Float128Mask) m); // specialize + return (FloatVector128) + super.selectFromTemplate((FloatVector128) v, + FloatMask128.class, (FloatMask128) m); // specialize } @Override @ForceInline - public Float128Vector selectFrom(Vector v1, + public FloatVector128 selectFrom(Vector v1, Vector v2) { - return (Float128Vector) - super.selectFromTemplate((Float128Vector) v1, (Float128Vector) v2); // specialize + return (FloatVector128) + super.selectFromTemplate((FloatVector128) v1, (FloatVector128) v2); // specialize } @ForceInline @@ -535,7 +535,7 @@ final class Float128Vector extends FloatVector { @ForceInline @Override - public Float128Vector withLane(int i, float e) { + public FloatVector128 withLane(int i, float e) { switch(i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -546,7 +546,7 @@ final class Float128Vector extends FloatVector { } @ForceInline - public Float128Vector withLaneHelper(int i, float e) { + public FloatVector128 withLaneHelper(int i, float e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Float.floatToRawIntBits(e), @@ -559,19 +559,19 @@ final class Float128Vector extends FloatVector { // Mask - static final class Float128Mask extends AbstractMask { + static final class FloatMask128 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = float.class; // used by the JVM - Float128Mask(boolean[] bits) { + FloatMask128(boolean[] bits) { this(bits, 0); } - Float128Mask(boolean[] bits, int offset) { + FloatMask128(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Float128Mask(boolean val) { + FloatMask128(boolean val) { super(prepare(val)); } @@ -604,31 +604,31 @@ final class Float128Vector extends FloatVector { } @Override - Float128Mask uOp(MUnOp f) { + FloatMask128 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Float128Mask(res); + return new FloatMask128(res); } @Override - Float128Mask bOp(VectorMask m, MBinOp f) { + FloatMask128 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Float128Mask)m).getBits(); + boolean[] mbits = ((FloatMask128)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Float128Mask(res); + return new FloatMask128(res); } @ForceInline @Override public final - Float128Vector toVector() { - return (Float128Vector) super.toVectorTemplate(); // specialize + FloatVector128 toVector() { + return (FloatVector128) super.toVectorTemplate(); // specialize } /** @@ -661,25 +661,25 @@ final class Float128Vector extends FloatVector { @Override @ForceInline /*package-private*/ - Float128Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Float128Mask) VectorSupport.indexPartiallyInUpperRange( - Float128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Float128Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + FloatMask128 indexPartiallyInUpperRange(long offset, long limit) { + return (FloatMask128) VectorSupport.indexPartiallyInUpperRange( + FloatMask128.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (FloatMask128) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Float128Mask not() { + public FloatMask128 not() { return xor(maskAll(true)); } @Override @ForceInline - public Float128Mask compress() { - return (Float128Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Float128Vector.class, Float128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public FloatMask128 compress() { + return (FloatMask128)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + FloatVector128.class, FloatMask128.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -688,30 +688,30 @@ final class Float128Vector extends FloatVector { @Override @ForceInline - public Float128Mask and(VectorMask mask) { + public FloatMask128 and(VectorMask mask) { Objects.requireNonNull(mask); - Float128Mask m = (Float128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Float128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask128 m = (FloatMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Float128Mask or(VectorMask mask) { + public FloatMask128 or(VectorMask mask) { Objects.requireNonNull(mask); - Float128Mask m = (Float128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Float128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask128 m = (FloatMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Float128Mask xor(VectorMask mask) { + public FloatMask128 xor(VectorMask mask) { Objects.requireNonNull(mask); - Float128Mask m = (Float128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Float128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask128 m = (FloatMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -721,21 +721,21 @@ final class Float128Vector extends FloatVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Float128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, FloatMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Float128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, FloatMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Float128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, FloatMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -745,7 +745,7 @@ final class Float128Vector extends FloatVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Float128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, FloatMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -755,7 +755,7 @@ final class Float128Vector extends FloatVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Float128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(FloatMask128.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -764,48 +764,48 @@ final class Float128Vector extends FloatVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Float128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, FloatMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Float128Mask)m).getBits())); + (m, __) -> anyTrueHelper(((FloatMask128)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Float128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, FloatMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Float128Mask)m).getBits())); + (m, __) -> allTrueHelper(((FloatMask128)m).getBits())); } @ForceInline /*package-private*/ - static Float128Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Float128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static FloatMask128 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(FloatMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Float128Mask TRUE_MASK = new Float128Mask(true); - private static final Float128Mask FALSE_MASK = new Float128Mask(false); + private static final FloatMask128 TRUE_MASK = new FloatMask128(true); + private static final FloatMask128 FALSE_MASK = new FloatMask128(false); } // Shuffle - static final class Float128Shuffle extends AbstractShuffle { + static final class FloatShuffle128 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Float128Shuffle(int[] indices) { + FloatShuffle128(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Float128Shuffle(int[] indices, int i) { + FloatShuffle128(int[] indices, int i) { this(prepare(indices, i)); } - Float128Shuffle(IntUnaryOperator fn) { + FloatShuffle128(IntUnaryOperator fn) { this(prepare(fn)); } @@ -825,23 +825,23 @@ final class Float128Vector extends FloatVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final Float128Shuffle IOTA = new Float128Shuffle(IDENTITY); + static final FloatShuffle128 IOTA = new FloatShuffle128(IDENTITY); @Override @ForceInline - public Float128Vector toVector() { - return (Float128Vector) toBitsVector().castShape(vspecies(), 0); + public FloatVector128 toVector() { + return (FloatVector128) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - Int128Vector toBitsVector() { - return (Int128Vector) super.toBitsVectorTemplate(); + IntVector128 toBitsVector() { + return (IntVector128) super.toBitsVectorTemplate(); } @Override - Int128Vector toBitsVector0() { - return ((Int128Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVector128 toBitsVector0() { + return ((IntVector128) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -864,30 +864,30 @@ final class Float128Vector extends FloatVector { @Override @ForceInline - public final Float128Mask laneIsValid() { - return (Float128Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final FloatMask128 laneIsValid() { + return (FloatMask128) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Float128Shuffle rearrange(VectorShuffle shuffle) { - Float128Shuffle concreteShuffle = (Float128Shuffle) shuffle; - return (Float128Shuffle) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_128)) + public final FloatShuffle128 rearrange(VectorShuffle shuffle) { + FloatShuffle128 concreteShuffle = (FloatShuffle128) shuffle; + return (FloatShuffle128) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_128)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Float128Shuffle wrapIndexes() { - Int128Vector v = toBitsVector(); + public final FloatShuffle128 wrapIndexes() { + IntVector128 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Int128Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVector128) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Int128Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVector128) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Float128Shuffle) v.toShuffle(vspecies(), false); + return (FloatShuffle128) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -938,14 +938,14 @@ final class Float128Vector extends FloatVector { @Override final FloatVector fromArray0(float[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Float128Mask.class, a, offset, (Float128Mask) m, offsetInRange); // specialize + return super.fromArray0Template(FloatMask128.class, a, offset, (FloatMask128) m, offsetInRange); // specialize } @ForceInline @Override final FloatVector fromArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Float128Mask.class, a, offset, indexMap, mapOffset, (Float128Mask) m); + return super.fromArray0Template(FloatMask128.class, a, offset, indexMap, mapOffset, (FloatMask128) m); } @@ -961,7 +961,7 @@ final class Float128Vector extends FloatVector { @Override final FloatVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Float128Mask.class, ms, offset, (Float128Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(FloatMask128.class, ms, offset, (FloatMask128) m, offsetInRange); // specialize } @ForceInline @@ -975,14 +975,14 @@ final class Float128Vector extends FloatVector { @Override final void intoArray0(float[] a, int offset, VectorMask m) { - super.intoArray0Template(Float128Mask.class, a, offset, (Float128Mask) m); + super.intoArray0Template(FloatMask128.class, a, offset, (FloatMask128) m); } @ForceInline @Override final void intoArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Float128Mask.class, a, offset, indexMap, mapOffset, (Float128Mask) m); + super.intoArray0Template(FloatMask128.class, a, offset, indexMap, mapOffset, (FloatMask128) m); } @@ -990,7 +990,7 @@ final class Float128Vector extends FloatVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Float128Mask.class, ms, offset, (Float128Mask) m); + super.intoMemorySegment0Template(FloatMask128.class, ms, offset, (FloatMask128) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector256.java similarity index 66% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector256.java index f41194500f9..06dcc061a27 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector256.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Float256Vector extends FloatVector { +final class FloatVector256 extends FloatVector { static final FloatSpecies VSPECIES = (FloatSpecies) FloatVector.SPECIES_256; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Float256Vector.class; + static final Class VCLASS = FloatVector256.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Float256Vector extends FloatVector { static final Class ETYPE = float.class; // used by the JVM - Float256Vector(float[] v) { + FloatVector256(float[] v) { super(v); } - // For compatibility as Float256Vector::new, + // For compatibility as FloatVector256::new, // stored into species.vectorFactory. - Float256Vector(Object v) { + FloatVector256(Object v) { this((float[]) v); } - static final Float256Vector ZERO = new Float256Vector(new float[VLENGTH]); - static final Float256Vector IOTA = new Float256Vector(VSPECIES.iotaArray()); + static final FloatVector256 ZERO = new FloatVector256(new float[VLENGTH]); + static final FloatVector256 IOTA = new FloatVector256(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Float256Vector extends FloatVector { @Override @ForceInline - public final Float256Vector broadcast(float e) { - return (Float256Vector) super.broadcastTemplate(e); // specialize + public final FloatVector256 broadcast(float e) { + return (FloatVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Float256Vector broadcast(long e) { - return (Float256Vector) super.broadcastTemplate(e); // specialize + public final FloatVector256 broadcast(long e) { + return (FloatVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Float256Mask maskFromArray(boolean[] bits) { - return new Float256Mask(bits); + FloatMask256 maskFromArray(boolean[] bits) { + return new FloatMask256(bits); } @Override @ForceInline - Float256Shuffle iotaShuffle() { return Float256Shuffle.IOTA; } + FloatShuffle256 iotaShuffle() { return FloatShuffle256.IOTA; } @Override @ForceInline - Float256Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Float256Shuffle) iotaShuffleTemplate(start, step, wrap); + FloatShuffle256 iotaShuffle(int start, int step, boolean wrap) { + return (FloatShuffle256) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Float256Shuffle shuffleFromArray(int[] indices, int i) { return new Float256Shuffle(indices, i); } + FloatShuffle256 shuffleFromArray(int[] indices, int i) { return new FloatShuffle256(indices, i); } @Override @ForceInline - Float256Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Float256Shuffle(fn); } + FloatShuffle256 shuffleFromOp(IntUnaryOperator fn) { return new FloatShuffle256(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Float256Vector vectorFactory(float[] vec) { - return new Float256Vector(vec); + FloatVector256 vectorFactory(float[] vec) { + return new FloatVector256(vec); } @ForceInline final @Override - Byte256Vector asByteVectorRaw() { - return (Byte256Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector256 asByteVectorRaw() { + return (ByteVector256) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Float256Vector extends FloatVector { @ForceInline final @Override - Float256Vector uOp(FUnOp f) { - return (Float256Vector) super.uOpTemplate(f); // specialize + FloatVector256 uOp(FUnOp f) { + return (FloatVector256) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Float256Vector uOp(VectorMask m, FUnOp f) { - return (Float256Vector) - super.uOpTemplate((Float256Mask)m, f); // specialize + FloatVector256 uOp(VectorMask m, FUnOp f) { + return (FloatVector256) + super.uOpTemplate((FloatMask256)m, f); // specialize } // Binary operator @ForceInline final @Override - Float256Vector bOp(Vector v, FBinOp f) { - return (Float256Vector) super.bOpTemplate((Float256Vector)v, f); // specialize + FloatVector256 bOp(Vector v, FBinOp f) { + return (FloatVector256) super.bOpTemplate((FloatVector256)v, f); // specialize } @ForceInline final @Override - Float256Vector bOp(Vector v, + FloatVector256 bOp(Vector v, VectorMask m, FBinOp f) { - return (Float256Vector) - super.bOpTemplate((Float256Vector)v, (Float256Mask)m, + return (FloatVector256) + super.bOpTemplate((FloatVector256)v, (FloatMask256)m, f); // specialize } @@ -219,19 +219,19 @@ final class Float256Vector extends FloatVector { @ForceInline final @Override - Float256Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Float256Vector) - super.tOpTemplate((Float256Vector)v1, (Float256Vector)v2, + FloatVector256 tOp(Vector v1, Vector v2, FTriOp f) { + return (FloatVector256) + super.tOpTemplate((FloatVector256)v1, (FloatVector256)v2, f); // specialize } @ForceInline final @Override - Float256Vector tOp(Vector v1, Vector v2, + FloatVector256 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Float256Vector) - super.tOpTemplate((Float256Vector)v1, (Float256Vector)v2, - (Float256Mask)m, f); // specialize + return (FloatVector256) + super.tOpTemplate((FloatVector256)v1, (FloatVector256)v2, + (FloatMask256)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class Float256Vector extends FloatVector { @Override @ForceInline - public Float256Vector lanewise(Unary op) { - return (Float256Vector) super.lanewiseTemplate(op); // specialize + public FloatVector256 lanewise(Unary op) { + return (FloatVector256) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Float256Vector lanewise(Unary op, VectorMask m) { - return (Float256Vector) super.lanewiseTemplate(op, Float256Mask.class, (Float256Mask) m); // specialize + public FloatVector256 lanewise(Unary op, VectorMask m) { + return (FloatVector256) super.lanewiseTemplate(op, FloatMask256.class, (FloatMask256) m); // specialize } @Override @ForceInline - public Float256Vector lanewise(Binary op, Vector v) { - return (Float256Vector) super.lanewiseTemplate(op, v); // specialize + public FloatVector256 lanewise(Binary op, Vector v) { + return (FloatVector256) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Float256Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Float256Vector) super.lanewiseTemplate(op, Float256Mask.class, v, (Float256Mask) m); // specialize + public FloatVector256 lanewise(Binary op, Vector v, VectorMask m) { + return (FloatVector256) super.lanewiseTemplate(op, FloatMask256.class, v, (FloatMask256) m); // specialize } @@ -296,24 +296,24 @@ final class Float256Vector extends FloatVector { @Override @ForceInline public final - Float256Vector + FloatVector256 lanewise(Ternary op, Vector v1, Vector v2) { - return (Float256Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (FloatVector256) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Float256Vector + FloatVector256 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Float256Vector) super.lanewiseTemplate(op, Float256Mask.class, v1, v2, (Float256Mask) m); // specialize + return (FloatVector256) super.lanewiseTemplate(op, FloatMask256.class, v1, v2, (FloatMask256) m); // specialize } @Override @ForceInline public final - Float256Vector addIndex(int scale) { - return (Float256Vector) super.addIndexTemplate(scale); // specialize + FloatVector256 addIndex(int scale) { + return (FloatVector256) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class Float256Vector extends FloatVector { @ForceInline public final float reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Float256Mask.class, (Float256Mask) m); // specialized + return super.reduceLanesTemplate(op, FloatMask256.class, (FloatMask256) m); // specialized } @Override @@ -341,7 +341,7 @@ final class Float256Vector extends FloatVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Float256Mask.class, (Float256Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, FloatMask256.class, (FloatMask256) m); // specialized } @Override @@ -352,160 +352,160 @@ final class Float256Vector extends FloatVector { @Override @ForceInline - public final Float256Shuffle toShuffle() { - return (Float256Shuffle) toShuffle(vspecies(), false); + public final FloatShuffle256 toShuffle() { + return (FloatShuffle256) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Float256Mask test(Test op) { - return super.testTemplate(Float256Mask.class, op); // specialize + public final FloatMask256 test(Test op) { + return super.testTemplate(FloatMask256.class, op); // specialize } @Override @ForceInline - public final Float256Mask test(Test op, VectorMask m) { - return super.testTemplate(Float256Mask.class, op, (Float256Mask) m); // specialize + public final FloatMask256 test(Test op, VectorMask m) { + return super.testTemplate(FloatMask256.class, op, (FloatMask256) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Float256Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Float256Mask.class, op, v); // specialize + public final FloatMask256 compare(Comparison op, Vector v) { + return super.compareTemplate(FloatMask256.class, op, v); // specialize } @Override @ForceInline - public final Float256Mask compare(Comparison op, float s) { - return super.compareTemplate(Float256Mask.class, op, s); // specialize + public final FloatMask256 compare(Comparison op, float s) { + return super.compareTemplate(FloatMask256.class, op, s); // specialize } @Override @ForceInline - public final Float256Mask compare(Comparison op, long s) { - return super.compareTemplate(Float256Mask.class, op, s); // specialize + public final FloatMask256 compare(Comparison op, long s) { + return super.compareTemplate(FloatMask256.class, op, s); // specialize } @Override @ForceInline - public final Float256Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Float256Mask.class, op, v, (Float256Mask) m); + public final FloatMask256 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(FloatMask256.class, op, v, (FloatMask256) m); } @Override @ForceInline - public Float256Vector blend(Vector v, VectorMask m) { - return (Float256Vector) - super.blendTemplate(Float256Mask.class, - (Float256Vector) v, - (Float256Mask) m); // specialize + public FloatVector256 blend(Vector v, VectorMask m) { + return (FloatVector256) + super.blendTemplate(FloatMask256.class, + (FloatVector256) v, + (FloatMask256) m); // specialize } @Override @ForceInline - public Float256Vector slice(int origin, Vector v) { - return (Float256Vector) super.sliceTemplate(origin, v); // specialize + public FloatVector256 slice(int origin, Vector v) { + return (FloatVector256) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Float256Vector slice(int origin) { - return (Float256Vector) super.sliceTemplate(origin); // specialize + public FloatVector256 slice(int origin) { + return (FloatVector256) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Float256Vector unslice(int origin, Vector w, int part) { - return (Float256Vector) super.unsliceTemplate(origin, w, part); // specialize + public FloatVector256 unslice(int origin, Vector w, int part) { + return (FloatVector256) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Float256Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Float256Vector) - super.unsliceTemplate(Float256Mask.class, + public FloatVector256 unslice(int origin, Vector w, int part, VectorMask m) { + return (FloatVector256) + super.unsliceTemplate(FloatMask256.class, origin, w, part, - (Float256Mask) m); // specialize + (FloatMask256) m); // specialize } @Override @ForceInline - public Float256Vector unslice(int origin) { - return (Float256Vector) super.unsliceTemplate(origin); // specialize + public FloatVector256 unslice(int origin) { + return (FloatVector256) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Float256Vector rearrange(VectorShuffle s) { - return (Float256Vector) - super.rearrangeTemplate(Float256Shuffle.class, - (Float256Shuffle) s); // specialize + public FloatVector256 rearrange(VectorShuffle s) { + return (FloatVector256) + super.rearrangeTemplate(FloatShuffle256.class, + (FloatShuffle256) s); // specialize } @Override @ForceInline - public Float256Vector rearrange(VectorShuffle shuffle, + public FloatVector256 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Float256Vector) - super.rearrangeTemplate(Float256Shuffle.class, - Float256Mask.class, - (Float256Shuffle) shuffle, - (Float256Mask) m); // specialize + return (FloatVector256) + super.rearrangeTemplate(FloatShuffle256.class, + FloatMask256.class, + (FloatShuffle256) shuffle, + (FloatMask256) m); // specialize } @Override @ForceInline - public Float256Vector rearrange(VectorShuffle s, + public FloatVector256 rearrange(VectorShuffle s, Vector v) { - return (Float256Vector) - super.rearrangeTemplate(Float256Shuffle.class, - (Float256Shuffle) s, - (Float256Vector) v); // specialize + return (FloatVector256) + super.rearrangeTemplate(FloatShuffle256.class, + (FloatShuffle256) s, + (FloatVector256) v); // specialize } @Override @ForceInline - public Float256Vector compress(VectorMask m) { - return (Float256Vector) - super.compressTemplate(Float256Mask.class, - (Float256Mask) m); // specialize + public FloatVector256 compress(VectorMask m) { + return (FloatVector256) + super.compressTemplate(FloatMask256.class, + (FloatMask256) m); // specialize } @Override @ForceInline - public Float256Vector expand(VectorMask m) { - return (Float256Vector) - super.expandTemplate(Float256Mask.class, - (Float256Mask) m); // specialize + public FloatVector256 expand(VectorMask m) { + return (FloatVector256) + super.expandTemplate(FloatMask256.class, + (FloatMask256) m); // specialize } @Override @ForceInline - public Float256Vector selectFrom(Vector v) { - return (Float256Vector) - super.selectFromTemplate((Float256Vector) v); // specialize + public FloatVector256 selectFrom(Vector v) { + return (FloatVector256) + super.selectFromTemplate((FloatVector256) v); // specialize } @Override @ForceInline - public Float256Vector selectFrom(Vector v, + public FloatVector256 selectFrom(Vector v, VectorMask m) { - return (Float256Vector) - super.selectFromTemplate((Float256Vector) v, - Float256Mask.class, (Float256Mask) m); // specialize + return (FloatVector256) + super.selectFromTemplate((FloatVector256) v, + FloatMask256.class, (FloatMask256) m); // specialize } @Override @ForceInline - public Float256Vector selectFrom(Vector v1, + public FloatVector256 selectFrom(Vector v1, Vector v2) { - return (Float256Vector) - super.selectFromTemplate((Float256Vector) v1, (Float256Vector) v2); // specialize + return (FloatVector256) + super.selectFromTemplate((FloatVector256) v1, (FloatVector256) v2); // specialize } @ForceInline @@ -539,7 +539,7 @@ final class Float256Vector extends FloatVector { @ForceInline @Override - public Float256Vector withLane(int i, float e) { + public FloatVector256 withLane(int i, float e) { switch(i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -554,7 +554,7 @@ final class Float256Vector extends FloatVector { } @ForceInline - public Float256Vector withLaneHelper(int i, float e) { + public FloatVector256 withLaneHelper(int i, float e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Float.floatToRawIntBits(e), @@ -567,19 +567,19 @@ final class Float256Vector extends FloatVector { // Mask - static final class Float256Mask extends AbstractMask { + static final class FloatMask256 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = float.class; // used by the JVM - Float256Mask(boolean[] bits) { + FloatMask256(boolean[] bits) { this(bits, 0); } - Float256Mask(boolean[] bits, int offset) { + FloatMask256(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Float256Mask(boolean val) { + FloatMask256(boolean val) { super(prepare(val)); } @@ -612,31 +612,31 @@ final class Float256Vector extends FloatVector { } @Override - Float256Mask uOp(MUnOp f) { + FloatMask256 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Float256Mask(res); + return new FloatMask256(res); } @Override - Float256Mask bOp(VectorMask m, MBinOp f) { + FloatMask256 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Float256Mask)m).getBits(); + boolean[] mbits = ((FloatMask256)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Float256Mask(res); + return new FloatMask256(res); } @ForceInline @Override public final - Float256Vector toVector() { - return (Float256Vector) super.toVectorTemplate(); // specialize + FloatVector256 toVector() { + return (FloatVector256) super.toVectorTemplate(); // specialize } /** @@ -669,25 +669,25 @@ final class Float256Vector extends FloatVector { @Override @ForceInline /*package-private*/ - Float256Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Float256Mask) VectorSupport.indexPartiallyInUpperRange( - Float256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Float256Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + FloatMask256 indexPartiallyInUpperRange(long offset, long limit) { + return (FloatMask256) VectorSupport.indexPartiallyInUpperRange( + FloatMask256.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (FloatMask256) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Float256Mask not() { + public FloatMask256 not() { return xor(maskAll(true)); } @Override @ForceInline - public Float256Mask compress() { - return (Float256Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Float256Vector.class, Float256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public FloatMask256 compress() { + return (FloatMask256)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + FloatVector256.class, FloatMask256.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -696,30 +696,30 @@ final class Float256Vector extends FloatVector { @Override @ForceInline - public Float256Mask and(VectorMask mask) { + public FloatMask256 and(VectorMask mask) { Objects.requireNonNull(mask); - Float256Mask m = (Float256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Float256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask256 m = (FloatMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Float256Mask or(VectorMask mask) { + public FloatMask256 or(VectorMask mask) { Objects.requireNonNull(mask); - Float256Mask m = (Float256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Float256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask256 m = (FloatMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Float256Mask xor(VectorMask mask) { + public FloatMask256 xor(VectorMask mask) { Objects.requireNonNull(mask); - Float256Mask m = (Float256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Float256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask256 m = (FloatMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -729,21 +729,21 @@ final class Float256Vector extends FloatVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Float256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, FloatMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Float256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, FloatMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Float256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, FloatMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -753,7 +753,7 @@ final class Float256Vector extends FloatVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Float256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, FloatMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -763,7 +763,7 @@ final class Float256Vector extends FloatVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Float256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(FloatMask256.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -772,48 +772,48 @@ final class Float256Vector extends FloatVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Float256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, FloatMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Float256Mask)m).getBits())); + (m, __) -> anyTrueHelper(((FloatMask256)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Float256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, FloatMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Float256Mask)m).getBits())); + (m, __) -> allTrueHelper(((FloatMask256)m).getBits())); } @ForceInline /*package-private*/ - static Float256Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Float256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static FloatMask256 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(FloatMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Float256Mask TRUE_MASK = new Float256Mask(true); - private static final Float256Mask FALSE_MASK = new Float256Mask(false); + private static final FloatMask256 TRUE_MASK = new FloatMask256(true); + private static final FloatMask256 FALSE_MASK = new FloatMask256(false); } // Shuffle - static final class Float256Shuffle extends AbstractShuffle { + static final class FloatShuffle256 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Float256Shuffle(int[] indices) { + FloatShuffle256(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Float256Shuffle(int[] indices, int i) { + FloatShuffle256(int[] indices, int i) { this(prepare(indices, i)); } - Float256Shuffle(IntUnaryOperator fn) { + FloatShuffle256(IntUnaryOperator fn) { this(prepare(fn)); } @@ -833,23 +833,23 @@ final class Float256Vector extends FloatVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final Float256Shuffle IOTA = new Float256Shuffle(IDENTITY); + static final FloatShuffle256 IOTA = new FloatShuffle256(IDENTITY); @Override @ForceInline - public Float256Vector toVector() { - return (Float256Vector) toBitsVector().castShape(vspecies(), 0); + public FloatVector256 toVector() { + return (FloatVector256) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - Int256Vector toBitsVector() { - return (Int256Vector) super.toBitsVectorTemplate(); + IntVector256 toBitsVector() { + return (IntVector256) super.toBitsVectorTemplate(); } @Override - Int256Vector toBitsVector0() { - return ((Int256Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVector256 toBitsVector0() { + return ((IntVector256) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -872,30 +872,30 @@ final class Float256Vector extends FloatVector { @Override @ForceInline - public final Float256Mask laneIsValid() { - return (Float256Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final FloatMask256 laneIsValid() { + return (FloatMask256) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Float256Shuffle rearrange(VectorShuffle shuffle) { - Float256Shuffle concreteShuffle = (Float256Shuffle) shuffle; - return (Float256Shuffle) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_256)) + public final FloatShuffle256 rearrange(VectorShuffle shuffle) { + FloatShuffle256 concreteShuffle = (FloatShuffle256) shuffle; + return (FloatShuffle256) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_256)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Float256Shuffle wrapIndexes() { - Int256Vector v = toBitsVector(); + public final FloatShuffle256 wrapIndexes() { + IntVector256 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Int256Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVector256) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Int256Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVector256) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Float256Shuffle) v.toShuffle(vspecies(), false); + return (FloatShuffle256) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -946,14 +946,14 @@ final class Float256Vector extends FloatVector { @Override final FloatVector fromArray0(float[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Float256Mask.class, a, offset, (Float256Mask) m, offsetInRange); // specialize + return super.fromArray0Template(FloatMask256.class, a, offset, (FloatMask256) m, offsetInRange); // specialize } @ForceInline @Override final FloatVector fromArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Float256Mask.class, a, offset, indexMap, mapOffset, (Float256Mask) m); + return super.fromArray0Template(FloatMask256.class, a, offset, indexMap, mapOffset, (FloatMask256) m); } @@ -969,7 +969,7 @@ final class Float256Vector extends FloatVector { @Override final FloatVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Float256Mask.class, ms, offset, (Float256Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(FloatMask256.class, ms, offset, (FloatMask256) m, offsetInRange); // specialize } @ForceInline @@ -983,14 +983,14 @@ final class Float256Vector extends FloatVector { @Override final void intoArray0(float[] a, int offset, VectorMask m) { - super.intoArray0Template(Float256Mask.class, a, offset, (Float256Mask) m); + super.intoArray0Template(FloatMask256.class, a, offset, (FloatMask256) m); } @ForceInline @Override final void intoArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Float256Mask.class, a, offset, indexMap, mapOffset, (Float256Mask) m); + super.intoArray0Template(FloatMask256.class, a, offset, indexMap, mapOffset, (FloatMask256) m); } @@ -998,7 +998,7 @@ final class Float256Vector extends FloatVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Float256Mask.class, ms, offset, (Float256Mask) m); + super.intoMemorySegment0Template(FloatMask256.class, ms, offset, (FloatMask256) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector512.java similarity index 66% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector512.java index c2fced0fdae..a83a97e1de5 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector512.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Float512Vector extends FloatVector { +final class FloatVector512 extends FloatVector { static final FloatSpecies VSPECIES = (FloatSpecies) FloatVector.SPECIES_512; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Float512Vector.class; + static final Class VCLASS = FloatVector512.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Float512Vector extends FloatVector { static final Class ETYPE = float.class; // used by the JVM - Float512Vector(float[] v) { + FloatVector512(float[] v) { super(v); } - // For compatibility as Float512Vector::new, + // For compatibility as FloatVector512::new, // stored into species.vectorFactory. - Float512Vector(Object v) { + FloatVector512(Object v) { this((float[]) v); } - static final Float512Vector ZERO = new Float512Vector(new float[VLENGTH]); - static final Float512Vector IOTA = new Float512Vector(VSPECIES.iotaArray()); + static final FloatVector512 ZERO = new FloatVector512(new float[VLENGTH]); + static final FloatVector512 IOTA = new FloatVector512(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Float512Vector extends FloatVector { @Override @ForceInline - public final Float512Vector broadcast(float e) { - return (Float512Vector) super.broadcastTemplate(e); // specialize + public final FloatVector512 broadcast(float e) { + return (FloatVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Float512Vector broadcast(long e) { - return (Float512Vector) super.broadcastTemplate(e); // specialize + public final FloatVector512 broadcast(long e) { + return (FloatVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Float512Mask maskFromArray(boolean[] bits) { - return new Float512Mask(bits); + FloatMask512 maskFromArray(boolean[] bits) { + return new FloatMask512(bits); } @Override @ForceInline - Float512Shuffle iotaShuffle() { return Float512Shuffle.IOTA; } + FloatShuffle512 iotaShuffle() { return FloatShuffle512.IOTA; } @Override @ForceInline - Float512Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Float512Shuffle) iotaShuffleTemplate(start, step, wrap); + FloatShuffle512 iotaShuffle(int start, int step, boolean wrap) { + return (FloatShuffle512) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Float512Shuffle shuffleFromArray(int[] indices, int i) { return new Float512Shuffle(indices, i); } + FloatShuffle512 shuffleFromArray(int[] indices, int i) { return new FloatShuffle512(indices, i); } @Override @ForceInline - Float512Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Float512Shuffle(fn); } + FloatShuffle512 shuffleFromOp(IntUnaryOperator fn) { return new FloatShuffle512(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Float512Vector vectorFactory(float[] vec) { - return new Float512Vector(vec); + FloatVector512 vectorFactory(float[] vec) { + return new FloatVector512(vec); } @ForceInline final @Override - Byte512Vector asByteVectorRaw() { - return (Byte512Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector512 asByteVectorRaw() { + return (ByteVector512) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Float512Vector extends FloatVector { @ForceInline final @Override - Float512Vector uOp(FUnOp f) { - return (Float512Vector) super.uOpTemplate(f); // specialize + FloatVector512 uOp(FUnOp f) { + return (FloatVector512) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Float512Vector uOp(VectorMask m, FUnOp f) { - return (Float512Vector) - super.uOpTemplate((Float512Mask)m, f); // specialize + FloatVector512 uOp(VectorMask m, FUnOp f) { + return (FloatVector512) + super.uOpTemplate((FloatMask512)m, f); // specialize } // Binary operator @ForceInline final @Override - Float512Vector bOp(Vector v, FBinOp f) { - return (Float512Vector) super.bOpTemplate((Float512Vector)v, f); // specialize + FloatVector512 bOp(Vector v, FBinOp f) { + return (FloatVector512) super.bOpTemplate((FloatVector512)v, f); // specialize } @ForceInline final @Override - Float512Vector bOp(Vector v, + FloatVector512 bOp(Vector v, VectorMask m, FBinOp f) { - return (Float512Vector) - super.bOpTemplate((Float512Vector)v, (Float512Mask)m, + return (FloatVector512) + super.bOpTemplate((FloatVector512)v, (FloatMask512)m, f); // specialize } @@ -219,19 +219,19 @@ final class Float512Vector extends FloatVector { @ForceInline final @Override - Float512Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Float512Vector) - super.tOpTemplate((Float512Vector)v1, (Float512Vector)v2, + FloatVector512 tOp(Vector v1, Vector v2, FTriOp f) { + return (FloatVector512) + super.tOpTemplate((FloatVector512)v1, (FloatVector512)v2, f); // specialize } @ForceInline final @Override - Float512Vector tOp(Vector v1, Vector v2, + FloatVector512 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Float512Vector) - super.tOpTemplate((Float512Vector)v1, (Float512Vector)v2, - (Float512Mask)m, f); // specialize + return (FloatVector512) + super.tOpTemplate((FloatVector512)v1, (FloatVector512)v2, + (FloatMask512)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class Float512Vector extends FloatVector { @Override @ForceInline - public Float512Vector lanewise(Unary op) { - return (Float512Vector) super.lanewiseTemplate(op); // specialize + public FloatVector512 lanewise(Unary op) { + return (FloatVector512) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Float512Vector lanewise(Unary op, VectorMask m) { - return (Float512Vector) super.lanewiseTemplate(op, Float512Mask.class, (Float512Mask) m); // specialize + public FloatVector512 lanewise(Unary op, VectorMask m) { + return (FloatVector512) super.lanewiseTemplate(op, FloatMask512.class, (FloatMask512) m); // specialize } @Override @ForceInline - public Float512Vector lanewise(Binary op, Vector v) { - return (Float512Vector) super.lanewiseTemplate(op, v); // specialize + public FloatVector512 lanewise(Binary op, Vector v) { + return (FloatVector512) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Float512Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Float512Vector) super.lanewiseTemplate(op, Float512Mask.class, v, (Float512Mask) m); // specialize + public FloatVector512 lanewise(Binary op, Vector v, VectorMask m) { + return (FloatVector512) super.lanewiseTemplate(op, FloatMask512.class, v, (FloatMask512) m); // specialize } @@ -296,24 +296,24 @@ final class Float512Vector extends FloatVector { @Override @ForceInline public final - Float512Vector + FloatVector512 lanewise(Ternary op, Vector v1, Vector v2) { - return (Float512Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (FloatVector512) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Float512Vector + FloatVector512 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Float512Vector) super.lanewiseTemplate(op, Float512Mask.class, v1, v2, (Float512Mask) m); // specialize + return (FloatVector512) super.lanewiseTemplate(op, FloatMask512.class, v1, v2, (FloatMask512) m); // specialize } @Override @ForceInline public final - Float512Vector addIndex(int scale) { - return (Float512Vector) super.addIndexTemplate(scale); // specialize + FloatVector512 addIndex(int scale) { + return (FloatVector512) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class Float512Vector extends FloatVector { @ForceInline public final float reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Float512Mask.class, (Float512Mask) m); // specialized + return super.reduceLanesTemplate(op, FloatMask512.class, (FloatMask512) m); // specialized } @Override @@ -341,7 +341,7 @@ final class Float512Vector extends FloatVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Float512Mask.class, (Float512Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, FloatMask512.class, (FloatMask512) m); // specialized } @Override @@ -352,160 +352,160 @@ final class Float512Vector extends FloatVector { @Override @ForceInline - public final Float512Shuffle toShuffle() { - return (Float512Shuffle) toShuffle(vspecies(), false); + public final FloatShuffle512 toShuffle() { + return (FloatShuffle512) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Float512Mask test(Test op) { - return super.testTemplate(Float512Mask.class, op); // specialize + public final FloatMask512 test(Test op) { + return super.testTemplate(FloatMask512.class, op); // specialize } @Override @ForceInline - public final Float512Mask test(Test op, VectorMask m) { - return super.testTemplate(Float512Mask.class, op, (Float512Mask) m); // specialize + public final FloatMask512 test(Test op, VectorMask m) { + return super.testTemplate(FloatMask512.class, op, (FloatMask512) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Float512Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Float512Mask.class, op, v); // specialize + public final FloatMask512 compare(Comparison op, Vector v) { + return super.compareTemplate(FloatMask512.class, op, v); // specialize } @Override @ForceInline - public final Float512Mask compare(Comparison op, float s) { - return super.compareTemplate(Float512Mask.class, op, s); // specialize + public final FloatMask512 compare(Comparison op, float s) { + return super.compareTemplate(FloatMask512.class, op, s); // specialize } @Override @ForceInline - public final Float512Mask compare(Comparison op, long s) { - return super.compareTemplate(Float512Mask.class, op, s); // specialize + public final FloatMask512 compare(Comparison op, long s) { + return super.compareTemplate(FloatMask512.class, op, s); // specialize } @Override @ForceInline - public final Float512Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Float512Mask.class, op, v, (Float512Mask) m); + public final FloatMask512 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(FloatMask512.class, op, v, (FloatMask512) m); } @Override @ForceInline - public Float512Vector blend(Vector v, VectorMask m) { - return (Float512Vector) - super.blendTemplate(Float512Mask.class, - (Float512Vector) v, - (Float512Mask) m); // specialize + public FloatVector512 blend(Vector v, VectorMask m) { + return (FloatVector512) + super.blendTemplate(FloatMask512.class, + (FloatVector512) v, + (FloatMask512) m); // specialize } @Override @ForceInline - public Float512Vector slice(int origin, Vector v) { - return (Float512Vector) super.sliceTemplate(origin, v); // specialize + public FloatVector512 slice(int origin, Vector v) { + return (FloatVector512) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Float512Vector slice(int origin) { - return (Float512Vector) super.sliceTemplate(origin); // specialize + public FloatVector512 slice(int origin) { + return (FloatVector512) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Float512Vector unslice(int origin, Vector w, int part) { - return (Float512Vector) super.unsliceTemplate(origin, w, part); // specialize + public FloatVector512 unslice(int origin, Vector w, int part) { + return (FloatVector512) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Float512Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Float512Vector) - super.unsliceTemplate(Float512Mask.class, + public FloatVector512 unslice(int origin, Vector w, int part, VectorMask m) { + return (FloatVector512) + super.unsliceTemplate(FloatMask512.class, origin, w, part, - (Float512Mask) m); // specialize + (FloatMask512) m); // specialize } @Override @ForceInline - public Float512Vector unslice(int origin) { - return (Float512Vector) super.unsliceTemplate(origin); // specialize + public FloatVector512 unslice(int origin) { + return (FloatVector512) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Float512Vector rearrange(VectorShuffle s) { - return (Float512Vector) - super.rearrangeTemplate(Float512Shuffle.class, - (Float512Shuffle) s); // specialize + public FloatVector512 rearrange(VectorShuffle s) { + return (FloatVector512) + super.rearrangeTemplate(FloatShuffle512.class, + (FloatShuffle512) s); // specialize } @Override @ForceInline - public Float512Vector rearrange(VectorShuffle shuffle, + public FloatVector512 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Float512Vector) - super.rearrangeTemplate(Float512Shuffle.class, - Float512Mask.class, - (Float512Shuffle) shuffle, - (Float512Mask) m); // specialize + return (FloatVector512) + super.rearrangeTemplate(FloatShuffle512.class, + FloatMask512.class, + (FloatShuffle512) shuffle, + (FloatMask512) m); // specialize } @Override @ForceInline - public Float512Vector rearrange(VectorShuffle s, + public FloatVector512 rearrange(VectorShuffle s, Vector v) { - return (Float512Vector) - super.rearrangeTemplate(Float512Shuffle.class, - (Float512Shuffle) s, - (Float512Vector) v); // specialize + return (FloatVector512) + super.rearrangeTemplate(FloatShuffle512.class, + (FloatShuffle512) s, + (FloatVector512) v); // specialize } @Override @ForceInline - public Float512Vector compress(VectorMask m) { - return (Float512Vector) - super.compressTemplate(Float512Mask.class, - (Float512Mask) m); // specialize + public FloatVector512 compress(VectorMask m) { + return (FloatVector512) + super.compressTemplate(FloatMask512.class, + (FloatMask512) m); // specialize } @Override @ForceInline - public Float512Vector expand(VectorMask m) { - return (Float512Vector) - super.expandTemplate(Float512Mask.class, - (Float512Mask) m); // specialize + public FloatVector512 expand(VectorMask m) { + return (FloatVector512) + super.expandTemplate(FloatMask512.class, + (FloatMask512) m); // specialize } @Override @ForceInline - public Float512Vector selectFrom(Vector v) { - return (Float512Vector) - super.selectFromTemplate((Float512Vector) v); // specialize + public FloatVector512 selectFrom(Vector v) { + return (FloatVector512) + super.selectFromTemplate((FloatVector512) v); // specialize } @Override @ForceInline - public Float512Vector selectFrom(Vector v, + public FloatVector512 selectFrom(Vector v, VectorMask m) { - return (Float512Vector) - super.selectFromTemplate((Float512Vector) v, - Float512Mask.class, (Float512Mask) m); // specialize + return (FloatVector512) + super.selectFromTemplate((FloatVector512) v, + FloatMask512.class, (FloatMask512) m); // specialize } @Override @ForceInline - public Float512Vector selectFrom(Vector v1, + public FloatVector512 selectFrom(Vector v1, Vector v2) { - return (Float512Vector) - super.selectFromTemplate((Float512Vector) v1, (Float512Vector) v2); // specialize + return (FloatVector512) + super.selectFromTemplate((FloatVector512) v1, (FloatVector512) v2); // specialize } @ForceInline @@ -547,7 +547,7 @@ final class Float512Vector extends FloatVector { @ForceInline @Override - public Float512Vector withLane(int i, float e) { + public FloatVector512 withLane(int i, float e) { switch(i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -570,7 +570,7 @@ final class Float512Vector extends FloatVector { } @ForceInline - public Float512Vector withLaneHelper(int i, float e) { + public FloatVector512 withLaneHelper(int i, float e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Float.floatToRawIntBits(e), @@ -583,19 +583,19 @@ final class Float512Vector extends FloatVector { // Mask - static final class Float512Mask extends AbstractMask { + static final class FloatMask512 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = float.class; // used by the JVM - Float512Mask(boolean[] bits) { + FloatMask512(boolean[] bits) { this(bits, 0); } - Float512Mask(boolean[] bits, int offset) { + FloatMask512(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Float512Mask(boolean val) { + FloatMask512(boolean val) { super(prepare(val)); } @@ -628,31 +628,31 @@ final class Float512Vector extends FloatVector { } @Override - Float512Mask uOp(MUnOp f) { + FloatMask512 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Float512Mask(res); + return new FloatMask512(res); } @Override - Float512Mask bOp(VectorMask m, MBinOp f) { + FloatMask512 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Float512Mask)m).getBits(); + boolean[] mbits = ((FloatMask512)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Float512Mask(res); + return new FloatMask512(res); } @ForceInline @Override public final - Float512Vector toVector() { - return (Float512Vector) super.toVectorTemplate(); // specialize + FloatVector512 toVector() { + return (FloatVector512) super.toVectorTemplate(); // specialize } /** @@ -685,25 +685,25 @@ final class Float512Vector extends FloatVector { @Override @ForceInline /*package-private*/ - Float512Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Float512Mask) VectorSupport.indexPartiallyInUpperRange( - Float512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Float512Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + FloatMask512 indexPartiallyInUpperRange(long offset, long limit) { + return (FloatMask512) VectorSupport.indexPartiallyInUpperRange( + FloatMask512.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (FloatMask512) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Float512Mask not() { + public FloatMask512 not() { return xor(maskAll(true)); } @Override @ForceInline - public Float512Mask compress() { - return (Float512Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Float512Vector.class, Float512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public FloatMask512 compress() { + return (FloatMask512)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + FloatVector512.class, FloatMask512.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -712,30 +712,30 @@ final class Float512Vector extends FloatVector { @Override @ForceInline - public Float512Mask and(VectorMask mask) { + public FloatMask512 and(VectorMask mask) { Objects.requireNonNull(mask); - Float512Mask m = (Float512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Float512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask512 m = (FloatMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Float512Mask or(VectorMask mask) { + public FloatMask512 or(VectorMask mask) { Objects.requireNonNull(mask); - Float512Mask m = (Float512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Float512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask512 m = (FloatMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Float512Mask xor(VectorMask mask) { + public FloatMask512 xor(VectorMask mask) { Objects.requireNonNull(mask); - Float512Mask m = (Float512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Float512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask512 m = (FloatMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -745,21 +745,21 @@ final class Float512Vector extends FloatVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Float512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, FloatMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Float512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, FloatMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Float512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, FloatMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -769,7 +769,7 @@ final class Float512Vector extends FloatVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Float512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, FloatMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -779,7 +779,7 @@ final class Float512Vector extends FloatVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Float512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(FloatMask512.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -788,48 +788,48 @@ final class Float512Vector extends FloatVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Float512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, FloatMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Float512Mask)m).getBits())); + (m, __) -> anyTrueHelper(((FloatMask512)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Float512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, FloatMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Float512Mask)m).getBits())); + (m, __) -> allTrueHelper(((FloatMask512)m).getBits())); } @ForceInline /*package-private*/ - static Float512Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Float512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static FloatMask512 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(FloatMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Float512Mask TRUE_MASK = new Float512Mask(true); - private static final Float512Mask FALSE_MASK = new Float512Mask(false); + private static final FloatMask512 TRUE_MASK = new FloatMask512(true); + private static final FloatMask512 FALSE_MASK = new FloatMask512(false); } // Shuffle - static final class Float512Shuffle extends AbstractShuffle { + static final class FloatShuffle512 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Float512Shuffle(int[] indices) { + FloatShuffle512(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Float512Shuffle(int[] indices, int i) { + FloatShuffle512(int[] indices, int i) { this(prepare(indices, i)); } - Float512Shuffle(IntUnaryOperator fn) { + FloatShuffle512(IntUnaryOperator fn) { this(prepare(fn)); } @@ -849,23 +849,23 @@ final class Float512Vector extends FloatVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final Float512Shuffle IOTA = new Float512Shuffle(IDENTITY); + static final FloatShuffle512 IOTA = new FloatShuffle512(IDENTITY); @Override @ForceInline - public Float512Vector toVector() { - return (Float512Vector) toBitsVector().castShape(vspecies(), 0); + public FloatVector512 toVector() { + return (FloatVector512) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - Int512Vector toBitsVector() { - return (Int512Vector) super.toBitsVectorTemplate(); + IntVector512 toBitsVector() { + return (IntVector512) super.toBitsVectorTemplate(); } @Override - Int512Vector toBitsVector0() { - return ((Int512Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVector512 toBitsVector0() { + return ((IntVector512) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -888,30 +888,30 @@ final class Float512Vector extends FloatVector { @Override @ForceInline - public final Float512Mask laneIsValid() { - return (Float512Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final FloatMask512 laneIsValid() { + return (FloatMask512) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Float512Shuffle rearrange(VectorShuffle shuffle) { - Float512Shuffle concreteShuffle = (Float512Shuffle) shuffle; - return (Float512Shuffle) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_512)) + public final FloatShuffle512 rearrange(VectorShuffle shuffle) { + FloatShuffle512 concreteShuffle = (FloatShuffle512) shuffle; + return (FloatShuffle512) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_512)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Float512Shuffle wrapIndexes() { - Int512Vector v = toBitsVector(); + public final FloatShuffle512 wrapIndexes() { + IntVector512 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Int512Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVector512) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Int512Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVector512) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Float512Shuffle) v.toShuffle(vspecies(), false); + return (FloatShuffle512) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -962,14 +962,14 @@ final class Float512Vector extends FloatVector { @Override final FloatVector fromArray0(float[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Float512Mask.class, a, offset, (Float512Mask) m, offsetInRange); // specialize + return super.fromArray0Template(FloatMask512.class, a, offset, (FloatMask512) m, offsetInRange); // specialize } @ForceInline @Override final FloatVector fromArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Float512Mask.class, a, offset, indexMap, mapOffset, (Float512Mask) m); + return super.fromArray0Template(FloatMask512.class, a, offset, indexMap, mapOffset, (FloatMask512) m); } @@ -985,7 +985,7 @@ final class Float512Vector extends FloatVector { @Override final FloatVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Float512Mask.class, ms, offset, (Float512Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(FloatMask512.class, ms, offset, (FloatMask512) m, offsetInRange); // specialize } @ForceInline @@ -999,14 +999,14 @@ final class Float512Vector extends FloatVector { @Override final void intoArray0(float[] a, int offset, VectorMask m) { - super.intoArray0Template(Float512Mask.class, a, offset, (Float512Mask) m); + super.intoArray0Template(FloatMask512.class, a, offset, (FloatMask512) m); } @ForceInline @Override final void intoArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Float512Mask.class, a, offset, indexMap, mapOffset, (Float512Mask) m); + super.intoArray0Template(FloatMask512.class, a, offset, indexMap, mapOffset, (FloatMask512) m); } @@ -1014,7 +1014,7 @@ final class Float512Vector extends FloatVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Float512Mask.class, ms, offset, (Float512Mask) m); + super.intoMemorySegment0Template(FloatMask512.class, ms, offset, (FloatMask512) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector64.java similarity index 65% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector64.java index 67676c828d6..2d7c436f88d 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector64.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Float64Vector extends FloatVector { +final class FloatVector64 extends FloatVector { static final FloatSpecies VSPECIES = (FloatSpecies) FloatVector.SPECIES_64; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Float64Vector.class; + static final Class VCLASS = FloatVector64.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Float64Vector extends FloatVector { static final Class ETYPE = float.class; // used by the JVM - Float64Vector(float[] v) { + FloatVector64(float[] v) { super(v); } - // For compatibility as Float64Vector::new, + // For compatibility as FloatVector64::new, // stored into species.vectorFactory. - Float64Vector(Object v) { + FloatVector64(Object v) { this((float[]) v); } - static final Float64Vector ZERO = new Float64Vector(new float[VLENGTH]); - static final Float64Vector IOTA = new Float64Vector(VSPECIES.iotaArray()); + static final FloatVector64 ZERO = new FloatVector64(new float[VLENGTH]); + static final FloatVector64 IOTA = new FloatVector64(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Float64Vector extends FloatVector { @Override @ForceInline - public final Float64Vector broadcast(float e) { - return (Float64Vector) super.broadcastTemplate(e); // specialize + public final FloatVector64 broadcast(float e) { + return (FloatVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Float64Vector broadcast(long e) { - return (Float64Vector) super.broadcastTemplate(e); // specialize + public final FloatVector64 broadcast(long e) { + return (FloatVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Float64Mask maskFromArray(boolean[] bits) { - return new Float64Mask(bits); + FloatMask64 maskFromArray(boolean[] bits) { + return new FloatMask64(bits); } @Override @ForceInline - Float64Shuffle iotaShuffle() { return Float64Shuffle.IOTA; } + FloatShuffle64 iotaShuffle() { return FloatShuffle64.IOTA; } @Override @ForceInline - Float64Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Float64Shuffle) iotaShuffleTemplate(start, step, wrap); + FloatShuffle64 iotaShuffle(int start, int step, boolean wrap) { + return (FloatShuffle64) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Float64Shuffle shuffleFromArray(int[] indices, int i) { return new Float64Shuffle(indices, i); } + FloatShuffle64 shuffleFromArray(int[] indices, int i) { return new FloatShuffle64(indices, i); } @Override @ForceInline - Float64Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Float64Shuffle(fn); } + FloatShuffle64 shuffleFromOp(IntUnaryOperator fn) { return new FloatShuffle64(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Float64Vector vectorFactory(float[] vec) { - return new Float64Vector(vec); + FloatVector64 vectorFactory(float[] vec) { + return new FloatVector64(vec); } @ForceInline final @Override - Byte64Vector asByteVectorRaw() { - return (Byte64Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector64 asByteVectorRaw() { + return (ByteVector64) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Float64Vector extends FloatVector { @ForceInline final @Override - Float64Vector uOp(FUnOp f) { - return (Float64Vector) super.uOpTemplate(f); // specialize + FloatVector64 uOp(FUnOp f) { + return (FloatVector64) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Float64Vector uOp(VectorMask m, FUnOp f) { - return (Float64Vector) - super.uOpTemplate((Float64Mask)m, f); // specialize + FloatVector64 uOp(VectorMask m, FUnOp f) { + return (FloatVector64) + super.uOpTemplate((FloatMask64)m, f); // specialize } // Binary operator @ForceInline final @Override - Float64Vector bOp(Vector v, FBinOp f) { - return (Float64Vector) super.bOpTemplate((Float64Vector)v, f); // specialize + FloatVector64 bOp(Vector v, FBinOp f) { + return (FloatVector64) super.bOpTemplate((FloatVector64)v, f); // specialize } @ForceInline final @Override - Float64Vector bOp(Vector v, + FloatVector64 bOp(Vector v, VectorMask m, FBinOp f) { - return (Float64Vector) - super.bOpTemplate((Float64Vector)v, (Float64Mask)m, + return (FloatVector64) + super.bOpTemplate((FloatVector64)v, (FloatMask64)m, f); // specialize } @@ -219,19 +219,19 @@ final class Float64Vector extends FloatVector { @ForceInline final @Override - Float64Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Float64Vector) - super.tOpTemplate((Float64Vector)v1, (Float64Vector)v2, + FloatVector64 tOp(Vector v1, Vector v2, FTriOp f) { + return (FloatVector64) + super.tOpTemplate((FloatVector64)v1, (FloatVector64)v2, f); // specialize } @ForceInline final @Override - Float64Vector tOp(Vector v1, Vector v2, + FloatVector64 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Float64Vector) - super.tOpTemplate((Float64Vector)v1, (Float64Vector)v2, - (Float64Mask)m, f); // specialize + return (FloatVector64) + super.tOpTemplate((FloatVector64)v1, (FloatVector64)v2, + (FloatMask64)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class Float64Vector extends FloatVector { @Override @ForceInline - public Float64Vector lanewise(Unary op) { - return (Float64Vector) super.lanewiseTemplate(op); // specialize + public FloatVector64 lanewise(Unary op) { + return (FloatVector64) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Float64Vector lanewise(Unary op, VectorMask m) { - return (Float64Vector) super.lanewiseTemplate(op, Float64Mask.class, (Float64Mask) m); // specialize + public FloatVector64 lanewise(Unary op, VectorMask m) { + return (FloatVector64) super.lanewiseTemplate(op, FloatMask64.class, (FloatMask64) m); // specialize } @Override @ForceInline - public Float64Vector lanewise(Binary op, Vector v) { - return (Float64Vector) super.lanewiseTemplate(op, v); // specialize + public FloatVector64 lanewise(Binary op, Vector v) { + return (FloatVector64) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Float64Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Float64Vector) super.lanewiseTemplate(op, Float64Mask.class, v, (Float64Mask) m); // specialize + public FloatVector64 lanewise(Binary op, Vector v, VectorMask m) { + return (FloatVector64) super.lanewiseTemplate(op, FloatMask64.class, v, (FloatMask64) m); // specialize } @@ -296,24 +296,24 @@ final class Float64Vector extends FloatVector { @Override @ForceInline public final - Float64Vector + FloatVector64 lanewise(Ternary op, Vector v1, Vector v2) { - return (Float64Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (FloatVector64) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Float64Vector + FloatVector64 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Float64Vector) super.lanewiseTemplate(op, Float64Mask.class, v1, v2, (Float64Mask) m); // specialize + return (FloatVector64) super.lanewiseTemplate(op, FloatMask64.class, v1, v2, (FloatMask64) m); // specialize } @Override @ForceInline public final - Float64Vector addIndex(int scale) { - return (Float64Vector) super.addIndexTemplate(scale); // specialize + FloatVector64 addIndex(int scale) { + return (FloatVector64) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class Float64Vector extends FloatVector { @ForceInline public final float reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Float64Mask.class, (Float64Mask) m); // specialized + return super.reduceLanesTemplate(op, FloatMask64.class, (FloatMask64) m); // specialized } @Override @@ -341,7 +341,7 @@ final class Float64Vector extends FloatVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Float64Mask.class, (Float64Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, FloatMask64.class, (FloatMask64) m); // specialized } @Override @@ -352,160 +352,160 @@ final class Float64Vector extends FloatVector { @Override @ForceInline - public final Float64Shuffle toShuffle() { - return (Float64Shuffle) toShuffle(vspecies(), false); + public final FloatShuffle64 toShuffle() { + return (FloatShuffle64) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Float64Mask test(Test op) { - return super.testTemplate(Float64Mask.class, op); // specialize + public final FloatMask64 test(Test op) { + return super.testTemplate(FloatMask64.class, op); // specialize } @Override @ForceInline - public final Float64Mask test(Test op, VectorMask m) { - return super.testTemplate(Float64Mask.class, op, (Float64Mask) m); // specialize + public final FloatMask64 test(Test op, VectorMask m) { + return super.testTemplate(FloatMask64.class, op, (FloatMask64) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Float64Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Float64Mask.class, op, v); // specialize + public final FloatMask64 compare(Comparison op, Vector v) { + return super.compareTemplate(FloatMask64.class, op, v); // specialize } @Override @ForceInline - public final Float64Mask compare(Comparison op, float s) { - return super.compareTemplate(Float64Mask.class, op, s); // specialize + public final FloatMask64 compare(Comparison op, float s) { + return super.compareTemplate(FloatMask64.class, op, s); // specialize } @Override @ForceInline - public final Float64Mask compare(Comparison op, long s) { - return super.compareTemplate(Float64Mask.class, op, s); // specialize + public final FloatMask64 compare(Comparison op, long s) { + return super.compareTemplate(FloatMask64.class, op, s); // specialize } @Override @ForceInline - public final Float64Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Float64Mask.class, op, v, (Float64Mask) m); + public final FloatMask64 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(FloatMask64.class, op, v, (FloatMask64) m); } @Override @ForceInline - public Float64Vector blend(Vector v, VectorMask m) { - return (Float64Vector) - super.blendTemplate(Float64Mask.class, - (Float64Vector) v, - (Float64Mask) m); // specialize + public FloatVector64 blend(Vector v, VectorMask m) { + return (FloatVector64) + super.blendTemplate(FloatMask64.class, + (FloatVector64) v, + (FloatMask64) m); // specialize } @Override @ForceInline - public Float64Vector slice(int origin, Vector v) { - return (Float64Vector) super.sliceTemplate(origin, v); // specialize + public FloatVector64 slice(int origin, Vector v) { + return (FloatVector64) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Float64Vector slice(int origin) { - return (Float64Vector) super.sliceTemplate(origin); // specialize + public FloatVector64 slice(int origin) { + return (FloatVector64) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Float64Vector unslice(int origin, Vector w, int part) { - return (Float64Vector) super.unsliceTemplate(origin, w, part); // specialize + public FloatVector64 unslice(int origin, Vector w, int part) { + return (FloatVector64) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Float64Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Float64Vector) - super.unsliceTemplate(Float64Mask.class, + public FloatVector64 unslice(int origin, Vector w, int part, VectorMask m) { + return (FloatVector64) + super.unsliceTemplate(FloatMask64.class, origin, w, part, - (Float64Mask) m); // specialize + (FloatMask64) m); // specialize } @Override @ForceInline - public Float64Vector unslice(int origin) { - return (Float64Vector) super.unsliceTemplate(origin); // specialize + public FloatVector64 unslice(int origin) { + return (FloatVector64) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Float64Vector rearrange(VectorShuffle s) { - return (Float64Vector) - super.rearrangeTemplate(Float64Shuffle.class, - (Float64Shuffle) s); // specialize + public FloatVector64 rearrange(VectorShuffle s) { + return (FloatVector64) + super.rearrangeTemplate(FloatShuffle64.class, + (FloatShuffle64) s); // specialize } @Override @ForceInline - public Float64Vector rearrange(VectorShuffle shuffle, + public FloatVector64 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Float64Vector) - super.rearrangeTemplate(Float64Shuffle.class, - Float64Mask.class, - (Float64Shuffle) shuffle, - (Float64Mask) m); // specialize + return (FloatVector64) + super.rearrangeTemplate(FloatShuffle64.class, + FloatMask64.class, + (FloatShuffle64) shuffle, + (FloatMask64) m); // specialize } @Override @ForceInline - public Float64Vector rearrange(VectorShuffle s, + public FloatVector64 rearrange(VectorShuffle s, Vector v) { - return (Float64Vector) - super.rearrangeTemplate(Float64Shuffle.class, - (Float64Shuffle) s, - (Float64Vector) v); // specialize + return (FloatVector64) + super.rearrangeTemplate(FloatShuffle64.class, + (FloatShuffle64) s, + (FloatVector64) v); // specialize } @Override @ForceInline - public Float64Vector compress(VectorMask m) { - return (Float64Vector) - super.compressTemplate(Float64Mask.class, - (Float64Mask) m); // specialize + public FloatVector64 compress(VectorMask m) { + return (FloatVector64) + super.compressTemplate(FloatMask64.class, + (FloatMask64) m); // specialize } @Override @ForceInline - public Float64Vector expand(VectorMask m) { - return (Float64Vector) - super.expandTemplate(Float64Mask.class, - (Float64Mask) m); // specialize + public FloatVector64 expand(VectorMask m) { + return (FloatVector64) + super.expandTemplate(FloatMask64.class, + (FloatMask64) m); // specialize } @Override @ForceInline - public Float64Vector selectFrom(Vector v) { - return (Float64Vector) - super.selectFromTemplate((Float64Vector) v); // specialize + public FloatVector64 selectFrom(Vector v) { + return (FloatVector64) + super.selectFromTemplate((FloatVector64) v); // specialize } @Override @ForceInline - public Float64Vector selectFrom(Vector v, + public FloatVector64 selectFrom(Vector v, VectorMask m) { - return (Float64Vector) - super.selectFromTemplate((Float64Vector) v, - Float64Mask.class, (Float64Mask) m); // specialize + return (FloatVector64) + super.selectFromTemplate((FloatVector64) v, + FloatMask64.class, (FloatMask64) m); // specialize } @Override @ForceInline - public Float64Vector selectFrom(Vector v1, + public FloatVector64 selectFrom(Vector v1, Vector v2) { - return (Float64Vector) - super.selectFromTemplate((Float64Vector) v1, (Float64Vector) v2); // specialize + return (FloatVector64) + super.selectFromTemplate((FloatVector64) v1, (FloatVector64) v2); // specialize } @ForceInline @@ -533,7 +533,7 @@ final class Float64Vector extends FloatVector { @ForceInline @Override - public Float64Vector withLane(int i, float e) { + public FloatVector64 withLane(int i, float e) { switch(i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -542,7 +542,7 @@ final class Float64Vector extends FloatVector { } @ForceInline - public Float64Vector withLaneHelper(int i, float e) { + public FloatVector64 withLaneHelper(int i, float e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Float.floatToRawIntBits(e), @@ -555,19 +555,19 @@ final class Float64Vector extends FloatVector { // Mask - static final class Float64Mask extends AbstractMask { + static final class FloatMask64 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = float.class; // used by the JVM - Float64Mask(boolean[] bits) { + FloatMask64(boolean[] bits) { this(bits, 0); } - Float64Mask(boolean[] bits, int offset) { + FloatMask64(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Float64Mask(boolean val) { + FloatMask64(boolean val) { super(prepare(val)); } @@ -600,31 +600,31 @@ final class Float64Vector extends FloatVector { } @Override - Float64Mask uOp(MUnOp f) { + FloatMask64 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Float64Mask(res); + return new FloatMask64(res); } @Override - Float64Mask bOp(VectorMask m, MBinOp f) { + FloatMask64 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Float64Mask)m).getBits(); + boolean[] mbits = ((FloatMask64)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Float64Mask(res); + return new FloatMask64(res); } @ForceInline @Override public final - Float64Vector toVector() { - return (Float64Vector) super.toVectorTemplate(); // specialize + FloatVector64 toVector() { + return (FloatVector64) super.toVectorTemplate(); // specialize } /** @@ -657,25 +657,25 @@ final class Float64Vector extends FloatVector { @Override @ForceInline /*package-private*/ - Float64Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Float64Mask) VectorSupport.indexPartiallyInUpperRange( - Float64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Float64Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + FloatMask64 indexPartiallyInUpperRange(long offset, long limit) { + return (FloatMask64) VectorSupport.indexPartiallyInUpperRange( + FloatMask64.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (FloatMask64) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Float64Mask not() { + public FloatMask64 not() { return xor(maskAll(true)); } @Override @ForceInline - public Float64Mask compress() { - return (Float64Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Float64Vector.class, Float64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public FloatMask64 compress() { + return (FloatMask64)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + FloatVector64.class, FloatMask64.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -684,30 +684,30 @@ final class Float64Vector extends FloatVector { @Override @ForceInline - public Float64Mask and(VectorMask mask) { + public FloatMask64 and(VectorMask mask) { Objects.requireNonNull(mask); - Float64Mask m = (Float64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Float64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask64 m = (FloatMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Float64Mask or(VectorMask mask) { + public FloatMask64 or(VectorMask mask) { Objects.requireNonNull(mask); - Float64Mask m = (Float64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Float64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask64 m = (FloatMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Float64Mask xor(VectorMask mask) { + public FloatMask64 xor(VectorMask mask) { Objects.requireNonNull(mask); - Float64Mask m = (Float64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Float64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMask64 m = (FloatMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -717,21 +717,21 @@ final class Float64Vector extends FloatVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Float64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, FloatMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Float64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, FloatMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Float64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, FloatMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -741,7 +741,7 @@ final class Float64Vector extends FloatVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Float64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, FloatMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -751,7 +751,7 @@ final class Float64Vector extends FloatVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Float64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(FloatMask64.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -760,48 +760,48 @@ final class Float64Vector extends FloatVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Float64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, FloatMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Float64Mask)m).getBits())); + (m, __) -> anyTrueHelper(((FloatMask64)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Float64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, FloatMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Float64Mask)m).getBits())); + (m, __) -> allTrueHelper(((FloatMask64)m).getBits())); } @ForceInline /*package-private*/ - static Float64Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Float64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static FloatMask64 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(FloatMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Float64Mask TRUE_MASK = new Float64Mask(true); - private static final Float64Mask FALSE_MASK = new Float64Mask(false); + private static final FloatMask64 TRUE_MASK = new FloatMask64(true); + private static final FloatMask64 FALSE_MASK = new FloatMask64(false); } // Shuffle - static final class Float64Shuffle extends AbstractShuffle { + static final class FloatShuffle64 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Float64Shuffle(int[] indices) { + FloatShuffle64(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Float64Shuffle(int[] indices, int i) { + FloatShuffle64(int[] indices, int i) { this(prepare(indices, i)); } - Float64Shuffle(IntUnaryOperator fn) { + FloatShuffle64(IntUnaryOperator fn) { this(prepare(fn)); } @@ -821,23 +821,23 @@ final class Float64Vector extends FloatVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final Float64Shuffle IOTA = new Float64Shuffle(IDENTITY); + static final FloatShuffle64 IOTA = new FloatShuffle64(IDENTITY); @Override @ForceInline - public Float64Vector toVector() { - return (Float64Vector) toBitsVector().castShape(vspecies(), 0); + public FloatVector64 toVector() { + return (FloatVector64) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - Int64Vector toBitsVector() { - return (Int64Vector) super.toBitsVectorTemplate(); + IntVector64 toBitsVector() { + return (IntVector64) super.toBitsVectorTemplate(); } @Override - Int64Vector toBitsVector0() { - return ((Int64Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVector64 toBitsVector0() { + return ((IntVector64) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -860,30 +860,30 @@ final class Float64Vector extends FloatVector { @Override @ForceInline - public final Float64Mask laneIsValid() { - return (Float64Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final FloatMask64 laneIsValid() { + return (FloatMask64) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Float64Shuffle rearrange(VectorShuffle shuffle) { - Float64Shuffle concreteShuffle = (Float64Shuffle) shuffle; - return (Float64Shuffle) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_64)) + public final FloatShuffle64 rearrange(VectorShuffle shuffle) { + FloatShuffle64 concreteShuffle = (FloatShuffle64) shuffle; + return (FloatShuffle64) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_64)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Float64Shuffle wrapIndexes() { - Int64Vector v = toBitsVector(); + public final FloatShuffle64 wrapIndexes() { + IntVector64 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Int64Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVector64) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Int64Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVector64) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Float64Shuffle) v.toShuffle(vspecies(), false); + return (FloatShuffle64) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -934,14 +934,14 @@ final class Float64Vector extends FloatVector { @Override final FloatVector fromArray0(float[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Float64Mask.class, a, offset, (Float64Mask) m, offsetInRange); // specialize + return super.fromArray0Template(FloatMask64.class, a, offset, (FloatMask64) m, offsetInRange); // specialize } @ForceInline @Override final FloatVector fromArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Float64Mask.class, a, offset, indexMap, mapOffset, (Float64Mask) m); + return super.fromArray0Template(FloatMask64.class, a, offset, indexMap, mapOffset, (FloatMask64) m); } @@ -957,7 +957,7 @@ final class Float64Vector extends FloatVector { @Override final FloatVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Float64Mask.class, ms, offset, (Float64Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(FloatMask64.class, ms, offset, (FloatMask64) m, offsetInRange); // specialize } @ForceInline @@ -971,14 +971,14 @@ final class Float64Vector extends FloatVector { @Override final void intoArray0(float[] a, int offset, VectorMask m) { - super.intoArray0Template(Float64Mask.class, a, offset, (Float64Mask) m); + super.intoArray0Template(FloatMask64.class, a, offset, (FloatMask64) m); } @ForceInline @Override final void intoArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Float64Mask.class, a, offset, indexMap, mapOffset, (Float64Mask) m); + super.intoArray0Template(FloatMask64.class, a, offset, indexMap, mapOffset, (FloatMask64) m); } @@ -986,7 +986,7 @@ final class Float64Vector extends FloatVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Float64Mask.class, ms, offset, (Float64Mask) m); + super.intoMemorySegment0Template(FloatMask64.class, ms, offset, (FloatMask64) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVectorMax.java similarity index 65% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVectorMax.java index 35e4c83ebde..e8a7eefb8e3 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVectorMax.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class FloatMaxVector extends FloatVector { +final class FloatVectorMax extends FloatVector { static final FloatSpecies VSPECIES = (FloatSpecies) FloatVector.SPECIES_MAX; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = FloatMaxVector.class; + static final Class VCLASS = FloatVectorMax.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class FloatMaxVector extends FloatVector { static final Class ETYPE = float.class; // used by the JVM - FloatMaxVector(float[] v) { + FloatVectorMax(float[] v) { super(v); } - // For compatibility as FloatMaxVector::new, + // For compatibility as FloatVectorMax::new, // stored into species.vectorFactory. - FloatMaxVector(Object v) { + FloatVectorMax(Object v) { this((float[]) v); } - static final FloatMaxVector ZERO = new FloatMaxVector(new float[VLENGTH]); - static final FloatMaxVector IOTA = new FloatMaxVector(VSPECIES.iotaArray()); + static final FloatVectorMax ZERO = new FloatVectorMax(new float[VLENGTH]); + static final FloatVectorMax IOTA = new FloatVectorMax(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline - public final FloatMaxVector broadcast(float e) { - return (FloatMaxVector) super.broadcastTemplate(e); // specialize + public final FloatVectorMax broadcast(float e) { + return (FloatVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final FloatMaxVector broadcast(long e) { - return (FloatMaxVector) super.broadcastTemplate(e); // specialize + public final FloatVectorMax broadcast(long e) { + return (FloatVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - FloatMaxMask maskFromArray(boolean[] bits) { - return new FloatMaxMask(bits); + FloatMaskMax maskFromArray(boolean[] bits) { + return new FloatMaskMax(bits); } @Override @ForceInline - FloatMaxShuffle iotaShuffle() { return FloatMaxShuffle.IOTA; } + FloatShuffleMax iotaShuffle() { return FloatShuffleMax.IOTA; } @Override @ForceInline - FloatMaxShuffle iotaShuffle(int start, int step, boolean wrap) { - return (FloatMaxShuffle) iotaShuffleTemplate(start, step, wrap); + FloatShuffleMax iotaShuffle(int start, int step, boolean wrap) { + return (FloatShuffleMax) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - FloatMaxShuffle shuffleFromArray(int[] indices, int i) { return new FloatMaxShuffle(indices, i); } + FloatShuffleMax shuffleFromArray(int[] indices, int i) { return new FloatShuffleMax(indices, i); } @Override @ForceInline - FloatMaxShuffle shuffleFromOp(IntUnaryOperator fn) { return new FloatMaxShuffle(fn); } + FloatShuffleMax shuffleFromOp(IntUnaryOperator fn) { return new FloatShuffleMax(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - FloatMaxVector vectorFactory(float[] vec) { - return new FloatMaxVector(vec); + FloatVectorMax vectorFactory(float[] vec) { + return new FloatVectorMax(vec); } @ForceInline final @Override - ByteMaxVector asByteVectorRaw() { - return (ByteMaxVector) super.asByteVectorRawTemplate(); // specialize + ByteVectorMax asByteVectorRaw() { + return (ByteVectorMax) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class FloatMaxVector extends FloatVector { @ForceInline final @Override - FloatMaxVector uOp(FUnOp f) { - return (FloatMaxVector) super.uOpTemplate(f); // specialize + FloatVectorMax uOp(FUnOp f) { + return (FloatVectorMax) super.uOpTemplate(f); // specialize } @ForceInline final @Override - FloatMaxVector uOp(VectorMask m, FUnOp f) { - return (FloatMaxVector) - super.uOpTemplate((FloatMaxMask)m, f); // specialize + FloatVectorMax uOp(VectorMask m, FUnOp f) { + return (FloatVectorMax) + super.uOpTemplate((FloatMaskMax)m, f); // specialize } // Binary operator @ForceInline final @Override - FloatMaxVector bOp(Vector v, FBinOp f) { - return (FloatMaxVector) super.bOpTemplate((FloatMaxVector)v, f); // specialize + FloatVectorMax bOp(Vector v, FBinOp f) { + return (FloatVectorMax) super.bOpTemplate((FloatVectorMax)v, f); // specialize } @ForceInline final @Override - FloatMaxVector bOp(Vector v, + FloatVectorMax bOp(Vector v, VectorMask m, FBinOp f) { - return (FloatMaxVector) - super.bOpTemplate((FloatMaxVector)v, (FloatMaxMask)m, + return (FloatVectorMax) + super.bOpTemplate((FloatVectorMax)v, (FloatMaskMax)m, f); // specialize } @@ -219,19 +219,19 @@ final class FloatMaxVector extends FloatVector { @ForceInline final @Override - FloatMaxVector tOp(Vector v1, Vector v2, FTriOp f) { - return (FloatMaxVector) - super.tOpTemplate((FloatMaxVector)v1, (FloatMaxVector)v2, + FloatVectorMax tOp(Vector v1, Vector v2, FTriOp f) { + return (FloatVectorMax) + super.tOpTemplate((FloatVectorMax)v1, (FloatVectorMax)v2, f); // specialize } @ForceInline final @Override - FloatMaxVector tOp(Vector v1, Vector v2, + FloatVectorMax tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (FloatMaxVector) - super.tOpTemplate((FloatMaxVector)v1, (FloatMaxVector)v2, - (FloatMaxMask)m, f); // specialize + return (FloatVectorMax) + super.tOpTemplate((FloatVectorMax)v1, (FloatVectorMax)v2, + (FloatMaskMax)m, f); // specialize } @ForceInline @@ -269,26 +269,26 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline - public FloatMaxVector lanewise(Unary op) { - return (FloatMaxVector) super.lanewiseTemplate(op); // specialize + public FloatVectorMax lanewise(Unary op) { + return (FloatVectorMax) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public FloatMaxVector lanewise(Unary op, VectorMask m) { - return (FloatMaxVector) super.lanewiseTemplate(op, FloatMaxMask.class, (FloatMaxMask) m); // specialize + public FloatVectorMax lanewise(Unary op, VectorMask m) { + return (FloatVectorMax) super.lanewiseTemplate(op, FloatMaskMax.class, (FloatMaskMax) m); // specialize } @Override @ForceInline - public FloatMaxVector lanewise(Binary op, Vector v) { - return (FloatMaxVector) super.lanewiseTemplate(op, v); // specialize + public FloatVectorMax lanewise(Binary op, Vector v) { + return (FloatVectorMax) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public FloatMaxVector lanewise(Binary op, Vector v, VectorMask m) { - return (FloatMaxVector) super.lanewiseTemplate(op, FloatMaxMask.class, v, (FloatMaxMask) m); // specialize + public FloatVectorMax lanewise(Binary op, Vector v, VectorMask m) { + return (FloatVectorMax) super.lanewiseTemplate(op, FloatMaskMax.class, v, (FloatMaskMax) m); // specialize } @@ -296,24 +296,24 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline public final - FloatMaxVector + FloatVectorMax lanewise(Ternary op, Vector v1, Vector v2) { - return (FloatMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize + return (FloatVectorMax) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - FloatMaxVector + FloatVectorMax lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (FloatMaxVector) super.lanewiseTemplate(op, FloatMaxMask.class, v1, v2, (FloatMaxMask) m); // specialize + return (FloatVectorMax) super.lanewiseTemplate(op, FloatMaskMax.class, v1, v2, (FloatMaskMax) m); // specialize } @Override @ForceInline public final - FloatMaxVector addIndex(int scale) { - return (FloatMaxVector) super.addIndexTemplate(scale); // specialize + FloatVectorMax addIndex(int scale) { + return (FloatVectorMax) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -328,7 +328,7 @@ final class FloatMaxVector extends FloatVector { @ForceInline public final float reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, FloatMaxMask.class, (FloatMaxMask) m); // specialized + return super.reduceLanesTemplate(op, FloatMaskMax.class, (FloatMaskMax) m); // specialized } @Override @@ -341,7 +341,7 @@ final class FloatMaxVector extends FloatVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, FloatMaxMask.class, (FloatMaxMask) m); // specialized + return (long) super.reduceLanesTemplate(op, FloatMaskMax.class, (FloatMaskMax) m); // specialized } @Override @@ -352,160 +352,160 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline - public final FloatMaxShuffle toShuffle() { - return (FloatMaxShuffle) toShuffle(vspecies(), false); + public final FloatShuffleMax toShuffle() { + return (FloatShuffleMax) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final FloatMaxMask test(Test op) { - return super.testTemplate(FloatMaxMask.class, op); // specialize + public final FloatMaskMax test(Test op) { + return super.testTemplate(FloatMaskMax.class, op); // specialize } @Override @ForceInline - public final FloatMaxMask test(Test op, VectorMask m) { - return super.testTemplate(FloatMaxMask.class, op, (FloatMaxMask) m); // specialize + public final FloatMaskMax test(Test op, VectorMask m) { + return super.testTemplate(FloatMaskMax.class, op, (FloatMaskMax) m); // specialize } // Specialized comparisons @Override @ForceInline - public final FloatMaxMask compare(Comparison op, Vector v) { - return super.compareTemplate(FloatMaxMask.class, op, v); // specialize + public final FloatMaskMax compare(Comparison op, Vector v) { + return super.compareTemplate(FloatMaskMax.class, op, v); // specialize } @Override @ForceInline - public final FloatMaxMask compare(Comparison op, float s) { - return super.compareTemplate(FloatMaxMask.class, op, s); // specialize + public final FloatMaskMax compare(Comparison op, float s) { + return super.compareTemplate(FloatMaskMax.class, op, s); // specialize } @Override @ForceInline - public final FloatMaxMask compare(Comparison op, long s) { - return super.compareTemplate(FloatMaxMask.class, op, s); // specialize + public final FloatMaskMax compare(Comparison op, long s) { + return super.compareTemplate(FloatMaskMax.class, op, s); // specialize } @Override @ForceInline - public final FloatMaxMask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(FloatMaxMask.class, op, v, (FloatMaxMask) m); + public final FloatMaskMax compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(FloatMaskMax.class, op, v, (FloatMaskMax) m); } @Override @ForceInline - public FloatMaxVector blend(Vector v, VectorMask m) { - return (FloatMaxVector) - super.blendTemplate(FloatMaxMask.class, - (FloatMaxVector) v, - (FloatMaxMask) m); // specialize + public FloatVectorMax blend(Vector v, VectorMask m) { + return (FloatVectorMax) + super.blendTemplate(FloatMaskMax.class, + (FloatVectorMax) v, + (FloatMaskMax) m); // specialize } @Override @ForceInline - public FloatMaxVector slice(int origin, Vector v) { - return (FloatMaxVector) super.sliceTemplate(origin, v); // specialize + public FloatVectorMax slice(int origin, Vector v) { + return (FloatVectorMax) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public FloatMaxVector slice(int origin) { - return (FloatMaxVector) super.sliceTemplate(origin); // specialize + public FloatVectorMax slice(int origin) { + return (FloatVectorMax) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public FloatMaxVector unslice(int origin, Vector w, int part) { - return (FloatMaxVector) super.unsliceTemplate(origin, w, part); // specialize + public FloatVectorMax unslice(int origin, Vector w, int part) { + return (FloatVectorMax) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public FloatMaxVector unslice(int origin, Vector w, int part, VectorMask m) { - return (FloatMaxVector) - super.unsliceTemplate(FloatMaxMask.class, + public FloatVectorMax unslice(int origin, Vector w, int part, VectorMask m) { + return (FloatVectorMax) + super.unsliceTemplate(FloatMaskMax.class, origin, w, part, - (FloatMaxMask) m); // specialize + (FloatMaskMax) m); // specialize } @Override @ForceInline - public FloatMaxVector unslice(int origin) { - return (FloatMaxVector) super.unsliceTemplate(origin); // specialize + public FloatVectorMax unslice(int origin) { + return (FloatVectorMax) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public FloatMaxVector rearrange(VectorShuffle s) { - return (FloatMaxVector) - super.rearrangeTemplate(FloatMaxShuffle.class, - (FloatMaxShuffle) s); // specialize + public FloatVectorMax rearrange(VectorShuffle s) { + return (FloatVectorMax) + super.rearrangeTemplate(FloatShuffleMax.class, + (FloatShuffleMax) s); // specialize } @Override @ForceInline - public FloatMaxVector rearrange(VectorShuffle shuffle, + public FloatVectorMax rearrange(VectorShuffle shuffle, VectorMask m) { - return (FloatMaxVector) - super.rearrangeTemplate(FloatMaxShuffle.class, - FloatMaxMask.class, - (FloatMaxShuffle) shuffle, - (FloatMaxMask) m); // specialize + return (FloatVectorMax) + super.rearrangeTemplate(FloatShuffleMax.class, + FloatMaskMax.class, + (FloatShuffleMax) shuffle, + (FloatMaskMax) m); // specialize } @Override @ForceInline - public FloatMaxVector rearrange(VectorShuffle s, + public FloatVectorMax rearrange(VectorShuffle s, Vector v) { - return (FloatMaxVector) - super.rearrangeTemplate(FloatMaxShuffle.class, - (FloatMaxShuffle) s, - (FloatMaxVector) v); // specialize + return (FloatVectorMax) + super.rearrangeTemplate(FloatShuffleMax.class, + (FloatShuffleMax) s, + (FloatVectorMax) v); // specialize } @Override @ForceInline - public FloatMaxVector compress(VectorMask m) { - return (FloatMaxVector) - super.compressTemplate(FloatMaxMask.class, - (FloatMaxMask) m); // specialize + public FloatVectorMax compress(VectorMask m) { + return (FloatVectorMax) + super.compressTemplate(FloatMaskMax.class, + (FloatMaskMax) m); // specialize } @Override @ForceInline - public FloatMaxVector expand(VectorMask m) { - return (FloatMaxVector) - super.expandTemplate(FloatMaxMask.class, - (FloatMaxMask) m); // specialize + public FloatVectorMax expand(VectorMask m) { + return (FloatVectorMax) + super.expandTemplate(FloatMaskMax.class, + (FloatMaskMax) m); // specialize } @Override @ForceInline - public FloatMaxVector selectFrom(Vector v) { - return (FloatMaxVector) - super.selectFromTemplate((FloatMaxVector) v); // specialize + public FloatVectorMax selectFrom(Vector v) { + return (FloatVectorMax) + super.selectFromTemplate((FloatVectorMax) v); // specialize } @Override @ForceInline - public FloatMaxVector selectFrom(Vector v, + public FloatVectorMax selectFrom(Vector v, VectorMask m) { - return (FloatMaxVector) - super.selectFromTemplate((FloatMaxVector) v, - FloatMaxMask.class, (FloatMaxMask) m); // specialize + return (FloatVectorMax) + super.selectFromTemplate((FloatVectorMax) v, + FloatMaskMax.class, (FloatMaskMax) m); // specialize } @Override @ForceInline - public FloatMaxVector selectFrom(Vector v1, + public FloatVectorMax selectFrom(Vector v1, Vector v2) { - return (FloatMaxVector) - super.selectFromTemplate((FloatMaxVector) v1, (FloatMaxVector) v2); // specialize + return (FloatVectorMax) + super.selectFromTemplate((FloatVectorMax) v1, (FloatVectorMax) v2); // specialize } @ForceInline @@ -531,7 +531,7 @@ final class FloatMaxVector extends FloatVector { @ForceInline @Override - public FloatMaxVector withLane(int i, float e) { + public FloatVectorMax withLane(int i, float e) { if (i < 0 || i >= VLENGTH) { throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); } @@ -539,7 +539,7 @@ final class FloatMaxVector extends FloatVector { } @ForceInline - public FloatMaxVector withLaneHelper(int i, float e) { + public FloatVectorMax withLaneHelper(int i, float e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)Float.floatToRawIntBits(e), @@ -552,19 +552,19 @@ final class FloatMaxVector extends FloatVector { // Mask - static final class FloatMaxMask extends AbstractMask { + static final class FloatMaskMax extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = float.class; // used by the JVM - FloatMaxMask(boolean[] bits) { + FloatMaskMax(boolean[] bits) { this(bits, 0); } - FloatMaxMask(boolean[] bits, int offset) { + FloatMaskMax(boolean[] bits, int offset) { super(prepare(bits, offset)); } - FloatMaxMask(boolean val) { + FloatMaskMax(boolean val) { super(prepare(val)); } @@ -597,31 +597,31 @@ final class FloatMaxVector extends FloatVector { } @Override - FloatMaxMask uOp(MUnOp f) { + FloatMaskMax uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new FloatMaxMask(res); + return new FloatMaskMax(res); } @Override - FloatMaxMask bOp(VectorMask m, MBinOp f) { + FloatMaskMax bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((FloatMaxMask)m).getBits(); + boolean[] mbits = ((FloatMaskMax)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new FloatMaxMask(res); + return new FloatMaskMax(res); } @ForceInline @Override public final - FloatMaxVector toVector() { - return (FloatMaxVector) super.toVectorTemplate(); // specialize + FloatVectorMax toVector() { + return (FloatVectorMax) super.toVectorTemplate(); // specialize } /** @@ -654,25 +654,25 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline /*package-private*/ - FloatMaxMask indexPartiallyInUpperRange(long offset, long limit) { - return (FloatMaxMask) VectorSupport.indexPartiallyInUpperRange( - FloatMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (FloatMaxMask) TRUE_MASK.indexPartiallyInRange(o, l)); + FloatMaskMax indexPartiallyInUpperRange(long offset, long limit) { + return (FloatMaskMax) VectorSupport.indexPartiallyInUpperRange( + FloatMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (FloatMaskMax) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public FloatMaxMask not() { + public FloatMaskMax not() { return xor(maskAll(true)); } @Override @ForceInline - public FloatMaxMask compress() { - return (FloatMaxMask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - FloatMaxVector.class, FloatMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public FloatMaskMax compress() { + return (FloatMaskMax)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + FloatVectorMax.class, FloatMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -681,30 +681,30 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline - public FloatMaxMask and(VectorMask mask) { + public FloatMaskMax and(VectorMask mask) { Objects.requireNonNull(mask); - FloatMaxMask m = (FloatMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMaskMax m = (FloatMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public FloatMaxMask or(VectorMask mask) { + public FloatMaskMax or(VectorMask mask) { Objects.requireNonNull(mask); - FloatMaxMask m = (FloatMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMaskMax m = (FloatMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public FloatMaxMask xor(VectorMask mask) { + public FloatMaskMax xor(VectorMask mask) { Objects.requireNonNull(mask); - FloatMaxMask m = (FloatMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + FloatMaskMax m = (FloatMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -714,21 +714,21 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, FloatMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, FloatMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, FloatMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, FloatMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, FloatMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, FloatMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -738,7 +738,7 @@ final class FloatMaxVector extends FloatVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, FloatMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, FloatMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -748,7 +748,7 @@ final class FloatMaxVector extends FloatVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(FloatMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(FloatMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -757,48 +757,48 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, FloatMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, FloatMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((FloatMaxMask)m).getBits())); + (m, __) -> anyTrueHelper(((FloatMaskMax)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, FloatMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, FloatMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((FloatMaxMask)m).getBits())); + (m, __) -> allTrueHelper(((FloatMaskMax)m).getBits())); } @ForceInline /*package-private*/ - static FloatMaxMask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(FloatMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static FloatMaskMax maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(FloatMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final FloatMaxMask TRUE_MASK = new FloatMaxMask(true); - private static final FloatMaxMask FALSE_MASK = new FloatMaxMask(false); + private static final FloatMaskMax TRUE_MASK = new FloatMaskMax(true); + private static final FloatMaskMax FALSE_MASK = new FloatMaskMax(false); } // Shuffle - static final class FloatMaxShuffle extends AbstractShuffle { + static final class FloatShuffleMax extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - FloatMaxShuffle(int[] indices) { + FloatShuffleMax(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - FloatMaxShuffle(int[] indices, int i) { + FloatShuffleMax(int[] indices, int i) { this(prepare(indices, i)); } - FloatMaxShuffle(IntUnaryOperator fn) { + FloatShuffleMax(IntUnaryOperator fn) { this(prepare(fn)); } @@ -818,23 +818,23 @@ final class FloatMaxVector extends FloatVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final FloatMaxShuffle IOTA = new FloatMaxShuffle(IDENTITY); + static final FloatShuffleMax IOTA = new FloatShuffleMax(IDENTITY); @Override @ForceInline - public FloatMaxVector toVector() { - return (FloatMaxVector) toBitsVector().castShape(vspecies(), 0); + public FloatVectorMax toVector() { + return (FloatVectorMax) toBitsVector().castShape(vspecies(), 0); } @Override @ForceInline - IntMaxVector toBitsVector() { - return (IntMaxVector) super.toBitsVectorTemplate(); + IntVectorMax toBitsVector() { + return (IntVectorMax) super.toBitsVectorTemplate(); } @Override - IntMaxVector toBitsVector0() { - return ((IntMaxVector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVectorMax toBitsVector0() { + return ((IntVectorMax) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -857,30 +857,30 @@ final class FloatMaxVector extends FloatVector { @Override @ForceInline - public final FloatMaxMask laneIsValid() { - return (FloatMaxMask) toBitsVector().compare(VectorOperators.GE, 0) + public final FloatMaskMax laneIsValid() { + return (FloatMaskMax) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final FloatMaxShuffle rearrange(VectorShuffle shuffle) { - FloatMaxShuffle concreteShuffle = (FloatMaxShuffle) shuffle; - return (FloatMaxShuffle) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_MAX)) + public final FloatShuffleMax rearrange(VectorShuffle shuffle) { + FloatShuffleMax concreteShuffle = (FloatShuffleMax) shuffle; + return (FloatShuffleMax) toBitsVector().rearrange(concreteShuffle.cast(IntVector.SPECIES_MAX)) .toShuffle(vspecies(), false); } @ForceInline @Override - public final FloatMaxShuffle wrapIndexes() { - IntMaxVector v = toBitsVector(); + public final FloatShuffleMax wrapIndexes() { + IntVectorMax v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (IntMaxVector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVectorMax) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (IntMaxVector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVectorMax) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (FloatMaxShuffle) v.toShuffle(vspecies(), false); + return (FloatShuffleMax) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -931,14 +931,14 @@ final class FloatMaxVector extends FloatVector { @Override final FloatVector fromArray0(float[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(FloatMaxMask.class, a, offset, (FloatMaxMask) m, offsetInRange); // specialize + return super.fromArray0Template(FloatMaskMax.class, a, offset, (FloatMaskMax) m, offsetInRange); // specialize } @ForceInline @Override final FloatVector fromArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(FloatMaxMask.class, a, offset, indexMap, mapOffset, (FloatMaxMask) m); + return super.fromArray0Template(FloatMaskMax.class, a, offset, indexMap, mapOffset, (FloatMaskMax) m); } @@ -954,7 +954,7 @@ final class FloatMaxVector extends FloatVector { @Override final FloatVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(FloatMaxMask.class, ms, offset, (FloatMaxMask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(FloatMaskMax.class, ms, offset, (FloatMaskMax) m, offsetInRange); // specialize } @ForceInline @@ -968,14 +968,14 @@ final class FloatMaxVector extends FloatVector { @Override final void intoArray0(float[] a, int offset, VectorMask m) { - super.intoArray0Template(FloatMaxMask.class, a, offset, (FloatMaxMask) m); + super.intoArray0Template(FloatMaskMax.class, a, offset, (FloatMaskMax) m); } @ForceInline @Override final void intoArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(FloatMaxMask.class, a, offset, indexMap, mapOffset, (FloatMaxMask) m); + super.intoArray0Template(FloatMaskMax.class, a, offset, indexMap, mapOffset, (FloatMaskMax) m); } @@ -983,7 +983,7 @@ final class FloatMaxVector extends FloatVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(FloatMaxMask.class, ms, offset, (FloatMaxMask) m); + super.intoMemorySegment0Template(FloatMaskMax.class, ms, offset, (FloatMaskMax) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java index 412ac8e59b2..445c4dfb006 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java @@ -84,8 +84,8 @@ public abstract class IntVector extends AbstractVector { // The various shape-specific subclasses // also specialize them by wrapping // them in a call like this: - // return (Byte128Vector) - // super.bOp((Byte128Vector) o); + // return (ByteVector128) + // super.bOp((ByteVector128) o); // The purpose of that is to forcibly inline // the generic definition from this file // into a sharply-typed and size-specific @@ -4084,13 +4084,13 @@ public abstract class IntVector extends AbstractVector { @Override @ForceInline public final IntVector zero() { - if ((Class) vectorType() == IntMaxVector.class) - return IntMaxVector.ZERO; + if ((Class) vectorType() == IntVectorMax.class) + return IntVectorMax.ZERO; switch (vectorBitSize()) { - case 64: return Int64Vector.ZERO; - case 128: return Int128Vector.ZERO; - case 256: return Int256Vector.ZERO; - case 512: return Int512Vector.ZERO; + case 64: return IntVector64.ZERO; + case 128: return IntVector128.ZERO; + case 256: return IntVector256.ZERO; + case 512: return IntVector512.ZERO; } throw new AssertionError(); } @@ -4098,13 +4098,13 @@ public abstract class IntVector extends AbstractVector { @Override @ForceInline public final IntVector iota() { - if ((Class) vectorType() == IntMaxVector.class) - return IntMaxVector.IOTA; + if ((Class) vectorType() == IntVectorMax.class) + return IntVectorMax.IOTA; switch (vectorBitSize()) { - case 64: return Int64Vector.IOTA; - case 128: return Int128Vector.IOTA; - case 256: return Int256Vector.IOTA; - case 512: return Int512Vector.IOTA; + case 64: return IntVector64.IOTA; + case 128: return IntVector128.IOTA; + case 256: return IntVector256.IOTA; + case 512: return IntVector512.IOTA; } throw new AssertionError(); } @@ -4113,13 +4113,13 @@ public abstract class IntVector extends AbstractVector { @Override @ForceInline public final VectorMask maskAll(boolean bit) { - if ((Class) vectorType() == IntMaxVector.class) - return IntMaxVector.IntMaxMask.maskAll(bit); + if ((Class) vectorType() == IntVectorMax.class) + return IntVectorMax.IntMaskMax.maskAll(bit); switch (vectorBitSize()) { - case 64: return Int64Vector.Int64Mask.maskAll(bit); - case 128: return Int128Vector.Int128Mask.maskAll(bit); - case 256: return Int256Vector.Int256Mask.maskAll(bit); - case 512: return Int512Vector.Int512Mask.maskAll(bit); + case 64: return IntVector64.IntMask64.maskAll(bit); + case 128: return IntVector128.IntMask128.maskAll(bit); + case 256: return IntVector256.IntMask256.maskAll(bit); + case 512: return IntVector512.IntMask512.maskAll(bit); } throw new AssertionError(); } @@ -4147,42 +4147,42 @@ public abstract class IntVector extends AbstractVector { /** Species representing {@link IntVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ public static final VectorSpecies SPECIES_64 = new IntSpecies(VectorShape.S_64_BIT, - Int64Vector.class, - Int64Vector.Int64Mask.class, - Int64Vector.Int64Shuffle.class, - Int64Vector::new); + IntVector64.class, + IntVector64.IntMask64.class, + IntVector64.IntShuffle64.class, + IntVector64::new); /** Species representing {@link IntVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ public static final VectorSpecies SPECIES_128 = new IntSpecies(VectorShape.S_128_BIT, - Int128Vector.class, - Int128Vector.Int128Mask.class, - Int128Vector.Int128Shuffle.class, - Int128Vector::new); + IntVector128.class, + IntVector128.IntMask128.class, + IntVector128.IntShuffle128.class, + IntVector128::new); /** Species representing {@link IntVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ public static final VectorSpecies SPECIES_256 = new IntSpecies(VectorShape.S_256_BIT, - Int256Vector.class, - Int256Vector.Int256Mask.class, - Int256Vector.Int256Shuffle.class, - Int256Vector::new); + IntVector256.class, + IntVector256.IntMask256.class, + IntVector256.IntShuffle256.class, + IntVector256::new); /** Species representing {@link IntVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ public static final VectorSpecies SPECIES_512 = new IntSpecies(VectorShape.S_512_BIT, - Int512Vector.class, - Int512Vector.Int512Mask.class, - Int512Vector.Int512Shuffle.class, - Int512Vector::new); + IntVector512.class, + IntVector512.IntMask512.class, + IntVector512.IntShuffle512.class, + IntVector512::new); /** Species representing {@link IntVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ public static final VectorSpecies SPECIES_MAX = new IntSpecies(VectorShape.S_Max_BIT, - IntMaxVector.class, - IntMaxVector.IntMaxMask.class, - IntMaxVector.IntMaxShuffle.class, - IntMaxVector::new); + IntVectorMax.class, + IntVectorMax.IntMaskMax.class, + IntVectorMax.IntShuffleMax.class, + IntVectorMax::new); /** * Preferred species for {@link IntVector}s. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int128Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector128.java similarity index 66% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int128Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector128.java index 17e93dbd06a..09fb0c29127 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int128Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector128.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Int128Vector extends IntVector { +final class IntVector128 extends IntVector { static final IntSpecies VSPECIES = (IntSpecies) IntVector.SPECIES_128; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Int128Vector.class; + static final Class VCLASS = IntVector128.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Int128Vector extends IntVector { static final Class ETYPE = int.class; // used by the JVM - Int128Vector(int[] v) { + IntVector128(int[] v) { super(v); } - // For compatibility as Int128Vector::new, + // For compatibility as IntVector128::new, // stored into species.vectorFactory. - Int128Vector(Object v) { + IntVector128(Object v) { this((int[]) v); } - static final Int128Vector ZERO = new Int128Vector(new int[VLENGTH]); - static final Int128Vector IOTA = new Int128Vector(VSPECIES.iotaArray()); + static final IntVector128 ZERO = new IntVector128(new int[VLENGTH]); + static final IntVector128 IOTA = new IntVector128(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Int128Vector extends IntVector { @Override @ForceInline - public final Int128Vector broadcast(int e) { - return (Int128Vector) super.broadcastTemplate(e); // specialize + public final IntVector128 broadcast(int e) { + return (IntVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Int128Vector broadcast(long e) { - return (Int128Vector) super.broadcastTemplate(e); // specialize + public final IntVector128 broadcast(long e) { + return (IntVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Int128Mask maskFromArray(boolean[] bits) { - return new Int128Mask(bits); + IntMask128 maskFromArray(boolean[] bits) { + return new IntMask128(bits); } @Override @ForceInline - Int128Shuffle iotaShuffle() { return Int128Shuffle.IOTA; } + IntShuffle128 iotaShuffle() { return IntShuffle128.IOTA; } @Override @ForceInline - Int128Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Int128Shuffle) iotaShuffleTemplate(start, step, wrap); + IntShuffle128 iotaShuffle(int start, int step, boolean wrap) { + return (IntShuffle128) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Int128Shuffle shuffleFromArray(int[] indices, int i) { return new Int128Shuffle(indices, i); } + IntShuffle128 shuffleFromArray(int[] indices, int i) { return new IntShuffle128(indices, i); } @Override @ForceInline - Int128Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Int128Shuffle(fn); } + IntShuffle128 shuffleFromOp(IntUnaryOperator fn) { return new IntShuffle128(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Int128Vector vectorFactory(int[] vec) { - return new Int128Vector(vec); + IntVector128 vectorFactory(int[] vec) { + return new IntVector128(vec); } @ForceInline final @Override - Byte128Vector asByteVectorRaw() { - return (Byte128Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector128 asByteVectorRaw() { + return (ByteVector128) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Int128Vector extends IntVector { @ForceInline final @Override - Int128Vector uOp(FUnOp f) { - return (Int128Vector) super.uOpTemplate(f); // specialize + IntVector128 uOp(FUnOp f) { + return (IntVector128) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Int128Vector uOp(VectorMask m, FUnOp f) { - return (Int128Vector) - super.uOpTemplate((Int128Mask)m, f); // specialize + IntVector128 uOp(VectorMask m, FUnOp f) { + return (IntVector128) + super.uOpTemplate((IntMask128)m, f); // specialize } // Binary operator @ForceInline final @Override - Int128Vector bOp(Vector v, FBinOp f) { - return (Int128Vector) super.bOpTemplate((Int128Vector)v, f); // specialize + IntVector128 bOp(Vector v, FBinOp f) { + return (IntVector128) super.bOpTemplate((IntVector128)v, f); // specialize } @ForceInline final @Override - Int128Vector bOp(Vector v, + IntVector128 bOp(Vector v, VectorMask m, FBinOp f) { - return (Int128Vector) - super.bOpTemplate((Int128Vector)v, (Int128Mask)m, + return (IntVector128) + super.bOpTemplate((IntVector128)v, (IntMask128)m, f); // specialize } @@ -219,19 +219,19 @@ final class Int128Vector extends IntVector { @ForceInline final @Override - Int128Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Int128Vector) - super.tOpTemplate((Int128Vector)v1, (Int128Vector)v2, + IntVector128 tOp(Vector v1, Vector v2, FTriOp f) { + return (IntVector128) + super.tOpTemplate((IntVector128)v1, (IntVector128)v2, f); // specialize } @ForceInline final @Override - Int128Vector tOp(Vector v1, Vector v2, + IntVector128 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Int128Vector) - super.tOpTemplate((Int128Vector)v1, (Int128Vector)v2, - (Int128Mask)m, f); // specialize + return (IntVector128) + super.tOpTemplate((IntVector128)v1, (IntVector128)v2, + (IntMask128)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Int128Vector extends IntVector { @Override @ForceInline - public Int128Vector lanewise(Unary op) { - return (Int128Vector) super.lanewiseTemplate(op); // specialize + public IntVector128 lanewise(Unary op) { + return (IntVector128) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Int128Vector lanewise(Unary op, VectorMask m) { - return (Int128Vector) super.lanewiseTemplate(op, Int128Mask.class, (Int128Mask) m); // specialize + public IntVector128 lanewise(Unary op, VectorMask m) { + return (IntVector128) super.lanewiseTemplate(op, IntMask128.class, (IntMask128) m); // specialize } @Override @ForceInline - public Int128Vector lanewise(Binary op, Vector v) { - return (Int128Vector) super.lanewiseTemplate(op, v); // specialize + public IntVector128 lanewise(Binary op, Vector v) { + return (IntVector128) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Int128Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Int128Vector) super.lanewiseTemplate(op, Int128Mask.class, v, (Int128Mask) m); // specialize + public IntVector128 lanewise(Binary op, Vector v, VectorMask m) { + return (IntVector128) super.lanewiseTemplate(op, IntMask128.class, v, (IntMask128) m); // specialize } /*package-private*/ @Override - @ForceInline Int128Vector + @ForceInline IntVector128 lanewiseShift(VectorOperators.Binary op, int e) { - return (Int128Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (IntVector128) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Int128Vector + @ForceInline IntVector128 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Int128Vector) super.lanewiseShiftTemplate(op, Int128Mask.class, e, (Int128Mask) m); // specialize + return (IntVector128) super.lanewiseShiftTemplate(op, IntMask128.class, e, (IntMask128) m); // specialize } /*package-private*/ @Override @ForceInline public final - Int128Vector + IntVector128 lanewise(Ternary op, Vector v1, Vector v2) { - return (Int128Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (IntVector128) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Int128Vector + IntVector128 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Int128Vector) super.lanewiseTemplate(op, Int128Mask.class, v1, v2, (Int128Mask) m); // specialize + return (IntVector128) super.lanewiseTemplate(op, IntMask128.class, v1, v2, (IntMask128) m); // specialize } @Override @ForceInline public final - Int128Vector addIndex(int scale) { - return (Int128Vector) super.addIndexTemplate(scale); // specialize + IntVector128 addIndex(int scale) { + return (IntVector128) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Int128Vector extends IntVector { @ForceInline public final int reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Int128Mask.class, (Int128Mask) m); // specialized + return super.reduceLanesTemplate(op, IntMask128.class, (IntMask128) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Int128Vector extends IntVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Int128Mask.class, (Int128Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, IntMask128.class, (IntMask128) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Int128Vector extends IntVector { @Override @ForceInline - public final Int128Shuffle toShuffle() { - return (Int128Shuffle) toShuffle(vspecies(), false); + public final IntShuffle128 toShuffle() { + return (IntShuffle128) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Int128Mask test(Test op) { - return super.testTemplate(Int128Mask.class, op); // specialize + public final IntMask128 test(Test op) { + return super.testTemplate(IntMask128.class, op); // specialize } @Override @ForceInline - public final Int128Mask test(Test op, VectorMask m) { - return super.testTemplate(Int128Mask.class, op, (Int128Mask) m); // specialize + public final IntMask128 test(Test op, VectorMask m) { + return super.testTemplate(IntMask128.class, op, (IntMask128) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Int128Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Int128Mask.class, op, v); // specialize + public final IntMask128 compare(Comparison op, Vector v) { + return super.compareTemplate(IntMask128.class, op, v); // specialize } @Override @ForceInline - public final Int128Mask compare(Comparison op, int s) { - return super.compareTemplate(Int128Mask.class, op, s); // specialize + public final IntMask128 compare(Comparison op, int s) { + return super.compareTemplate(IntMask128.class, op, s); // specialize } @Override @ForceInline - public final Int128Mask compare(Comparison op, long s) { - return super.compareTemplate(Int128Mask.class, op, s); // specialize + public final IntMask128 compare(Comparison op, long s) { + return super.compareTemplate(IntMask128.class, op, s); // specialize } @Override @ForceInline - public final Int128Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Int128Mask.class, op, v, (Int128Mask) m); + public final IntMask128 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(IntMask128.class, op, v, (IntMask128) m); } @Override @ForceInline - public Int128Vector blend(Vector v, VectorMask m) { - return (Int128Vector) - super.blendTemplate(Int128Mask.class, - (Int128Vector) v, - (Int128Mask) m); // specialize + public IntVector128 blend(Vector v, VectorMask m) { + return (IntVector128) + super.blendTemplate(IntMask128.class, + (IntVector128) v, + (IntMask128) m); // specialize } @Override @ForceInline - public Int128Vector slice(int origin, Vector v) { - return (Int128Vector) super.sliceTemplate(origin, v); // specialize + public IntVector128 slice(int origin, Vector v) { + return (IntVector128) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Int128Vector slice(int origin) { - return (Int128Vector) super.sliceTemplate(origin); // specialize + public IntVector128 slice(int origin) { + return (IntVector128) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Int128Vector unslice(int origin, Vector w, int part) { - return (Int128Vector) super.unsliceTemplate(origin, w, part); // specialize + public IntVector128 unslice(int origin, Vector w, int part) { + return (IntVector128) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Int128Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Int128Vector) - super.unsliceTemplate(Int128Mask.class, + public IntVector128 unslice(int origin, Vector w, int part, VectorMask m) { + return (IntVector128) + super.unsliceTemplate(IntMask128.class, origin, w, part, - (Int128Mask) m); // specialize + (IntMask128) m); // specialize } @Override @ForceInline - public Int128Vector unslice(int origin) { - return (Int128Vector) super.unsliceTemplate(origin); // specialize + public IntVector128 unslice(int origin) { + return (IntVector128) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Int128Vector rearrange(VectorShuffle s) { - return (Int128Vector) - super.rearrangeTemplate(Int128Shuffle.class, - (Int128Shuffle) s); // specialize + public IntVector128 rearrange(VectorShuffle s) { + return (IntVector128) + super.rearrangeTemplate(IntShuffle128.class, + (IntShuffle128) s); // specialize } @Override @ForceInline - public Int128Vector rearrange(VectorShuffle shuffle, + public IntVector128 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Int128Vector) - super.rearrangeTemplate(Int128Shuffle.class, - Int128Mask.class, - (Int128Shuffle) shuffle, - (Int128Mask) m); // specialize + return (IntVector128) + super.rearrangeTemplate(IntShuffle128.class, + IntMask128.class, + (IntShuffle128) shuffle, + (IntMask128) m); // specialize } @Override @ForceInline - public Int128Vector rearrange(VectorShuffle s, + public IntVector128 rearrange(VectorShuffle s, Vector v) { - return (Int128Vector) - super.rearrangeTemplate(Int128Shuffle.class, - (Int128Shuffle) s, - (Int128Vector) v); // specialize + return (IntVector128) + super.rearrangeTemplate(IntShuffle128.class, + (IntShuffle128) s, + (IntVector128) v); // specialize } @Override @ForceInline - public Int128Vector compress(VectorMask m) { - return (Int128Vector) - super.compressTemplate(Int128Mask.class, - (Int128Mask) m); // specialize + public IntVector128 compress(VectorMask m) { + return (IntVector128) + super.compressTemplate(IntMask128.class, + (IntMask128) m); // specialize } @Override @ForceInline - public Int128Vector expand(VectorMask m) { - return (Int128Vector) - super.expandTemplate(Int128Mask.class, - (Int128Mask) m); // specialize + public IntVector128 expand(VectorMask m) { + return (IntVector128) + super.expandTemplate(IntMask128.class, + (IntMask128) m); // specialize } @Override @ForceInline - public Int128Vector selectFrom(Vector v) { - return (Int128Vector) - super.selectFromTemplate((Int128Vector) v); // specialize + public IntVector128 selectFrom(Vector v) { + return (IntVector128) + super.selectFromTemplate((IntVector128) v); // specialize } @Override @ForceInline - public Int128Vector selectFrom(Vector v, + public IntVector128 selectFrom(Vector v, VectorMask m) { - return (Int128Vector) - super.selectFromTemplate((Int128Vector) v, - Int128Mask.class, (Int128Mask) m); // specialize + return (IntVector128) + super.selectFromTemplate((IntVector128) v, + IntMask128.class, (IntMask128) m); // specialize } @Override @ForceInline - public Int128Vector selectFrom(Vector v1, + public IntVector128 selectFrom(Vector v1, Vector v2) { - return (Int128Vector) - super.selectFromTemplate((Int128Vector) v1, (Int128Vector) v2); // specialize + return (IntVector128) + super.selectFromTemplate((IntVector128) v1, (IntVector128) v2); // specialize } @ForceInline @@ -546,7 +546,7 @@ final class Int128Vector extends IntVector { @ForceInline @Override - public Int128Vector withLane(int i, int e) { + public IntVector128 withLane(int i, int e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -557,7 +557,7 @@ final class Int128Vector extends IntVector { } @ForceInline - public Int128Vector withLaneHelper(int i, int e) { + public IntVector128 withLaneHelper(int i, int e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -570,19 +570,19 @@ final class Int128Vector extends IntVector { // Mask - static final class Int128Mask extends AbstractMask { + static final class IntMask128 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Int128Mask(boolean[] bits) { + IntMask128(boolean[] bits) { this(bits, 0); } - Int128Mask(boolean[] bits, int offset) { + IntMask128(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Int128Mask(boolean val) { + IntMask128(boolean val) { super(prepare(val)); } @@ -615,31 +615,31 @@ final class Int128Vector extends IntVector { } @Override - Int128Mask uOp(MUnOp f) { + IntMask128 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Int128Mask(res); + return new IntMask128(res); } @Override - Int128Mask bOp(VectorMask m, MBinOp f) { + IntMask128 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Int128Mask)m).getBits(); + boolean[] mbits = ((IntMask128)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Int128Mask(res); + return new IntMask128(res); } @ForceInline @Override public final - Int128Vector toVector() { - return (Int128Vector) super.toVectorTemplate(); // specialize + IntVector128 toVector() { + return (IntVector128) super.toVectorTemplate(); // specialize } /** @@ -672,25 +672,25 @@ final class Int128Vector extends IntVector { @Override @ForceInline /*package-private*/ - Int128Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Int128Mask) VectorSupport.indexPartiallyInUpperRange( - Int128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Int128Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + IntMask128 indexPartiallyInUpperRange(long offset, long limit) { + return (IntMask128) VectorSupport.indexPartiallyInUpperRange( + IntMask128.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (IntMask128) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Int128Mask not() { + public IntMask128 not() { return xor(maskAll(true)); } @Override @ForceInline - public Int128Mask compress() { - return (Int128Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Int128Vector.class, Int128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public IntMask128 compress() { + return (IntMask128)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + IntVector128.class, IntMask128.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -699,30 +699,30 @@ final class Int128Vector extends IntVector { @Override @ForceInline - public Int128Mask and(VectorMask mask) { + public IntMask128 and(VectorMask mask) { Objects.requireNonNull(mask); - Int128Mask m = (Int128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Int128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask128 m = (IntMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, IntMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Int128Mask or(VectorMask mask) { + public IntMask128 or(VectorMask mask) { Objects.requireNonNull(mask); - Int128Mask m = (Int128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Int128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask128 m = (IntMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, IntMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Int128Mask xor(VectorMask mask) { + public IntMask128 xor(VectorMask mask) { Objects.requireNonNull(mask); - Int128Mask m = (Int128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Int128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask128 m = (IntMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, IntMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -732,21 +732,21 @@ final class Int128Vector extends IntVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Int128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, IntMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Int128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, IntMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Int128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, IntMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -756,7 +756,7 @@ final class Int128Vector extends IntVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Int128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, IntMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -766,7 +766,7 @@ final class Int128Vector extends IntVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Int128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(IntMask128.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -775,48 +775,48 @@ final class Int128Vector extends IntVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Int128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, IntMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Int128Mask)m).getBits())); + (m, __) -> anyTrueHelper(((IntMask128)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Int128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, IntMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Int128Mask)m).getBits())); + (m, __) -> allTrueHelper(((IntMask128)m).getBits())); } @ForceInline /*package-private*/ - static Int128Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Int128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static IntMask128 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(IntMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Int128Mask TRUE_MASK = new Int128Mask(true); - private static final Int128Mask FALSE_MASK = new Int128Mask(false); + private static final IntMask128 TRUE_MASK = new IntMask128(true); + private static final IntMask128 FALSE_MASK = new IntMask128(false); } // Shuffle - static final class Int128Shuffle extends AbstractShuffle { + static final class IntShuffle128 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Int128Shuffle(int[] indices) { + IntShuffle128(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Int128Shuffle(int[] indices, int i) { + IntShuffle128(int[] indices, int i) { this(prepare(indices, i)); } - Int128Shuffle(IntUnaryOperator fn) { + IntShuffle128(IntUnaryOperator fn) { this(prepare(fn)); } @@ -836,23 +836,23 @@ final class Int128Vector extends IntVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final Int128Shuffle IOTA = new Int128Shuffle(IDENTITY); + static final IntShuffle128 IOTA = new IntShuffle128(IDENTITY); @Override @ForceInline - public Int128Vector toVector() { + public IntVector128 toVector() { return toBitsVector(); } @Override @ForceInline - Int128Vector toBitsVector() { - return (Int128Vector) super.toBitsVectorTemplate(); + IntVector128 toBitsVector() { + return (IntVector128) super.toBitsVectorTemplate(); } @Override - Int128Vector toBitsVector0() { - return ((Int128Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVector128 toBitsVector0() { + return ((IntVector128) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -875,30 +875,30 @@ final class Int128Vector extends IntVector { @Override @ForceInline - public final Int128Mask laneIsValid() { - return (Int128Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final IntMask128 laneIsValid() { + return (IntMask128) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Int128Shuffle rearrange(VectorShuffle shuffle) { - Int128Shuffle concreteShuffle = (Int128Shuffle) shuffle; - return (Int128Shuffle) toBitsVector().rearrange(concreteShuffle) + public final IntShuffle128 rearrange(VectorShuffle shuffle) { + IntShuffle128 concreteShuffle = (IntShuffle128) shuffle; + return (IntShuffle128) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Int128Shuffle wrapIndexes() { - Int128Vector v = toBitsVector(); + public final IntShuffle128 wrapIndexes() { + IntVector128 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Int128Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVector128) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Int128Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVector128) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Int128Shuffle) v.toShuffle(vspecies(), false); + return (IntShuffle128) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -949,14 +949,14 @@ final class Int128Vector extends IntVector { @Override final IntVector fromArray0(int[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Int128Mask.class, a, offset, (Int128Mask) m, offsetInRange); // specialize + return super.fromArray0Template(IntMask128.class, a, offset, (IntMask128) m, offsetInRange); // specialize } @ForceInline @Override final IntVector fromArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Int128Mask.class, a, offset, indexMap, mapOffset, (Int128Mask) m); + return super.fromArray0Template(IntMask128.class, a, offset, indexMap, mapOffset, (IntMask128) m); } @@ -972,7 +972,7 @@ final class Int128Vector extends IntVector { @Override final IntVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Int128Mask.class, ms, offset, (Int128Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(IntMask128.class, ms, offset, (IntMask128) m, offsetInRange); // specialize } @ForceInline @@ -986,14 +986,14 @@ final class Int128Vector extends IntVector { @Override final void intoArray0(int[] a, int offset, VectorMask m) { - super.intoArray0Template(Int128Mask.class, a, offset, (Int128Mask) m); + super.intoArray0Template(IntMask128.class, a, offset, (IntMask128) m); } @ForceInline @Override final void intoArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Int128Mask.class, a, offset, indexMap, mapOffset, (Int128Mask) m); + super.intoArray0Template(IntMask128.class, a, offset, indexMap, mapOffset, (IntMask128) m); } @@ -1001,7 +1001,7 @@ final class Int128Vector extends IntVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Int128Mask.class, ms, offset, (Int128Mask) m); + super.intoMemorySegment0Template(IntMask128.class, ms, offset, (IntMask128) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int256Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector256.java similarity index 66% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int256Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector256.java index f9700fbfd71..33ba1062c1b 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int256Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector256.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Int256Vector extends IntVector { +final class IntVector256 extends IntVector { static final IntSpecies VSPECIES = (IntSpecies) IntVector.SPECIES_256; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Int256Vector.class; + static final Class VCLASS = IntVector256.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Int256Vector extends IntVector { static final Class ETYPE = int.class; // used by the JVM - Int256Vector(int[] v) { + IntVector256(int[] v) { super(v); } - // For compatibility as Int256Vector::new, + // For compatibility as IntVector256::new, // stored into species.vectorFactory. - Int256Vector(Object v) { + IntVector256(Object v) { this((int[]) v); } - static final Int256Vector ZERO = new Int256Vector(new int[VLENGTH]); - static final Int256Vector IOTA = new Int256Vector(VSPECIES.iotaArray()); + static final IntVector256 ZERO = new IntVector256(new int[VLENGTH]); + static final IntVector256 IOTA = new IntVector256(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Int256Vector extends IntVector { @Override @ForceInline - public final Int256Vector broadcast(int e) { - return (Int256Vector) super.broadcastTemplate(e); // specialize + public final IntVector256 broadcast(int e) { + return (IntVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Int256Vector broadcast(long e) { - return (Int256Vector) super.broadcastTemplate(e); // specialize + public final IntVector256 broadcast(long e) { + return (IntVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Int256Mask maskFromArray(boolean[] bits) { - return new Int256Mask(bits); + IntMask256 maskFromArray(boolean[] bits) { + return new IntMask256(bits); } @Override @ForceInline - Int256Shuffle iotaShuffle() { return Int256Shuffle.IOTA; } + IntShuffle256 iotaShuffle() { return IntShuffle256.IOTA; } @Override @ForceInline - Int256Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Int256Shuffle) iotaShuffleTemplate(start, step, wrap); + IntShuffle256 iotaShuffle(int start, int step, boolean wrap) { + return (IntShuffle256) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Int256Shuffle shuffleFromArray(int[] indices, int i) { return new Int256Shuffle(indices, i); } + IntShuffle256 shuffleFromArray(int[] indices, int i) { return new IntShuffle256(indices, i); } @Override @ForceInline - Int256Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Int256Shuffle(fn); } + IntShuffle256 shuffleFromOp(IntUnaryOperator fn) { return new IntShuffle256(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Int256Vector vectorFactory(int[] vec) { - return new Int256Vector(vec); + IntVector256 vectorFactory(int[] vec) { + return new IntVector256(vec); } @ForceInline final @Override - Byte256Vector asByteVectorRaw() { - return (Byte256Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector256 asByteVectorRaw() { + return (ByteVector256) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Int256Vector extends IntVector { @ForceInline final @Override - Int256Vector uOp(FUnOp f) { - return (Int256Vector) super.uOpTemplate(f); // specialize + IntVector256 uOp(FUnOp f) { + return (IntVector256) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Int256Vector uOp(VectorMask m, FUnOp f) { - return (Int256Vector) - super.uOpTemplate((Int256Mask)m, f); // specialize + IntVector256 uOp(VectorMask m, FUnOp f) { + return (IntVector256) + super.uOpTemplate((IntMask256)m, f); // specialize } // Binary operator @ForceInline final @Override - Int256Vector bOp(Vector v, FBinOp f) { - return (Int256Vector) super.bOpTemplate((Int256Vector)v, f); // specialize + IntVector256 bOp(Vector v, FBinOp f) { + return (IntVector256) super.bOpTemplate((IntVector256)v, f); // specialize } @ForceInline final @Override - Int256Vector bOp(Vector v, + IntVector256 bOp(Vector v, VectorMask m, FBinOp f) { - return (Int256Vector) - super.bOpTemplate((Int256Vector)v, (Int256Mask)m, + return (IntVector256) + super.bOpTemplate((IntVector256)v, (IntMask256)m, f); // specialize } @@ -219,19 +219,19 @@ final class Int256Vector extends IntVector { @ForceInline final @Override - Int256Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Int256Vector) - super.tOpTemplate((Int256Vector)v1, (Int256Vector)v2, + IntVector256 tOp(Vector v1, Vector v2, FTriOp f) { + return (IntVector256) + super.tOpTemplate((IntVector256)v1, (IntVector256)v2, f); // specialize } @ForceInline final @Override - Int256Vector tOp(Vector v1, Vector v2, + IntVector256 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Int256Vector) - super.tOpTemplate((Int256Vector)v1, (Int256Vector)v2, - (Int256Mask)m, f); // specialize + return (IntVector256) + super.tOpTemplate((IntVector256)v1, (IntVector256)v2, + (IntMask256)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Int256Vector extends IntVector { @Override @ForceInline - public Int256Vector lanewise(Unary op) { - return (Int256Vector) super.lanewiseTemplate(op); // specialize + public IntVector256 lanewise(Unary op) { + return (IntVector256) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Int256Vector lanewise(Unary op, VectorMask m) { - return (Int256Vector) super.lanewiseTemplate(op, Int256Mask.class, (Int256Mask) m); // specialize + public IntVector256 lanewise(Unary op, VectorMask m) { + return (IntVector256) super.lanewiseTemplate(op, IntMask256.class, (IntMask256) m); // specialize } @Override @ForceInline - public Int256Vector lanewise(Binary op, Vector v) { - return (Int256Vector) super.lanewiseTemplate(op, v); // specialize + public IntVector256 lanewise(Binary op, Vector v) { + return (IntVector256) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Int256Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Int256Vector) super.lanewiseTemplate(op, Int256Mask.class, v, (Int256Mask) m); // specialize + public IntVector256 lanewise(Binary op, Vector v, VectorMask m) { + return (IntVector256) super.lanewiseTemplate(op, IntMask256.class, v, (IntMask256) m); // specialize } /*package-private*/ @Override - @ForceInline Int256Vector + @ForceInline IntVector256 lanewiseShift(VectorOperators.Binary op, int e) { - return (Int256Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (IntVector256) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Int256Vector + @ForceInline IntVector256 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Int256Vector) super.lanewiseShiftTemplate(op, Int256Mask.class, e, (Int256Mask) m); // specialize + return (IntVector256) super.lanewiseShiftTemplate(op, IntMask256.class, e, (IntMask256) m); // specialize } /*package-private*/ @Override @ForceInline public final - Int256Vector + IntVector256 lanewise(Ternary op, Vector v1, Vector v2) { - return (Int256Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (IntVector256) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Int256Vector + IntVector256 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Int256Vector) super.lanewiseTemplate(op, Int256Mask.class, v1, v2, (Int256Mask) m); // specialize + return (IntVector256) super.lanewiseTemplate(op, IntMask256.class, v1, v2, (IntMask256) m); // specialize } @Override @ForceInline public final - Int256Vector addIndex(int scale) { - return (Int256Vector) super.addIndexTemplate(scale); // specialize + IntVector256 addIndex(int scale) { + return (IntVector256) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Int256Vector extends IntVector { @ForceInline public final int reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Int256Mask.class, (Int256Mask) m); // specialized + return super.reduceLanesTemplate(op, IntMask256.class, (IntMask256) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Int256Vector extends IntVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Int256Mask.class, (Int256Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, IntMask256.class, (IntMask256) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Int256Vector extends IntVector { @Override @ForceInline - public final Int256Shuffle toShuffle() { - return (Int256Shuffle) toShuffle(vspecies(), false); + public final IntShuffle256 toShuffle() { + return (IntShuffle256) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Int256Mask test(Test op) { - return super.testTemplate(Int256Mask.class, op); // specialize + public final IntMask256 test(Test op) { + return super.testTemplate(IntMask256.class, op); // specialize } @Override @ForceInline - public final Int256Mask test(Test op, VectorMask m) { - return super.testTemplate(Int256Mask.class, op, (Int256Mask) m); // specialize + public final IntMask256 test(Test op, VectorMask m) { + return super.testTemplate(IntMask256.class, op, (IntMask256) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Int256Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Int256Mask.class, op, v); // specialize + public final IntMask256 compare(Comparison op, Vector v) { + return super.compareTemplate(IntMask256.class, op, v); // specialize } @Override @ForceInline - public final Int256Mask compare(Comparison op, int s) { - return super.compareTemplate(Int256Mask.class, op, s); // specialize + public final IntMask256 compare(Comparison op, int s) { + return super.compareTemplate(IntMask256.class, op, s); // specialize } @Override @ForceInline - public final Int256Mask compare(Comparison op, long s) { - return super.compareTemplate(Int256Mask.class, op, s); // specialize + public final IntMask256 compare(Comparison op, long s) { + return super.compareTemplate(IntMask256.class, op, s); // specialize } @Override @ForceInline - public final Int256Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Int256Mask.class, op, v, (Int256Mask) m); + public final IntMask256 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(IntMask256.class, op, v, (IntMask256) m); } @Override @ForceInline - public Int256Vector blend(Vector v, VectorMask m) { - return (Int256Vector) - super.blendTemplate(Int256Mask.class, - (Int256Vector) v, - (Int256Mask) m); // specialize + public IntVector256 blend(Vector v, VectorMask m) { + return (IntVector256) + super.blendTemplate(IntMask256.class, + (IntVector256) v, + (IntMask256) m); // specialize } @Override @ForceInline - public Int256Vector slice(int origin, Vector v) { - return (Int256Vector) super.sliceTemplate(origin, v); // specialize + public IntVector256 slice(int origin, Vector v) { + return (IntVector256) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Int256Vector slice(int origin) { - return (Int256Vector) super.sliceTemplate(origin); // specialize + public IntVector256 slice(int origin) { + return (IntVector256) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Int256Vector unslice(int origin, Vector w, int part) { - return (Int256Vector) super.unsliceTemplate(origin, w, part); // specialize + public IntVector256 unslice(int origin, Vector w, int part) { + return (IntVector256) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Int256Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Int256Vector) - super.unsliceTemplate(Int256Mask.class, + public IntVector256 unslice(int origin, Vector w, int part, VectorMask m) { + return (IntVector256) + super.unsliceTemplate(IntMask256.class, origin, w, part, - (Int256Mask) m); // specialize + (IntMask256) m); // specialize } @Override @ForceInline - public Int256Vector unslice(int origin) { - return (Int256Vector) super.unsliceTemplate(origin); // specialize + public IntVector256 unslice(int origin) { + return (IntVector256) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Int256Vector rearrange(VectorShuffle s) { - return (Int256Vector) - super.rearrangeTemplate(Int256Shuffle.class, - (Int256Shuffle) s); // specialize + public IntVector256 rearrange(VectorShuffle s) { + return (IntVector256) + super.rearrangeTemplate(IntShuffle256.class, + (IntShuffle256) s); // specialize } @Override @ForceInline - public Int256Vector rearrange(VectorShuffle shuffle, + public IntVector256 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Int256Vector) - super.rearrangeTemplate(Int256Shuffle.class, - Int256Mask.class, - (Int256Shuffle) shuffle, - (Int256Mask) m); // specialize + return (IntVector256) + super.rearrangeTemplate(IntShuffle256.class, + IntMask256.class, + (IntShuffle256) shuffle, + (IntMask256) m); // specialize } @Override @ForceInline - public Int256Vector rearrange(VectorShuffle s, + public IntVector256 rearrange(VectorShuffle s, Vector v) { - return (Int256Vector) - super.rearrangeTemplate(Int256Shuffle.class, - (Int256Shuffle) s, - (Int256Vector) v); // specialize + return (IntVector256) + super.rearrangeTemplate(IntShuffle256.class, + (IntShuffle256) s, + (IntVector256) v); // specialize } @Override @ForceInline - public Int256Vector compress(VectorMask m) { - return (Int256Vector) - super.compressTemplate(Int256Mask.class, - (Int256Mask) m); // specialize + public IntVector256 compress(VectorMask m) { + return (IntVector256) + super.compressTemplate(IntMask256.class, + (IntMask256) m); // specialize } @Override @ForceInline - public Int256Vector expand(VectorMask m) { - return (Int256Vector) - super.expandTemplate(Int256Mask.class, - (Int256Mask) m); // specialize + public IntVector256 expand(VectorMask m) { + return (IntVector256) + super.expandTemplate(IntMask256.class, + (IntMask256) m); // specialize } @Override @ForceInline - public Int256Vector selectFrom(Vector v) { - return (Int256Vector) - super.selectFromTemplate((Int256Vector) v); // specialize + public IntVector256 selectFrom(Vector v) { + return (IntVector256) + super.selectFromTemplate((IntVector256) v); // specialize } @Override @ForceInline - public Int256Vector selectFrom(Vector v, + public IntVector256 selectFrom(Vector v, VectorMask m) { - return (Int256Vector) - super.selectFromTemplate((Int256Vector) v, - Int256Mask.class, (Int256Mask) m); // specialize + return (IntVector256) + super.selectFromTemplate((IntVector256) v, + IntMask256.class, (IntMask256) m); // specialize } @Override @ForceInline - public Int256Vector selectFrom(Vector v1, + public IntVector256 selectFrom(Vector v1, Vector v2) { - return (Int256Vector) - super.selectFromTemplate((Int256Vector) v1, (Int256Vector) v2); // specialize + return (IntVector256) + super.selectFromTemplate((IntVector256) v1, (IntVector256) v2); // specialize } @ForceInline @@ -550,7 +550,7 @@ final class Int256Vector extends IntVector { @ForceInline @Override - public Int256Vector withLane(int i, int e) { + public IntVector256 withLane(int i, int e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -565,7 +565,7 @@ final class Int256Vector extends IntVector { } @ForceInline - public Int256Vector withLaneHelper(int i, int e) { + public IntVector256 withLaneHelper(int i, int e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -578,19 +578,19 @@ final class Int256Vector extends IntVector { // Mask - static final class Int256Mask extends AbstractMask { + static final class IntMask256 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Int256Mask(boolean[] bits) { + IntMask256(boolean[] bits) { this(bits, 0); } - Int256Mask(boolean[] bits, int offset) { + IntMask256(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Int256Mask(boolean val) { + IntMask256(boolean val) { super(prepare(val)); } @@ -623,31 +623,31 @@ final class Int256Vector extends IntVector { } @Override - Int256Mask uOp(MUnOp f) { + IntMask256 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Int256Mask(res); + return new IntMask256(res); } @Override - Int256Mask bOp(VectorMask m, MBinOp f) { + IntMask256 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Int256Mask)m).getBits(); + boolean[] mbits = ((IntMask256)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Int256Mask(res); + return new IntMask256(res); } @ForceInline @Override public final - Int256Vector toVector() { - return (Int256Vector) super.toVectorTemplate(); // specialize + IntVector256 toVector() { + return (IntVector256) super.toVectorTemplate(); // specialize } /** @@ -680,25 +680,25 @@ final class Int256Vector extends IntVector { @Override @ForceInline /*package-private*/ - Int256Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Int256Mask) VectorSupport.indexPartiallyInUpperRange( - Int256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Int256Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + IntMask256 indexPartiallyInUpperRange(long offset, long limit) { + return (IntMask256) VectorSupport.indexPartiallyInUpperRange( + IntMask256.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (IntMask256) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Int256Mask not() { + public IntMask256 not() { return xor(maskAll(true)); } @Override @ForceInline - public Int256Mask compress() { - return (Int256Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Int256Vector.class, Int256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public IntMask256 compress() { + return (IntMask256)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + IntVector256.class, IntMask256.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -707,30 +707,30 @@ final class Int256Vector extends IntVector { @Override @ForceInline - public Int256Mask and(VectorMask mask) { + public IntMask256 and(VectorMask mask) { Objects.requireNonNull(mask); - Int256Mask m = (Int256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Int256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask256 m = (IntMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, IntMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Int256Mask or(VectorMask mask) { + public IntMask256 or(VectorMask mask) { Objects.requireNonNull(mask); - Int256Mask m = (Int256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Int256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask256 m = (IntMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, IntMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Int256Mask xor(VectorMask mask) { + public IntMask256 xor(VectorMask mask) { Objects.requireNonNull(mask); - Int256Mask m = (Int256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Int256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask256 m = (IntMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, IntMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -740,21 +740,21 @@ final class Int256Vector extends IntVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Int256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, IntMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Int256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, IntMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Int256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, IntMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -764,7 +764,7 @@ final class Int256Vector extends IntVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Int256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, IntMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -774,7 +774,7 @@ final class Int256Vector extends IntVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Int256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(IntMask256.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -783,48 +783,48 @@ final class Int256Vector extends IntVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Int256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, IntMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Int256Mask)m).getBits())); + (m, __) -> anyTrueHelper(((IntMask256)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Int256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, IntMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Int256Mask)m).getBits())); + (m, __) -> allTrueHelper(((IntMask256)m).getBits())); } @ForceInline /*package-private*/ - static Int256Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Int256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static IntMask256 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(IntMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Int256Mask TRUE_MASK = new Int256Mask(true); - private static final Int256Mask FALSE_MASK = new Int256Mask(false); + private static final IntMask256 TRUE_MASK = new IntMask256(true); + private static final IntMask256 FALSE_MASK = new IntMask256(false); } // Shuffle - static final class Int256Shuffle extends AbstractShuffle { + static final class IntShuffle256 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Int256Shuffle(int[] indices) { + IntShuffle256(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Int256Shuffle(int[] indices, int i) { + IntShuffle256(int[] indices, int i) { this(prepare(indices, i)); } - Int256Shuffle(IntUnaryOperator fn) { + IntShuffle256(IntUnaryOperator fn) { this(prepare(fn)); } @@ -844,23 +844,23 @@ final class Int256Vector extends IntVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final Int256Shuffle IOTA = new Int256Shuffle(IDENTITY); + static final IntShuffle256 IOTA = new IntShuffle256(IDENTITY); @Override @ForceInline - public Int256Vector toVector() { + public IntVector256 toVector() { return toBitsVector(); } @Override @ForceInline - Int256Vector toBitsVector() { - return (Int256Vector) super.toBitsVectorTemplate(); + IntVector256 toBitsVector() { + return (IntVector256) super.toBitsVectorTemplate(); } @Override - Int256Vector toBitsVector0() { - return ((Int256Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVector256 toBitsVector0() { + return ((IntVector256) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -883,30 +883,30 @@ final class Int256Vector extends IntVector { @Override @ForceInline - public final Int256Mask laneIsValid() { - return (Int256Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final IntMask256 laneIsValid() { + return (IntMask256) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Int256Shuffle rearrange(VectorShuffle shuffle) { - Int256Shuffle concreteShuffle = (Int256Shuffle) shuffle; - return (Int256Shuffle) toBitsVector().rearrange(concreteShuffle) + public final IntShuffle256 rearrange(VectorShuffle shuffle) { + IntShuffle256 concreteShuffle = (IntShuffle256) shuffle; + return (IntShuffle256) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Int256Shuffle wrapIndexes() { - Int256Vector v = toBitsVector(); + public final IntShuffle256 wrapIndexes() { + IntVector256 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Int256Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVector256) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Int256Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVector256) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Int256Shuffle) v.toShuffle(vspecies(), false); + return (IntShuffle256) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -957,14 +957,14 @@ final class Int256Vector extends IntVector { @Override final IntVector fromArray0(int[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Int256Mask.class, a, offset, (Int256Mask) m, offsetInRange); // specialize + return super.fromArray0Template(IntMask256.class, a, offset, (IntMask256) m, offsetInRange); // specialize } @ForceInline @Override final IntVector fromArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Int256Mask.class, a, offset, indexMap, mapOffset, (Int256Mask) m); + return super.fromArray0Template(IntMask256.class, a, offset, indexMap, mapOffset, (IntMask256) m); } @@ -980,7 +980,7 @@ final class Int256Vector extends IntVector { @Override final IntVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Int256Mask.class, ms, offset, (Int256Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(IntMask256.class, ms, offset, (IntMask256) m, offsetInRange); // specialize } @ForceInline @@ -994,14 +994,14 @@ final class Int256Vector extends IntVector { @Override final void intoArray0(int[] a, int offset, VectorMask m) { - super.intoArray0Template(Int256Mask.class, a, offset, (Int256Mask) m); + super.intoArray0Template(IntMask256.class, a, offset, (IntMask256) m); } @ForceInline @Override final void intoArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Int256Mask.class, a, offset, indexMap, mapOffset, (Int256Mask) m); + super.intoArray0Template(IntMask256.class, a, offset, indexMap, mapOffset, (IntMask256) m); } @@ -1009,7 +1009,7 @@ final class Int256Vector extends IntVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Int256Mask.class, ms, offset, (Int256Mask) m); + super.intoMemorySegment0Template(IntMask256.class, ms, offset, (IntMask256) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int512Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector512.java similarity index 67% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int512Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector512.java index 2e2ee7eac05..89128b1ff57 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int512Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector512.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Int512Vector extends IntVector { +final class IntVector512 extends IntVector { static final IntSpecies VSPECIES = (IntSpecies) IntVector.SPECIES_512; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Int512Vector.class; + static final Class VCLASS = IntVector512.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Int512Vector extends IntVector { static final Class ETYPE = int.class; // used by the JVM - Int512Vector(int[] v) { + IntVector512(int[] v) { super(v); } - // For compatibility as Int512Vector::new, + // For compatibility as IntVector512::new, // stored into species.vectorFactory. - Int512Vector(Object v) { + IntVector512(Object v) { this((int[]) v); } - static final Int512Vector ZERO = new Int512Vector(new int[VLENGTH]); - static final Int512Vector IOTA = new Int512Vector(VSPECIES.iotaArray()); + static final IntVector512 ZERO = new IntVector512(new int[VLENGTH]); + static final IntVector512 IOTA = new IntVector512(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Int512Vector extends IntVector { @Override @ForceInline - public final Int512Vector broadcast(int e) { - return (Int512Vector) super.broadcastTemplate(e); // specialize + public final IntVector512 broadcast(int e) { + return (IntVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Int512Vector broadcast(long e) { - return (Int512Vector) super.broadcastTemplate(e); // specialize + public final IntVector512 broadcast(long e) { + return (IntVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Int512Mask maskFromArray(boolean[] bits) { - return new Int512Mask(bits); + IntMask512 maskFromArray(boolean[] bits) { + return new IntMask512(bits); } @Override @ForceInline - Int512Shuffle iotaShuffle() { return Int512Shuffle.IOTA; } + IntShuffle512 iotaShuffle() { return IntShuffle512.IOTA; } @Override @ForceInline - Int512Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Int512Shuffle) iotaShuffleTemplate(start, step, wrap); + IntShuffle512 iotaShuffle(int start, int step, boolean wrap) { + return (IntShuffle512) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Int512Shuffle shuffleFromArray(int[] indices, int i) { return new Int512Shuffle(indices, i); } + IntShuffle512 shuffleFromArray(int[] indices, int i) { return new IntShuffle512(indices, i); } @Override @ForceInline - Int512Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Int512Shuffle(fn); } + IntShuffle512 shuffleFromOp(IntUnaryOperator fn) { return new IntShuffle512(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Int512Vector vectorFactory(int[] vec) { - return new Int512Vector(vec); + IntVector512 vectorFactory(int[] vec) { + return new IntVector512(vec); } @ForceInline final @Override - Byte512Vector asByteVectorRaw() { - return (Byte512Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector512 asByteVectorRaw() { + return (ByteVector512) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Int512Vector extends IntVector { @ForceInline final @Override - Int512Vector uOp(FUnOp f) { - return (Int512Vector) super.uOpTemplate(f); // specialize + IntVector512 uOp(FUnOp f) { + return (IntVector512) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Int512Vector uOp(VectorMask m, FUnOp f) { - return (Int512Vector) - super.uOpTemplate((Int512Mask)m, f); // specialize + IntVector512 uOp(VectorMask m, FUnOp f) { + return (IntVector512) + super.uOpTemplate((IntMask512)m, f); // specialize } // Binary operator @ForceInline final @Override - Int512Vector bOp(Vector v, FBinOp f) { - return (Int512Vector) super.bOpTemplate((Int512Vector)v, f); // specialize + IntVector512 bOp(Vector v, FBinOp f) { + return (IntVector512) super.bOpTemplate((IntVector512)v, f); // specialize } @ForceInline final @Override - Int512Vector bOp(Vector v, + IntVector512 bOp(Vector v, VectorMask m, FBinOp f) { - return (Int512Vector) - super.bOpTemplate((Int512Vector)v, (Int512Mask)m, + return (IntVector512) + super.bOpTemplate((IntVector512)v, (IntMask512)m, f); // specialize } @@ -219,19 +219,19 @@ final class Int512Vector extends IntVector { @ForceInline final @Override - Int512Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Int512Vector) - super.tOpTemplate((Int512Vector)v1, (Int512Vector)v2, + IntVector512 tOp(Vector v1, Vector v2, FTriOp f) { + return (IntVector512) + super.tOpTemplate((IntVector512)v1, (IntVector512)v2, f); // specialize } @ForceInline final @Override - Int512Vector tOp(Vector v1, Vector v2, + IntVector512 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Int512Vector) - super.tOpTemplate((Int512Vector)v1, (Int512Vector)v2, - (Int512Mask)m, f); // specialize + return (IntVector512) + super.tOpTemplate((IntVector512)v1, (IntVector512)v2, + (IntMask512)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Int512Vector extends IntVector { @Override @ForceInline - public Int512Vector lanewise(Unary op) { - return (Int512Vector) super.lanewiseTemplate(op); // specialize + public IntVector512 lanewise(Unary op) { + return (IntVector512) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Int512Vector lanewise(Unary op, VectorMask m) { - return (Int512Vector) super.lanewiseTemplate(op, Int512Mask.class, (Int512Mask) m); // specialize + public IntVector512 lanewise(Unary op, VectorMask m) { + return (IntVector512) super.lanewiseTemplate(op, IntMask512.class, (IntMask512) m); // specialize } @Override @ForceInline - public Int512Vector lanewise(Binary op, Vector v) { - return (Int512Vector) super.lanewiseTemplate(op, v); // specialize + public IntVector512 lanewise(Binary op, Vector v) { + return (IntVector512) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Int512Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Int512Vector) super.lanewiseTemplate(op, Int512Mask.class, v, (Int512Mask) m); // specialize + public IntVector512 lanewise(Binary op, Vector v, VectorMask m) { + return (IntVector512) super.lanewiseTemplate(op, IntMask512.class, v, (IntMask512) m); // specialize } /*package-private*/ @Override - @ForceInline Int512Vector + @ForceInline IntVector512 lanewiseShift(VectorOperators.Binary op, int e) { - return (Int512Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (IntVector512) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Int512Vector + @ForceInline IntVector512 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Int512Vector) super.lanewiseShiftTemplate(op, Int512Mask.class, e, (Int512Mask) m); // specialize + return (IntVector512) super.lanewiseShiftTemplate(op, IntMask512.class, e, (IntMask512) m); // specialize } /*package-private*/ @Override @ForceInline public final - Int512Vector + IntVector512 lanewise(Ternary op, Vector v1, Vector v2) { - return (Int512Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (IntVector512) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Int512Vector + IntVector512 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Int512Vector) super.lanewiseTemplate(op, Int512Mask.class, v1, v2, (Int512Mask) m); // specialize + return (IntVector512) super.lanewiseTemplate(op, IntMask512.class, v1, v2, (IntMask512) m); // specialize } @Override @ForceInline public final - Int512Vector addIndex(int scale) { - return (Int512Vector) super.addIndexTemplate(scale); // specialize + IntVector512 addIndex(int scale) { + return (IntVector512) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Int512Vector extends IntVector { @ForceInline public final int reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Int512Mask.class, (Int512Mask) m); // specialized + return super.reduceLanesTemplate(op, IntMask512.class, (IntMask512) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Int512Vector extends IntVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Int512Mask.class, (Int512Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, IntMask512.class, (IntMask512) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Int512Vector extends IntVector { @Override @ForceInline - public final Int512Shuffle toShuffle() { - return (Int512Shuffle) toShuffle(vspecies(), false); + public final IntShuffle512 toShuffle() { + return (IntShuffle512) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Int512Mask test(Test op) { - return super.testTemplate(Int512Mask.class, op); // specialize + public final IntMask512 test(Test op) { + return super.testTemplate(IntMask512.class, op); // specialize } @Override @ForceInline - public final Int512Mask test(Test op, VectorMask m) { - return super.testTemplate(Int512Mask.class, op, (Int512Mask) m); // specialize + public final IntMask512 test(Test op, VectorMask m) { + return super.testTemplate(IntMask512.class, op, (IntMask512) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Int512Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Int512Mask.class, op, v); // specialize + public final IntMask512 compare(Comparison op, Vector v) { + return super.compareTemplate(IntMask512.class, op, v); // specialize } @Override @ForceInline - public final Int512Mask compare(Comparison op, int s) { - return super.compareTemplate(Int512Mask.class, op, s); // specialize + public final IntMask512 compare(Comparison op, int s) { + return super.compareTemplate(IntMask512.class, op, s); // specialize } @Override @ForceInline - public final Int512Mask compare(Comparison op, long s) { - return super.compareTemplate(Int512Mask.class, op, s); // specialize + public final IntMask512 compare(Comparison op, long s) { + return super.compareTemplate(IntMask512.class, op, s); // specialize } @Override @ForceInline - public final Int512Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Int512Mask.class, op, v, (Int512Mask) m); + public final IntMask512 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(IntMask512.class, op, v, (IntMask512) m); } @Override @ForceInline - public Int512Vector blend(Vector v, VectorMask m) { - return (Int512Vector) - super.blendTemplate(Int512Mask.class, - (Int512Vector) v, - (Int512Mask) m); // specialize + public IntVector512 blend(Vector v, VectorMask m) { + return (IntVector512) + super.blendTemplate(IntMask512.class, + (IntVector512) v, + (IntMask512) m); // specialize } @Override @ForceInline - public Int512Vector slice(int origin, Vector v) { - return (Int512Vector) super.sliceTemplate(origin, v); // specialize + public IntVector512 slice(int origin, Vector v) { + return (IntVector512) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Int512Vector slice(int origin) { - return (Int512Vector) super.sliceTemplate(origin); // specialize + public IntVector512 slice(int origin) { + return (IntVector512) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Int512Vector unslice(int origin, Vector w, int part) { - return (Int512Vector) super.unsliceTemplate(origin, w, part); // specialize + public IntVector512 unslice(int origin, Vector w, int part) { + return (IntVector512) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Int512Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Int512Vector) - super.unsliceTemplate(Int512Mask.class, + public IntVector512 unslice(int origin, Vector w, int part, VectorMask m) { + return (IntVector512) + super.unsliceTemplate(IntMask512.class, origin, w, part, - (Int512Mask) m); // specialize + (IntMask512) m); // specialize } @Override @ForceInline - public Int512Vector unslice(int origin) { - return (Int512Vector) super.unsliceTemplate(origin); // specialize + public IntVector512 unslice(int origin) { + return (IntVector512) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Int512Vector rearrange(VectorShuffle s) { - return (Int512Vector) - super.rearrangeTemplate(Int512Shuffle.class, - (Int512Shuffle) s); // specialize + public IntVector512 rearrange(VectorShuffle s) { + return (IntVector512) + super.rearrangeTemplate(IntShuffle512.class, + (IntShuffle512) s); // specialize } @Override @ForceInline - public Int512Vector rearrange(VectorShuffle shuffle, + public IntVector512 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Int512Vector) - super.rearrangeTemplate(Int512Shuffle.class, - Int512Mask.class, - (Int512Shuffle) shuffle, - (Int512Mask) m); // specialize + return (IntVector512) + super.rearrangeTemplate(IntShuffle512.class, + IntMask512.class, + (IntShuffle512) shuffle, + (IntMask512) m); // specialize } @Override @ForceInline - public Int512Vector rearrange(VectorShuffle s, + public IntVector512 rearrange(VectorShuffle s, Vector v) { - return (Int512Vector) - super.rearrangeTemplate(Int512Shuffle.class, - (Int512Shuffle) s, - (Int512Vector) v); // specialize + return (IntVector512) + super.rearrangeTemplate(IntShuffle512.class, + (IntShuffle512) s, + (IntVector512) v); // specialize } @Override @ForceInline - public Int512Vector compress(VectorMask m) { - return (Int512Vector) - super.compressTemplate(Int512Mask.class, - (Int512Mask) m); // specialize + public IntVector512 compress(VectorMask m) { + return (IntVector512) + super.compressTemplate(IntMask512.class, + (IntMask512) m); // specialize } @Override @ForceInline - public Int512Vector expand(VectorMask m) { - return (Int512Vector) - super.expandTemplate(Int512Mask.class, - (Int512Mask) m); // specialize + public IntVector512 expand(VectorMask m) { + return (IntVector512) + super.expandTemplate(IntMask512.class, + (IntMask512) m); // specialize } @Override @ForceInline - public Int512Vector selectFrom(Vector v) { - return (Int512Vector) - super.selectFromTemplate((Int512Vector) v); // specialize + public IntVector512 selectFrom(Vector v) { + return (IntVector512) + super.selectFromTemplate((IntVector512) v); // specialize } @Override @ForceInline - public Int512Vector selectFrom(Vector v, + public IntVector512 selectFrom(Vector v, VectorMask m) { - return (Int512Vector) - super.selectFromTemplate((Int512Vector) v, - Int512Mask.class, (Int512Mask) m); // specialize + return (IntVector512) + super.selectFromTemplate((IntVector512) v, + IntMask512.class, (IntMask512) m); // specialize } @Override @ForceInline - public Int512Vector selectFrom(Vector v1, + public IntVector512 selectFrom(Vector v1, Vector v2) { - return (Int512Vector) - super.selectFromTemplate((Int512Vector) v1, (Int512Vector) v2); // specialize + return (IntVector512) + super.selectFromTemplate((IntVector512) v1, (IntVector512) v2); // specialize } @ForceInline @@ -558,7 +558,7 @@ final class Int512Vector extends IntVector { @ForceInline @Override - public Int512Vector withLane(int i, int e) { + public IntVector512 withLane(int i, int e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -581,7 +581,7 @@ final class Int512Vector extends IntVector { } @ForceInline - public Int512Vector withLaneHelper(int i, int e) { + public IntVector512 withLaneHelper(int i, int e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -594,19 +594,19 @@ final class Int512Vector extends IntVector { // Mask - static final class Int512Mask extends AbstractMask { + static final class IntMask512 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Int512Mask(boolean[] bits) { + IntMask512(boolean[] bits) { this(bits, 0); } - Int512Mask(boolean[] bits, int offset) { + IntMask512(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Int512Mask(boolean val) { + IntMask512(boolean val) { super(prepare(val)); } @@ -639,31 +639,31 @@ final class Int512Vector extends IntVector { } @Override - Int512Mask uOp(MUnOp f) { + IntMask512 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Int512Mask(res); + return new IntMask512(res); } @Override - Int512Mask bOp(VectorMask m, MBinOp f) { + IntMask512 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Int512Mask)m).getBits(); + boolean[] mbits = ((IntMask512)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Int512Mask(res); + return new IntMask512(res); } @ForceInline @Override public final - Int512Vector toVector() { - return (Int512Vector) super.toVectorTemplate(); // specialize + IntVector512 toVector() { + return (IntVector512) super.toVectorTemplate(); // specialize } /** @@ -696,25 +696,25 @@ final class Int512Vector extends IntVector { @Override @ForceInline /*package-private*/ - Int512Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Int512Mask) VectorSupport.indexPartiallyInUpperRange( - Int512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Int512Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + IntMask512 indexPartiallyInUpperRange(long offset, long limit) { + return (IntMask512) VectorSupport.indexPartiallyInUpperRange( + IntMask512.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (IntMask512) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Int512Mask not() { + public IntMask512 not() { return xor(maskAll(true)); } @Override @ForceInline - public Int512Mask compress() { - return (Int512Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Int512Vector.class, Int512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public IntMask512 compress() { + return (IntMask512)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + IntVector512.class, IntMask512.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -723,30 +723,30 @@ final class Int512Vector extends IntVector { @Override @ForceInline - public Int512Mask and(VectorMask mask) { + public IntMask512 and(VectorMask mask) { Objects.requireNonNull(mask); - Int512Mask m = (Int512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Int512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask512 m = (IntMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, IntMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Int512Mask or(VectorMask mask) { + public IntMask512 or(VectorMask mask) { Objects.requireNonNull(mask); - Int512Mask m = (Int512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Int512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask512 m = (IntMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, IntMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Int512Mask xor(VectorMask mask) { + public IntMask512 xor(VectorMask mask) { Objects.requireNonNull(mask); - Int512Mask m = (Int512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Int512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask512 m = (IntMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, IntMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -756,21 +756,21 @@ final class Int512Vector extends IntVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Int512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, IntMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Int512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, IntMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Int512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, IntMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -780,7 +780,7 @@ final class Int512Vector extends IntVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Int512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, IntMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -790,7 +790,7 @@ final class Int512Vector extends IntVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Int512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(IntMask512.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -799,48 +799,48 @@ final class Int512Vector extends IntVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Int512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, IntMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Int512Mask)m).getBits())); + (m, __) -> anyTrueHelper(((IntMask512)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Int512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, IntMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Int512Mask)m).getBits())); + (m, __) -> allTrueHelper(((IntMask512)m).getBits())); } @ForceInline /*package-private*/ - static Int512Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Int512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static IntMask512 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(IntMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Int512Mask TRUE_MASK = new Int512Mask(true); - private static final Int512Mask FALSE_MASK = new Int512Mask(false); + private static final IntMask512 TRUE_MASK = new IntMask512(true); + private static final IntMask512 FALSE_MASK = new IntMask512(false); } // Shuffle - static final class Int512Shuffle extends AbstractShuffle { + static final class IntShuffle512 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Int512Shuffle(int[] indices) { + IntShuffle512(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Int512Shuffle(int[] indices, int i) { + IntShuffle512(int[] indices, int i) { this(prepare(indices, i)); } - Int512Shuffle(IntUnaryOperator fn) { + IntShuffle512(IntUnaryOperator fn) { this(prepare(fn)); } @@ -860,23 +860,23 @@ final class Int512Vector extends IntVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final Int512Shuffle IOTA = new Int512Shuffle(IDENTITY); + static final IntShuffle512 IOTA = new IntShuffle512(IDENTITY); @Override @ForceInline - public Int512Vector toVector() { + public IntVector512 toVector() { return toBitsVector(); } @Override @ForceInline - Int512Vector toBitsVector() { - return (Int512Vector) super.toBitsVectorTemplate(); + IntVector512 toBitsVector() { + return (IntVector512) super.toBitsVectorTemplate(); } @Override - Int512Vector toBitsVector0() { - return ((Int512Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVector512 toBitsVector0() { + return ((IntVector512) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -899,30 +899,30 @@ final class Int512Vector extends IntVector { @Override @ForceInline - public final Int512Mask laneIsValid() { - return (Int512Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final IntMask512 laneIsValid() { + return (IntMask512) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Int512Shuffle rearrange(VectorShuffle shuffle) { - Int512Shuffle concreteShuffle = (Int512Shuffle) shuffle; - return (Int512Shuffle) toBitsVector().rearrange(concreteShuffle) + public final IntShuffle512 rearrange(VectorShuffle shuffle) { + IntShuffle512 concreteShuffle = (IntShuffle512) shuffle; + return (IntShuffle512) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Int512Shuffle wrapIndexes() { - Int512Vector v = toBitsVector(); + public final IntShuffle512 wrapIndexes() { + IntVector512 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Int512Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVector512) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Int512Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVector512) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Int512Shuffle) v.toShuffle(vspecies(), false); + return (IntShuffle512) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -973,14 +973,14 @@ final class Int512Vector extends IntVector { @Override final IntVector fromArray0(int[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Int512Mask.class, a, offset, (Int512Mask) m, offsetInRange); // specialize + return super.fromArray0Template(IntMask512.class, a, offset, (IntMask512) m, offsetInRange); // specialize } @ForceInline @Override final IntVector fromArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Int512Mask.class, a, offset, indexMap, mapOffset, (Int512Mask) m); + return super.fromArray0Template(IntMask512.class, a, offset, indexMap, mapOffset, (IntMask512) m); } @@ -996,7 +996,7 @@ final class Int512Vector extends IntVector { @Override final IntVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Int512Mask.class, ms, offset, (Int512Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(IntMask512.class, ms, offset, (IntMask512) m, offsetInRange); // specialize } @ForceInline @@ -1010,14 +1010,14 @@ final class Int512Vector extends IntVector { @Override final void intoArray0(int[] a, int offset, VectorMask m) { - super.intoArray0Template(Int512Mask.class, a, offset, (Int512Mask) m); + super.intoArray0Template(IntMask512.class, a, offset, (IntMask512) m); } @ForceInline @Override final void intoArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Int512Mask.class, a, offset, indexMap, mapOffset, (Int512Mask) m); + super.intoArray0Template(IntMask512.class, a, offset, indexMap, mapOffset, (IntMask512) m); } @@ -1025,7 +1025,7 @@ final class Int512Vector extends IntVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Int512Mask.class, ms, offset, (Int512Mask) m); + super.intoMemorySegment0Template(IntMask512.class, ms, offset, (IntMask512) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int64Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector64.java similarity index 66% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int64Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector64.java index 8338799c61a..68195064879 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Int64Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector64.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Int64Vector extends IntVector { +final class IntVector64 extends IntVector { static final IntSpecies VSPECIES = (IntSpecies) IntVector.SPECIES_64; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Int64Vector.class; + static final Class VCLASS = IntVector64.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Int64Vector extends IntVector { static final Class ETYPE = int.class; // used by the JVM - Int64Vector(int[] v) { + IntVector64(int[] v) { super(v); } - // For compatibility as Int64Vector::new, + // For compatibility as IntVector64::new, // stored into species.vectorFactory. - Int64Vector(Object v) { + IntVector64(Object v) { this((int[]) v); } - static final Int64Vector ZERO = new Int64Vector(new int[VLENGTH]); - static final Int64Vector IOTA = new Int64Vector(VSPECIES.iotaArray()); + static final IntVector64 ZERO = new IntVector64(new int[VLENGTH]); + static final IntVector64 IOTA = new IntVector64(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Int64Vector extends IntVector { @Override @ForceInline - public final Int64Vector broadcast(int e) { - return (Int64Vector) super.broadcastTemplate(e); // specialize + public final IntVector64 broadcast(int e) { + return (IntVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Int64Vector broadcast(long e) { - return (Int64Vector) super.broadcastTemplate(e); // specialize + public final IntVector64 broadcast(long e) { + return (IntVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Int64Mask maskFromArray(boolean[] bits) { - return new Int64Mask(bits); + IntMask64 maskFromArray(boolean[] bits) { + return new IntMask64(bits); } @Override @ForceInline - Int64Shuffle iotaShuffle() { return Int64Shuffle.IOTA; } + IntShuffle64 iotaShuffle() { return IntShuffle64.IOTA; } @Override @ForceInline - Int64Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Int64Shuffle) iotaShuffleTemplate(start, step, wrap); + IntShuffle64 iotaShuffle(int start, int step, boolean wrap) { + return (IntShuffle64) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Int64Shuffle shuffleFromArray(int[] indices, int i) { return new Int64Shuffle(indices, i); } + IntShuffle64 shuffleFromArray(int[] indices, int i) { return new IntShuffle64(indices, i); } @Override @ForceInline - Int64Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Int64Shuffle(fn); } + IntShuffle64 shuffleFromOp(IntUnaryOperator fn) { return new IntShuffle64(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Int64Vector vectorFactory(int[] vec) { - return new Int64Vector(vec); + IntVector64 vectorFactory(int[] vec) { + return new IntVector64(vec); } @ForceInline final @Override - Byte64Vector asByteVectorRaw() { - return (Byte64Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector64 asByteVectorRaw() { + return (ByteVector64) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Int64Vector extends IntVector { @ForceInline final @Override - Int64Vector uOp(FUnOp f) { - return (Int64Vector) super.uOpTemplate(f); // specialize + IntVector64 uOp(FUnOp f) { + return (IntVector64) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Int64Vector uOp(VectorMask m, FUnOp f) { - return (Int64Vector) - super.uOpTemplate((Int64Mask)m, f); // specialize + IntVector64 uOp(VectorMask m, FUnOp f) { + return (IntVector64) + super.uOpTemplate((IntMask64)m, f); // specialize } // Binary operator @ForceInline final @Override - Int64Vector bOp(Vector v, FBinOp f) { - return (Int64Vector) super.bOpTemplate((Int64Vector)v, f); // specialize + IntVector64 bOp(Vector v, FBinOp f) { + return (IntVector64) super.bOpTemplate((IntVector64)v, f); // specialize } @ForceInline final @Override - Int64Vector bOp(Vector v, + IntVector64 bOp(Vector v, VectorMask m, FBinOp f) { - return (Int64Vector) - super.bOpTemplate((Int64Vector)v, (Int64Mask)m, + return (IntVector64) + super.bOpTemplate((IntVector64)v, (IntMask64)m, f); // specialize } @@ -219,19 +219,19 @@ final class Int64Vector extends IntVector { @ForceInline final @Override - Int64Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Int64Vector) - super.tOpTemplate((Int64Vector)v1, (Int64Vector)v2, + IntVector64 tOp(Vector v1, Vector v2, FTriOp f) { + return (IntVector64) + super.tOpTemplate((IntVector64)v1, (IntVector64)v2, f); // specialize } @ForceInline final @Override - Int64Vector tOp(Vector v1, Vector v2, + IntVector64 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Int64Vector) - super.tOpTemplate((Int64Vector)v1, (Int64Vector)v2, - (Int64Mask)m, f); // specialize + return (IntVector64) + super.tOpTemplate((IntVector64)v1, (IntVector64)v2, + (IntMask64)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Int64Vector extends IntVector { @Override @ForceInline - public Int64Vector lanewise(Unary op) { - return (Int64Vector) super.lanewiseTemplate(op); // specialize + public IntVector64 lanewise(Unary op) { + return (IntVector64) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Int64Vector lanewise(Unary op, VectorMask m) { - return (Int64Vector) super.lanewiseTemplate(op, Int64Mask.class, (Int64Mask) m); // specialize + public IntVector64 lanewise(Unary op, VectorMask m) { + return (IntVector64) super.lanewiseTemplate(op, IntMask64.class, (IntMask64) m); // specialize } @Override @ForceInline - public Int64Vector lanewise(Binary op, Vector v) { - return (Int64Vector) super.lanewiseTemplate(op, v); // specialize + public IntVector64 lanewise(Binary op, Vector v) { + return (IntVector64) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Int64Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Int64Vector) super.lanewiseTemplate(op, Int64Mask.class, v, (Int64Mask) m); // specialize + public IntVector64 lanewise(Binary op, Vector v, VectorMask m) { + return (IntVector64) super.lanewiseTemplate(op, IntMask64.class, v, (IntMask64) m); // specialize } /*package-private*/ @Override - @ForceInline Int64Vector + @ForceInline IntVector64 lanewiseShift(VectorOperators.Binary op, int e) { - return (Int64Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (IntVector64) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Int64Vector + @ForceInline IntVector64 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Int64Vector) super.lanewiseShiftTemplate(op, Int64Mask.class, e, (Int64Mask) m); // specialize + return (IntVector64) super.lanewiseShiftTemplate(op, IntMask64.class, e, (IntMask64) m); // specialize } /*package-private*/ @Override @ForceInline public final - Int64Vector + IntVector64 lanewise(Ternary op, Vector v1, Vector v2) { - return (Int64Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (IntVector64) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Int64Vector + IntVector64 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Int64Vector) super.lanewiseTemplate(op, Int64Mask.class, v1, v2, (Int64Mask) m); // specialize + return (IntVector64) super.lanewiseTemplate(op, IntMask64.class, v1, v2, (IntMask64) m); // specialize } @Override @ForceInline public final - Int64Vector addIndex(int scale) { - return (Int64Vector) super.addIndexTemplate(scale); // specialize + IntVector64 addIndex(int scale) { + return (IntVector64) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Int64Vector extends IntVector { @ForceInline public final int reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Int64Mask.class, (Int64Mask) m); // specialized + return super.reduceLanesTemplate(op, IntMask64.class, (IntMask64) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Int64Vector extends IntVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Int64Mask.class, (Int64Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, IntMask64.class, (IntMask64) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Int64Vector extends IntVector { @Override @ForceInline - public final Int64Shuffle toShuffle() { - return (Int64Shuffle) toShuffle(vspecies(), false); + public final IntShuffle64 toShuffle() { + return (IntShuffle64) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Int64Mask test(Test op) { - return super.testTemplate(Int64Mask.class, op); // specialize + public final IntMask64 test(Test op) { + return super.testTemplate(IntMask64.class, op); // specialize } @Override @ForceInline - public final Int64Mask test(Test op, VectorMask m) { - return super.testTemplate(Int64Mask.class, op, (Int64Mask) m); // specialize + public final IntMask64 test(Test op, VectorMask m) { + return super.testTemplate(IntMask64.class, op, (IntMask64) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Int64Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Int64Mask.class, op, v); // specialize + public final IntMask64 compare(Comparison op, Vector v) { + return super.compareTemplate(IntMask64.class, op, v); // specialize } @Override @ForceInline - public final Int64Mask compare(Comparison op, int s) { - return super.compareTemplate(Int64Mask.class, op, s); // specialize + public final IntMask64 compare(Comparison op, int s) { + return super.compareTemplate(IntMask64.class, op, s); // specialize } @Override @ForceInline - public final Int64Mask compare(Comparison op, long s) { - return super.compareTemplate(Int64Mask.class, op, s); // specialize + public final IntMask64 compare(Comparison op, long s) { + return super.compareTemplate(IntMask64.class, op, s); // specialize } @Override @ForceInline - public final Int64Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Int64Mask.class, op, v, (Int64Mask) m); + public final IntMask64 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(IntMask64.class, op, v, (IntMask64) m); } @Override @ForceInline - public Int64Vector blend(Vector v, VectorMask m) { - return (Int64Vector) - super.blendTemplate(Int64Mask.class, - (Int64Vector) v, - (Int64Mask) m); // specialize + public IntVector64 blend(Vector v, VectorMask m) { + return (IntVector64) + super.blendTemplate(IntMask64.class, + (IntVector64) v, + (IntMask64) m); // specialize } @Override @ForceInline - public Int64Vector slice(int origin, Vector v) { - return (Int64Vector) super.sliceTemplate(origin, v); // specialize + public IntVector64 slice(int origin, Vector v) { + return (IntVector64) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Int64Vector slice(int origin) { - return (Int64Vector) super.sliceTemplate(origin); // specialize + public IntVector64 slice(int origin) { + return (IntVector64) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Int64Vector unslice(int origin, Vector w, int part) { - return (Int64Vector) super.unsliceTemplate(origin, w, part); // specialize + public IntVector64 unslice(int origin, Vector w, int part) { + return (IntVector64) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Int64Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Int64Vector) - super.unsliceTemplate(Int64Mask.class, + public IntVector64 unslice(int origin, Vector w, int part, VectorMask m) { + return (IntVector64) + super.unsliceTemplate(IntMask64.class, origin, w, part, - (Int64Mask) m); // specialize + (IntMask64) m); // specialize } @Override @ForceInline - public Int64Vector unslice(int origin) { - return (Int64Vector) super.unsliceTemplate(origin); // specialize + public IntVector64 unslice(int origin) { + return (IntVector64) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Int64Vector rearrange(VectorShuffle s) { - return (Int64Vector) - super.rearrangeTemplate(Int64Shuffle.class, - (Int64Shuffle) s); // specialize + public IntVector64 rearrange(VectorShuffle s) { + return (IntVector64) + super.rearrangeTemplate(IntShuffle64.class, + (IntShuffle64) s); // specialize } @Override @ForceInline - public Int64Vector rearrange(VectorShuffle shuffle, + public IntVector64 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Int64Vector) - super.rearrangeTemplate(Int64Shuffle.class, - Int64Mask.class, - (Int64Shuffle) shuffle, - (Int64Mask) m); // specialize + return (IntVector64) + super.rearrangeTemplate(IntShuffle64.class, + IntMask64.class, + (IntShuffle64) shuffle, + (IntMask64) m); // specialize } @Override @ForceInline - public Int64Vector rearrange(VectorShuffle s, + public IntVector64 rearrange(VectorShuffle s, Vector v) { - return (Int64Vector) - super.rearrangeTemplate(Int64Shuffle.class, - (Int64Shuffle) s, - (Int64Vector) v); // specialize + return (IntVector64) + super.rearrangeTemplate(IntShuffle64.class, + (IntShuffle64) s, + (IntVector64) v); // specialize } @Override @ForceInline - public Int64Vector compress(VectorMask m) { - return (Int64Vector) - super.compressTemplate(Int64Mask.class, - (Int64Mask) m); // specialize + public IntVector64 compress(VectorMask m) { + return (IntVector64) + super.compressTemplate(IntMask64.class, + (IntMask64) m); // specialize } @Override @ForceInline - public Int64Vector expand(VectorMask m) { - return (Int64Vector) - super.expandTemplate(Int64Mask.class, - (Int64Mask) m); // specialize + public IntVector64 expand(VectorMask m) { + return (IntVector64) + super.expandTemplate(IntMask64.class, + (IntMask64) m); // specialize } @Override @ForceInline - public Int64Vector selectFrom(Vector v) { - return (Int64Vector) - super.selectFromTemplate((Int64Vector) v); // specialize + public IntVector64 selectFrom(Vector v) { + return (IntVector64) + super.selectFromTemplate((IntVector64) v); // specialize } @Override @ForceInline - public Int64Vector selectFrom(Vector v, + public IntVector64 selectFrom(Vector v, VectorMask m) { - return (Int64Vector) - super.selectFromTemplate((Int64Vector) v, - Int64Mask.class, (Int64Mask) m); // specialize + return (IntVector64) + super.selectFromTemplate((IntVector64) v, + IntMask64.class, (IntMask64) m); // specialize } @Override @ForceInline - public Int64Vector selectFrom(Vector v1, + public IntVector64 selectFrom(Vector v1, Vector v2) { - return (Int64Vector) - super.selectFromTemplate((Int64Vector) v1, (Int64Vector) v2); // specialize + return (IntVector64) + super.selectFromTemplate((IntVector64) v1, (IntVector64) v2); // specialize } @ForceInline @@ -544,7 +544,7 @@ final class Int64Vector extends IntVector { @ForceInline @Override - public Int64Vector withLane(int i, int e) { + public IntVector64 withLane(int i, int e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -553,7 +553,7 @@ final class Int64Vector extends IntVector { } @ForceInline - public Int64Vector withLaneHelper(int i, int e) { + public IntVector64 withLaneHelper(int i, int e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -566,19 +566,19 @@ final class Int64Vector extends IntVector { // Mask - static final class Int64Mask extends AbstractMask { + static final class IntMask64 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Int64Mask(boolean[] bits) { + IntMask64(boolean[] bits) { this(bits, 0); } - Int64Mask(boolean[] bits, int offset) { + IntMask64(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Int64Mask(boolean val) { + IntMask64(boolean val) { super(prepare(val)); } @@ -611,31 +611,31 @@ final class Int64Vector extends IntVector { } @Override - Int64Mask uOp(MUnOp f) { + IntMask64 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Int64Mask(res); + return new IntMask64(res); } @Override - Int64Mask bOp(VectorMask m, MBinOp f) { + IntMask64 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Int64Mask)m).getBits(); + boolean[] mbits = ((IntMask64)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Int64Mask(res); + return new IntMask64(res); } @ForceInline @Override public final - Int64Vector toVector() { - return (Int64Vector) super.toVectorTemplate(); // specialize + IntVector64 toVector() { + return (IntVector64) super.toVectorTemplate(); // specialize } /** @@ -668,25 +668,25 @@ final class Int64Vector extends IntVector { @Override @ForceInline /*package-private*/ - Int64Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Int64Mask) VectorSupport.indexPartiallyInUpperRange( - Int64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Int64Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + IntMask64 indexPartiallyInUpperRange(long offset, long limit) { + return (IntMask64) VectorSupport.indexPartiallyInUpperRange( + IntMask64.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (IntMask64) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Int64Mask not() { + public IntMask64 not() { return xor(maskAll(true)); } @Override @ForceInline - public Int64Mask compress() { - return (Int64Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Int64Vector.class, Int64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public IntMask64 compress() { + return (IntMask64)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + IntVector64.class, IntMask64.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -695,30 +695,30 @@ final class Int64Vector extends IntVector { @Override @ForceInline - public Int64Mask and(VectorMask mask) { + public IntMask64 and(VectorMask mask) { Objects.requireNonNull(mask); - Int64Mask m = (Int64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Int64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask64 m = (IntMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, IntMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Int64Mask or(VectorMask mask) { + public IntMask64 or(VectorMask mask) { Objects.requireNonNull(mask); - Int64Mask m = (Int64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Int64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask64 m = (IntMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, IntMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Int64Mask xor(VectorMask mask) { + public IntMask64 xor(VectorMask mask) { Objects.requireNonNull(mask); - Int64Mask m = (Int64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Int64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMask64 m = (IntMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, IntMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -728,21 +728,21 @@ final class Int64Vector extends IntVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Int64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, IntMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Int64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, IntMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Int64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, IntMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -752,7 +752,7 @@ final class Int64Vector extends IntVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Int64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, IntMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -762,7 +762,7 @@ final class Int64Vector extends IntVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Int64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(IntMask64.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -771,48 +771,48 @@ final class Int64Vector extends IntVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Int64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, IntMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Int64Mask)m).getBits())); + (m, __) -> anyTrueHelper(((IntMask64)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Int64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, IntMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Int64Mask)m).getBits())); + (m, __) -> allTrueHelper(((IntMask64)m).getBits())); } @ForceInline /*package-private*/ - static Int64Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Int64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static IntMask64 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(IntMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Int64Mask TRUE_MASK = new Int64Mask(true); - private static final Int64Mask FALSE_MASK = new Int64Mask(false); + private static final IntMask64 TRUE_MASK = new IntMask64(true); + private static final IntMask64 FALSE_MASK = new IntMask64(false); } // Shuffle - static final class Int64Shuffle extends AbstractShuffle { + static final class IntShuffle64 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - Int64Shuffle(int[] indices) { + IntShuffle64(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Int64Shuffle(int[] indices, int i) { + IntShuffle64(int[] indices, int i) { this(prepare(indices, i)); } - Int64Shuffle(IntUnaryOperator fn) { + IntShuffle64(IntUnaryOperator fn) { this(prepare(fn)); } @@ -832,23 +832,23 @@ final class Int64Vector extends IntVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final Int64Shuffle IOTA = new Int64Shuffle(IDENTITY); + static final IntShuffle64 IOTA = new IntShuffle64(IDENTITY); @Override @ForceInline - public Int64Vector toVector() { + public IntVector64 toVector() { return toBitsVector(); } @Override @ForceInline - Int64Vector toBitsVector() { - return (Int64Vector) super.toBitsVectorTemplate(); + IntVector64 toBitsVector() { + return (IntVector64) super.toBitsVectorTemplate(); } @Override - Int64Vector toBitsVector0() { - return ((Int64Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVector64 toBitsVector0() { + return ((IntVector64) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -871,30 +871,30 @@ final class Int64Vector extends IntVector { @Override @ForceInline - public final Int64Mask laneIsValid() { - return (Int64Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final IntMask64 laneIsValid() { + return (IntMask64) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Int64Shuffle rearrange(VectorShuffle shuffle) { - Int64Shuffle concreteShuffle = (Int64Shuffle) shuffle; - return (Int64Shuffle) toBitsVector().rearrange(concreteShuffle) + public final IntShuffle64 rearrange(VectorShuffle shuffle) { + IntShuffle64 concreteShuffle = (IntShuffle64) shuffle; + return (IntShuffle64) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Int64Shuffle wrapIndexes() { - Int64Vector v = toBitsVector(); + public final IntShuffle64 wrapIndexes() { + IntVector64 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Int64Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVector64) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Int64Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVector64) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Int64Shuffle) v.toShuffle(vspecies(), false); + return (IntShuffle64) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -945,14 +945,14 @@ final class Int64Vector extends IntVector { @Override final IntVector fromArray0(int[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Int64Mask.class, a, offset, (Int64Mask) m, offsetInRange); // specialize + return super.fromArray0Template(IntMask64.class, a, offset, (IntMask64) m, offsetInRange); // specialize } @ForceInline @Override final IntVector fromArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Int64Mask.class, a, offset, indexMap, mapOffset, (Int64Mask) m); + return super.fromArray0Template(IntMask64.class, a, offset, indexMap, mapOffset, (IntMask64) m); } @@ -968,7 +968,7 @@ final class Int64Vector extends IntVector { @Override final IntVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Int64Mask.class, ms, offset, (Int64Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(IntMask64.class, ms, offset, (IntMask64) m, offsetInRange); // specialize } @ForceInline @@ -982,14 +982,14 @@ final class Int64Vector extends IntVector { @Override final void intoArray0(int[] a, int offset, VectorMask m) { - super.intoArray0Template(Int64Mask.class, a, offset, (Int64Mask) m); + super.intoArray0Template(IntMask64.class, a, offset, (IntMask64) m); } @ForceInline @Override final void intoArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Int64Mask.class, a, offset, indexMap, mapOffset, (Int64Mask) m); + super.intoArray0Template(IntMask64.class, a, offset, indexMap, mapOffset, (IntMask64) m); } @@ -997,7 +997,7 @@ final class Int64Vector extends IntVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Int64Mask.class, ms, offset, (Int64Mask) m); + super.intoMemorySegment0Template(IntMask64.class, ms, offset, (IntMask64) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntMaxVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVectorMax.java similarity index 65% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntMaxVector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVectorMax.java index 177890e765c..e3d94a0d06d 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntMaxVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVectorMax.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class IntMaxVector extends IntVector { +final class IntVectorMax extends IntVector { static final IntSpecies VSPECIES = (IntSpecies) IntVector.SPECIES_MAX; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = IntMaxVector.class; + static final Class VCLASS = IntVectorMax.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class IntMaxVector extends IntVector { static final Class ETYPE = int.class; // used by the JVM - IntMaxVector(int[] v) { + IntVectorMax(int[] v) { super(v); } - // For compatibility as IntMaxVector::new, + // For compatibility as IntVectorMax::new, // stored into species.vectorFactory. - IntMaxVector(Object v) { + IntVectorMax(Object v) { this((int[]) v); } - static final IntMaxVector ZERO = new IntMaxVector(new int[VLENGTH]); - static final IntMaxVector IOTA = new IntMaxVector(VSPECIES.iotaArray()); + static final IntVectorMax ZERO = new IntVectorMax(new int[VLENGTH]); + static final IntVectorMax IOTA = new IntVectorMax(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class IntMaxVector extends IntVector { @Override @ForceInline - public final IntMaxVector broadcast(int e) { - return (IntMaxVector) super.broadcastTemplate(e); // specialize + public final IntVectorMax broadcast(int e) { + return (IntVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final IntMaxVector broadcast(long e) { - return (IntMaxVector) super.broadcastTemplate(e); // specialize + public final IntVectorMax broadcast(long e) { + return (IntVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - IntMaxMask maskFromArray(boolean[] bits) { - return new IntMaxMask(bits); + IntMaskMax maskFromArray(boolean[] bits) { + return new IntMaskMax(bits); } @Override @ForceInline - IntMaxShuffle iotaShuffle() { return IntMaxShuffle.IOTA; } + IntShuffleMax iotaShuffle() { return IntShuffleMax.IOTA; } @Override @ForceInline - IntMaxShuffle iotaShuffle(int start, int step, boolean wrap) { - return (IntMaxShuffle) iotaShuffleTemplate(start, step, wrap); + IntShuffleMax iotaShuffle(int start, int step, boolean wrap) { + return (IntShuffleMax) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - IntMaxShuffle shuffleFromArray(int[] indices, int i) { return new IntMaxShuffle(indices, i); } + IntShuffleMax shuffleFromArray(int[] indices, int i) { return new IntShuffleMax(indices, i); } @Override @ForceInline - IntMaxShuffle shuffleFromOp(IntUnaryOperator fn) { return new IntMaxShuffle(fn); } + IntShuffleMax shuffleFromOp(IntUnaryOperator fn) { return new IntShuffleMax(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - IntMaxVector vectorFactory(int[] vec) { - return new IntMaxVector(vec); + IntVectorMax vectorFactory(int[] vec) { + return new IntVectorMax(vec); } @ForceInline final @Override - ByteMaxVector asByteVectorRaw() { - return (ByteMaxVector) super.asByteVectorRawTemplate(); // specialize + ByteVectorMax asByteVectorRaw() { + return (ByteVectorMax) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class IntMaxVector extends IntVector { @ForceInline final @Override - IntMaxVector uOp(FUnOp f) { - return (IntMaxVector) super.uOpTemplate(f); // specialize + IntVectorMax uOp(FUnOp f) { + return (IntVectorMax) super.uOpTemplate(f); // specialize } @ForceInline final @Override - IntMaxVector uOp(VectorMask m, FUnOp f) { - return (IntMaxVector) - super.uOpTemplate((IntMaxMask)m, f); // specialize + IntVectorMax uOp(VectorMask m, FUnOp f) { + return (IntVectorMax) + super.uOpTemplate((IntMaskMax)m, f); // specialize } // Binary operator @ForceInline final @Override - IntMaxVector bOp(Vector v, FBinOp f) { - return (IntMaxVector) super.bOpTemplate((IntMaxVector)v, f); // specialize + IntVectorMax bOp(Vector v, FBinOp f) { + return (IntVectorMax) super.bOpTemplate((IntVectorMax)v, f); // specialize } @ForceInline final @Override - IntMaxVector bOp(Vector v, + IntVectorMax bOp(Vector v, VectorMask m, FBinOp f) { - return (IntMaxVector) - super.bOpTemplate((IntMaxVector)v, (IntMaxMask)m, + return (IntVectorMax) + super.bOpTemplate((IntVectorMax)v, (IntMaskMax)m, f); // specialize } @@ -219,19 +219,19 @@ final class IntMaxVector extends IntVector { @ForceInline final @Override - IntMaxVector tOp(Vector v1, Vector v2, FTriOp f) { - return (IntMaxVector) - super.tOpTemplate((IntMaxVector)v1, (IntMaxVector)v2, + IntVectorMax tOp(Vector v1, Vector v2, FTriOp f) { + return (IntVectorMax) + super.tOpTemplate((IntVectorMax)v1, (IntVectorMax)v2, f); // specialize } @ForceInline final @Override - IntMaxVector tOp(Vector v1, Vector v2, + IntVectorMax tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (IntMaxVector) - super.tOpTemplate((IntMaxVector)v1, (IntMaxVector)v2, - (IntMaxMask)m, f); // specialize + return (IntVectorMax) + super.tOpTemplate((IntVectorMax)v1, (IntVectorMax)v2, + (IntMaskMax)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class IntMaxVector extends IntVector { @Override @ForceInline - public IntMaxVector lanewise(Unary op) { - return (IntMaxVector) super.lanewiseTemplate(op); // specialize + public IntVectorMax lanewise(Unary op) { + return (IntVectorMax) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public IntMaxVector lanewise(Unary op, VectorMask m) { - return (IntMaxVector) super.lanewiseTemplate(op, IntMaxMask.class, (IntMaxMask) m); // specialize + public IntVectorMax lanewise(Unary op, VectorMask m) { + return (IntVectorMax) super.lanewiseTemplate(op, IntMaskMax.class, (IntMaskMax) m); // specialize } @Override @ForceInline - public IntMaxVector lanewise(Binary op, Vector v) { - return (IntMaxVector) super.lanewiseTemplate(op, v); // specialize + public IntVectorMax lanewise(Binary op, Vector v) { + return (IntVectorMax) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public IntMaxVector lanewise(Binary op, Vector v, VectorMask m) { - return (IntMaxVector) super.lanewiseTemplate(op, IntMaxMask.class, v, (IntMaxMask) m); // specialize + public IntVectorMax lanewise(Binary op, Vector v, VectorMask m) { + return (IntVectorMax) super.lanewiseTemplate(op, IntMaskMax.class, v, (IntMaskMax) m); // specialize } /*package-private*/ @Override - @ForceInline IntMaxVector + @ForceInline IntVectorMax lanewiseShift(VectorOperators.Binary op, int e) { - return (IntMaxVector) super.lanewiseShiftTemplate(op, e); // specialize + return (IntVectorMax) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline IntMaxVector + @ForceInline IntVectorMax lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (IntMaxVector) super.lanewiseShiftTemplate(op, IntMaxMask.class, e, (IntMaxMask) m); // specialize + return (IntVectorMax) super.lanewiseShiftTemplate(op, IntMaskMax.class, e, (IntMaskMax) m); // specialize } /*package-private*/ @Override @ForceInline public final - IntMaxVector + IntVectorMax lanewise(Ternary op, Vector v1, Vector v2) { - return (IntMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize + return (IntVectorMax) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - IntMaxVector + IntVectorMax lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (IntMaxVector) super.lanewiseTemplate(op, IntMaxMask.class, v1, v2, (IntMaxMask) m); // specialize + return (IntVectorMax) super.lanewiseTemplate(op, IntMaskMax.class, v1, v2, (IntMaskMax) m); // specialize } @Override @ForceInline public final - IntMaxVector addIndex(int scale) { - return (IntMaxVector) super.addIndexTemplate(scale); // specialize + IntVectorMax addIndex(int scale) { + return (IntVectorMax) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class IntMaxVector extends IntVector { @ForceInline public final int reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, IntMaxMask.class, (IntMaxMask) m); // specialized + return super.reduceLanesTemplate(op, IntMaskMax.class, (IntMaskMax) m); // specialized } @Override @@ -354,7 +354,7 @@ final class IntMaxVector extends IntVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, IntMaxMask.class, (IntMaxMask) m); // specialized + return (long) super.reduceLanesTemplate(op, IntMaskMax.class, (IntMaskMax) m); // specialized } @Override @@ -365,160 +365,160 @@ final class IntMaxVector extends IntVector { @Override @ForceInline - public final IntMaxShuffle toShuffle() { - return (IntMaxShuffle) toShuffle(vspecies(), false); + public final IntShuffleMax toShuffle() { + return (IntShuffleMax) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final IntMaxMask test(Test op) { - return super.testTemplate(IntMaxMask.class, op); // specialize + public final IntMaskMax test(Test op) { + return super.testTemplate(IntMaskMax.class, op); // specialize } @Override @ForceInline - public final IntMaxMask test(Test op, VectorMask m) { - return super.testTemplate(IntMaxMask.class, op, (IntMaxMask) m); // specialize + public final IntMaskMax test(Test op, VectorMask m) { + return super.testTemplate(IntMaskMax.class, op, (IntMaskMax) m); // specialize } // Specialized comparisons @Override @ForceInline - public final IntMaxMask compare(Comparison op, Vector v) { - return super.compareTemplate(IntMaxMask.class, op, v); // specialize + public final IntMaskMax compare(Comparison op, Vector v) { + return super.compareTemplate(IntMaskMax.class, op, v); // specialize } @Override @ForceInline - public final IntMaxMask compare(Comparison op, int s) { - return super.compareTemplate(IntMaxMask.class, op, s); // specialize + public final IntMaskMax compare(Comparison op, int s) { + return super.compareTemplate(IntMaskMax.class, op, s); // specialize } @Override @ForceInline - public final IntMaxMask compare(Comparison op, long s) { - return super.compareTemplate(IntMaxMask.class, op, s); // specialize + public final IntMaskMax compare(Comparison op, long s) { + return super.compareTemplate(IntMaskMax.class, op, s); // specialize } @Override @ForceInline - public final IntMaxMask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(IntMaxMask.class, op, v, (IntMaxMask) m); + public final IntMaskMax compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(IntMaskMax.class, op, v, (IntMaskMax) m); } @Override @ForceInline - public IntMaxVector blend(Vector v, VectorMask m) { - return (IntMaxVector) - super.blendTemplate(IntMaxMask.class, - (IntMaxVector) v, - (IntMaxMask) m); // specialize + public IntVectorMax blend(Vector v, VectorMask m) { + return (IntVectorMax) + super.blendTemplate(IntMaskMax.class, + (IntVectorMax) v, + (IntMaskMax) m); // specialize } @Override @ForceInline - public IntMaxVector slice(int origin, Vector v) { - return (IntMaxVector) super.sliceTemplate(origin, v); // specialize + public IntVectorMax slice(int origin, Vector v) { + return (IntVectorMax) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public IntMaxVector slice(int origin) { - return (IntMaxVector) super.sliceTemplate(origin); // specialize + public IntVectorMax slice(int origin) { + return (IntVectorMax) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public IntMaxVector unslice(int origin, Vector w, int part) { - return (IntMaxVector) super.unsliceTemplate(origin, w, part); // specialize + public IntVectorMax unslice(int origin, Vector w, int part) { + return (IntVectorMax) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public IntMaxVector unslice(int origin, Vector w, int part, VectorMask m) { - return (IntMaxVector) - super.unsliceTemplate(IntMaxMask.class, + public IntVectorMax unslice(int origin, Vector w, int part, VectorMask m) { + return (IntVectorMax) + super.unsliceTemplate(IntMaskMax.class, origin, w, part, - (IntMaxMask) m); // specialize + (IntMaskMax) m); // specialize } @Override @ForceInline - public IntMaxVector unslice(int origin) { - return (IntMaxVector) super.unsliceTemplate(origin); // specialize + public IntVectorMax unslice(int origin) { + return (IntVectorMax) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public IntMaxVector rearrange(VectorShuffle s) { - return (IntMaxVector) - super.rearrangeTemplate(IntMaxShuffle.class, - (IntMaxShuffle) s); // specialize + public IntVectorMax rearrange(VectorShuffle s) { + return (IntVectorMax) + super.rearrangeTemplate(IntShuffleMax.class, + (IntShuffleMax) s); // specialize } @Override @ForceInline - public IntMaxVector rearrange(VectorShuffle shuffle, + public IntVectorMax rearrange(VectorShuffle shuffle, VectorMask m) { - return (IntMaxVector) - super.rearrangeTemplate(IntMaxShuffle.class, - IntMaxMask.class, - (IntMaxShuffle) shuffle, - (IntMaxMask) m); // specialize + return (IntVectorMax) + super.rearrangeTemplate(IntShuffleMax.class, + IntMaskMax.class, + (IntShuffleMax) shuffle, + (IntMaskMax) m); // specialize } @Override @ForceInline - public IntMaxVector rearrange(VectorShuffle s, + public IntVectorMax rearrange(VectorShuffle s, Vector v) { - return (IntMaxVector) - super.rearrangeTemplate(IntMaxShuffle.class, - (IntMaxShuffle) s, - (IntMaxVector) v); // specialize + return (IntVectorMax) + super.rearrangeTemplate(IntShuffleMax.class, + (IntShuffleMax) s, + (IntVectorMax) v); // specialize } @Override @ForceInline - public IntMaxVector compress(VectorMask m) { - return (IntMaxVector) - super.compressTemplate(IntMaxMask.class, - (IntMaxMask) m); // specialize + public IntVectorMax compress(VectorMask m) { + return (IntVectorMax) + super.compressTemplate(IntMaskMax.class, + (IntMaskMax) m); // specialize } @Override @ForceInline - public IntMaxVector expand(VectorMask m) { - return (IntMaxVector) - super.expandTemplate(IntMaxMask.class, - (IntMaxMask) m); // specialize + public IntVectorMax expand(VectorMask m) { + return (IntVectorMax) + super.expandTemplate(IntMaskMax.class, + (IntMaskMax) m); // specialize } @Override @ForceInline - public IntMaxVector selectFrom(Vector v) { - return (IntMaxVector) - super.selectFromTemplate((IntMaxVector) v); // specialize + public IntVectorMax selectFrom(Vector v) { + return (IntVectorMax) + super.selectFromTemplate((IntVectorMax) v); // specialize } @Override @ForceInline - public IntMaxVector selectFrom(Vector v, + public IntVectorMax selectFrom(Vector v, VectorMask m) { - return (IntMaxVector) - super.selectFromTemplate((IntMaxVector) v, - IntMaxMask.class, (IntMaxMask) m); // specialize + return (IntVectorMax) + super.selectFromTemplate((IntVectorMax) v, + IntMaskMax.class, (IntMaskMax) m); // specialize } @Override @ForceInline - public IntMaxVector selectFrom(Vector v1, + public IntVectorMax selectFrom(Vector v1, Vector v2) { - return (IntMaxVector) - super.selectFromTemplate((IntMaxVector) v1, (IntMaxVector) v2); // specialize + return (IntVectorMax) + super.selectFromTemplate((IntVectorMax) v1, (IntVectorMax) v2); // specialize } @ForceInline @@ -543,7 +543,7 @@ final class IntMaxVector extends IntVector { @ForceInline @Override - public IntMaxVector withLane(int i, int e) { + public IntVectorMax withLane(int i, int e) { if (i < 0 || i >= VLENGTH) { throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); } @@ -551,7 +551,7 @@ final class IntMaxVector extends IntVector { } @ForceInline - public IntMaxVector withLaneHelper(int i, int e) { + public IntVectorMax withLaneHelper(int i, int e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -564,19 +564,19 @@ final class IntMaxVector extends IntVector { // Mask - static final class IntMaxMask extends AbstractMask { + static final class IntMaskMax extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - IntMaxMask(boolean[] bits) { + IntMaskMax(boolean[] bits) { this(bits, 0); } - IntMaxMask(boolean[] bits, int offset) { + IntMaskMax(boolean[] bits, int offset) { super(prepare(bits, offset)); } - IntMaxMask(boolean val) { + IntMaskMax(boolean val) { super(prepare(val)); } @@ -609,31 +609,31 @@ final class IntMaxVector extends IntVector { } @Override - IntMaxMask uOp(MUnOp f) { + IntMaskMax uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new IntMaxMask(res); + return new IntMaskMax(res); } @Override - IntMaxMask bOp(VectorMask m, MBinOp f) { + IntMaskMax bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((IntMaxMask)m).getBits(); + boolean[] mbits = ((IntMaskMax)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new IntMaxMask(res); + return new IntMaskMax(res); } @ForceInline @Override public final - IntMaxVector toVector() { - return (IntMaxVector) super.toVectorTemplate(); // specialize + IntVectorMax toVector() { + return (IntVectorMax) super.toVectorTemplate(); // specialize } /** @@ -666,25 +666,25 @@ final class IntMaxVector extends IntVector { @Override @ForceInline /*package-private*/ - IntMaxMask indexPartiallyInUpperRange(long offset, long limit) { - return (IntMaxMask) VectorSupport.indexPartiallyInUpperRange( - IntMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (IntMaxMask) TRUE_MASK.indexPartiallyInRange(o, l)); + IntMaskMax indexPartiallyInUpperRange(long offset, long limit) { + return (IntMaskMax) VectorSupport.indexPartiallyInUpperRange( + IntMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (IntMaskMax) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public IntMaxMask not() { + public IntMaskMax not() { return xor(maskAll(true)); } @Override @ForceInline - public IntMaxMask compress() { - return (IntMaxMask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - IntMaxVector.class, IntMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public IntMaskMax compress() { + return (IntMaskMax)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + IntVectorMax.class, IntMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -693,30 +693,30 @@ final class IntMaxVector extends IntVector { @Override @ForceInline - public IntMaxMask and(VectorMask mask) { + public IntMaskMax and(VectorMask mask) { Objects.requireNonNull(mask); - IntMaxMask m = (IntMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, IntMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMaskMax m = (IntMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, IntMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public IntMaxMask or(VectorMask mask) { + public IntMaskMax or(VectorMask mask) { Objects.requireNonNull(mask); - IntMaxMask m = (IntMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, IntMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMaskMax m = (IntMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, IntMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public IntMaxMask xor(VectorMask mask) { + public IntMaskMax xor(VectorMask mask) { Objects.requireNonNull(mask); - IntMaxMask m = (IntMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, IntMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + IntMaskMax m = (IntMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, IntMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -726,21 +726,21 @@ final class IntMaxVector extends IntVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, IntMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, IntMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, IntMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, IntMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, IntMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, IntMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -750,7 +750,7 @@ final class IntMaxVector extends IntVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, IntMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, IntMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -760,7 +760,7 @@ final class IntMaxVector extends IntVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(IntMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(IntMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -769,28 +769,28 @@ final class IntMaxVector extends IntVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, IntMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, IntMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((IntMaxMask)m).getBits())); + (m, __) -> anyTrueHelper(((IntMaskMax)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, IntMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, IntMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((IntMaxMask)m).getBits())); + (m, __) -> allTrueHelper(((IntMaskMax)m).getBits())); } @ForceInline /*package-private*/ - static IntMaxMask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(IntMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static IntMaskMax maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(IntMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final IntMaxMask TRUE_MASK = new IntMaxMask(true); - private static final IntMaxMask FALSE_MASK = new IntMaxMask(false); + private static final IntMaskMax TRUE_MASK = new IntMaskMax(true); + private static final IntMaskMax FALSE_MASK = new IntMaskMax(false); static boolean[] maskLowerHalf() { @@ -802,26 +802,26 @@ final class IntMaxVector extends IntVector { return a; } - static final IntMaxMask LOWER_HALF_TRUE_MASK = new IntMaxMask(maskLowerHalf()); + static final IntMaskMax LOWER_HALF_TRUE_MASK = new IntMaskMax(maskLowerHalf()); } // Shuffle - static final class IntMaxShuffle extends AbstractShuffle { + static final class IntShuffleMax extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = int.class; // used by the JVM - IntMaxShuffle(int[] indices) { + IntShuffleMax(int[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - IntMaxShuffle(int[] indices, int i) { + IntShuffleMax(int[] indices, int i) { this(prepare(indices, i)); } - IntMaxShuffle(IntUnaryOperator fn) { + IntShuffleMax(IntUnaryOperator fn) { this(prepare(fn)); } @@ -841,23 +841,23 @@ final class IntMaxVector extends IntVector { assert(VLENGTH < Integer.MAX_VALUE); assert(Integer.MIN_VALUE <= -VLENGTH); } - static final IntMaxShuffle IOTA = new IntMaxShuffle(IDENTITY); + static final IntShuffleMax IOTA = new IntShuffleMax(IDENTITY); @Override @ForceInline - public IntMaxVector toVector() { + public IntVectorMax toVector() { return toBitsVector(); } @Override @ForceInline - IntMaxVector toBitsVector() { - return (IntMaxVector) super.toBitsVectorTemplate(); + IntVectorMax toBitsVector() { + return (IntVectorMax) super.toBitsVectorTemplate(); } @Override - IntMaxVector toBitsVector0() { - return ((IntMaxVector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + IntVectorMax toBitsVector0() { + return ((IntVectorMax) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -880,30 +880,30 @@ final class IntMaxVector extends IntVector { @Override @ForceInline - public final IntMaxMask laneIsValid() { - return (IntMaxMask) toBitsVector().compare(VectorOperators.GE, 0) + public final IntMaskMax laneIsValid() { + return (IntMaskMax) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final IntMaxShuffle rearrange(VectorShuffle shuffle) { - IntMaxShuffle concreteShuffle = (IntMaxShuffle) shuffle; - return (IntMaxShuffle) toBitsVector().rearrange(concreteShuffle) + public final IntShuffleMax rearrange(VectorShuffle shuffle) { + IntShuffleMax concreteShuffle = (IntShuffleMax) shuffle; + return (IntShuffleMax) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final IntMaxShuffle wrapIndexes() { - IntMaxVector v = toBitsVector(); + public final IntShuffleMax wrapIndexes() { + IntVectorMax v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (IntMaxVector) v.lanewise(VectorOperators.AND, length() - 1); + v = (IntVectorMax) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (IntMaxVector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (IntVectorMax) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (IntMaxShuffle) v.toShuffle(vspecies(), false); + return (IntShuffleMax) v.toShuffle(vspecies(), false); } private static int[] prepare(int[] indices, int offset) { @@ -954,14 +954,14 @@ final class IntMaxVector extends IntVector { @Override final IntVector fromArray0(int[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(IntMaxMask.class, a, offset, (IntMaxMask) m, offsetInRange); // specialize + return super.fromArray0Template(IntMaskMax.class, a, offset, (IntMaskMax) m, offsetInRange); // specialize } @ForceInline @Override final IntVector fromArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(IntMaxMask.class, a, offset, indexMap, mapOffset, (IntMaxMask) m); + return super.fromArray0Template(IntMaskMax.class, a, offset, indexMap, mapOffset, (IntMaskMax) m); } @@ -977,7 +977,7 @@ final class IntMaxVector extends IntVector { @Override final IntVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(IntMaxMask.class, ms, offset, (IntMaxMask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(IntMaskMax.class, ms, offset, (IntMaskMax) m, offsetInRange); // specialize } @ForceInline @@ -991,14 +991,14 @@ final class IntMaxVector extends IntVector { @Override final void intoArray0(int[] a, int offset, VectorMask m) { - super.intoArray0Template(IntMaxMask.class, a, offset, (IntMaxMask) m); + super.intoArray0Template(IntMaskMax.class, a, offset, (IntMaskMax) m); } @ForceInline @Override final void intoArray0(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(IntMaxMask.class, a, offset, indexMap, mapOffset, (IntMaxMask) m); + super.intoArray0Template(IntMaskMax.class, a, offset, indexMap, mapOffset, (IntMaskMax) m); } @@ -1006,7 +1006,7 @@ final class IntMaxVector extends IntVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(IntMaxMask.class, ms, offset, (IntMaxMask) m); + super.intoMemorySegment0Template(IntMaskMax.class, ms, offset, (IntMaskMax) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java index 5657bbec0a6..7ba0af6c139 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java @@ -84,8 +84,8 @@ public abstract class LongVector extends AbstractVector { // The various shape-specific subclasses // also specialize them by wrapping // them in a call like this: - // return (Byte128Vector) - // super.bOp((Byte128Vector) o); + // return (ByteVector128) + // super.bOp((ByteVector128) o); // The purpose of that is to forcibly inline // the generic definition from this file // into a sharply-typed and size-specific @@ -2964,7 +2964,7 @@ public abstract class LongVector extends AbstractVector { // Index vector: vix[0:n] = k -> offset + indexMap[mapOffset + k] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For LongMaxVector, if vector length is non-power-of-two or + // For LongVectorMax, if vector length is non-power-of-two or // 2048 bits, indexShape of Long species is S_MAX_BIT. // Assume that vector length is 2048, then the lane count of Long // vector is 32. When converting Long species to int species, @@ -2972,7 +2972,7 @@ public abstract class LongVector extends AbstractVector { // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -3255,14 +3255,14 @@ public abstract class LongVector extends AbstractVector { // Index vector: vix[0:n] = i -> offset + indexMap[mo + i] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For LongMaxVector, if vector length is 2048 bits, indexShape + // For LongVectorMax, if vector length is 2048 bits, indexShape // of Long species is S_MAX_BIT. and the lane count of Long // vector is 32. When converting Long species to int species, // indexShape is still S_MAX_BIT, but the lane count of int vector // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -3449,7 +3449,7 @@ public abstract class LongVector extends AbstractVector { // Index vector: vix[0:n] = k -> offset + indexMap[mapOffset + k] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For LongMaxVector, if vector length is non-power-of-two or + // For LongVectorMax, if vector length is non-power-of-two or // 2048 bits, indexShape of Long species is S_MAX_BIT. // Assume that vector length is 2048, then the lane count of Long // vector is 32. When converting Long species to int species, @@ -3457,7 +3457,7 @@ public abstract class LongVector extends AbstractVector { // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -3565,14 +3565,14 @@ public abstract class LongVector extends AbstractVector { // Index vector: vix[0:n] = i -> offset + indexMap[mo + i] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For LongMaxVector, if vector length is 2048 bits, indexShape + // For LongVectorMax, if vector length is 2048 bits, indexShape // of Long species is S_MAX_BIT. and the lane count of Long // vector is 32. When converting Long species to int species, // indexShape is still S_MAX_BIT, but the lane count of int vector // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -4010,13 +4010,13 @@ public abstract class LongVector extends AbstractVector { @Override @ForceInline public final LongVector zero() { - if ((Class) vectorType() == LongMaxVector.class) - return LongMaxVector.ZERO; + if ((Class) vectorType() == LongVectorMax.class) + return LongVectorMax.ZERO; switch (vectorBitSize()) { - case 64: return Long64Vector.ZERO; - case 128: return Long128Vector.ZERO; - case 256: return Long256Vector.ZERO; - case 512: return Long512Vector.ZERO; + case 64: return LongVector64.ZERO; + case 128: return LongVector128.ZERO; + case 256: return LongVector256.ZERO; + case 512: return LongVector512.ZERO; } throw new AssertionError(); } @@ -4024,13 +4024,13 @@ public abstract class LongVector extends AbstractVector { @Override @ForceInline public final LongVector iota() { - if ((Class) vectorType() == LongMaxVector.class) - return LongMaxVector.IOTA; + if ((Class) vectorType() == LongVectorMax.class) + return LongVectorMax.IOTA; switch (vectorBitSize()) { - case 64: return Long64Vector.IOTA; - case 128: return Long128Vector.IOTA; - case 256: return Long256Vector.IOTA; - case 512: return Long512Vector.IOTA; + case 64: return LongVector64.IOTA; + case 128: return LongVector128.IOTA; + case 256: return LongVector256.IOTA; + case 512: return LongVector512.IOTA; } throw new AssertionError(); } @@ -4039,13 +4039,13 @@ public abstract class LongVector extends AbstractVector { @Override @ForceInline public final VectorMask maskAll(boolean bit) { - if ((Class) vectorType() == LongMaxVector.class) - return LongMaxVector.LongMaxMask.maskAll(bit); + if ((Class) vectorType() == LongVectorMax.class) + return LongVectorMax.LongMaskMax.maskAll(bit); switch (vectorBitSize()) { - case 64: return Long64Vector.Long64Mask.maskAll(bit); - case 128: return Long128Vector.Long128Mask.maskAll(bit); - case 256: return Long256Vector.Long256Mask.maskAll(bit); - case 512: return Long512Vector.Long512Mask.maskAll(bit); + case 64: return LongVector64.LongMask64.maskAll(bit); + case 128: return LongVector128.LongMask128.maskAll(bit); + case 256: return LongVector256.LongMask256.maskAll(bit); + case 512: return LongVector512.LongMask512.maskAll(bit); } throw new AssertionError(); } @@ -4073,42 +4073,42 @@ public abstract class LongVector extends AbstractVector { /** Species representing {@link LongVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ public static final VectorSpecies SPECIES_64 = new LongSpecies(VectorShape.S_64_BIT, - Long64Vector.class, - Long64Vector.Long64Mask.class, - Long64Vector.Long64Shuffle.class, - Long64Vector::new); + LongVector64.class, + LongVector64.LongMask64.class, + LongVector64.LongShuffle64.class, + LongVector64::new); /** Species representing {@link LongVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ public static final VectorSpecies SPECIES_128 = new LongSpecies(VectorShape.S_128_BIT, - Long128Vector.class, - Long128Vector.Long128Mask.class, - Long128Vector.Long128Shuffle.class, - Long128Vector::new); + LongVector128.class, + LongVector128.LongMask128.class, + LongVector128.LongShuffle128.class, + LongVector128::new); /** Species representing {@link LongVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ public static final VectorSpecies SPECIES_256 = new LongSpecies(VectorShape.S_256_BIT, - Long256Vector.class, - Long256Vector.Long256Mask.class, - Long256Vector.Long256Shuffle.class, - Long256Vector::new); + LongVector256.class, + LongVector256.LongMask256.class, + LongVector256.LongShuffle256.class, + LongVector256::new); /** Species representing {@link LongVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ public static final VectorSpecies SPECIES_512 = new LongSpecies(VectorShape.S_512_BIT, - Long512Vector.class, - Long512Vector.Long512Mask.class, - Long512Vector.Long512Shuffle.class, - Long512Vector::new); + LongVector512.class, + LongVector512.LongMask512.class, + LongVector512.LongShuffle512.class, + LongVector512::new); /** Species representing {@link LongVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ public static final VectorSpecies SPECIES_MAX = new LongSpecies(VectorShape.S_Max_BIT, - LongMaxVector.class, - LongMaxVector.LongMaxMask.class, - LongMaxVector.LongMaxShuffle.class, - LongMaxVector::new); + LongVectorMax.class, + LongVectorMax.LongMaskMax.class, + LongVectorMax.LongShuffleMax.class, + LongVectorMax::new); /** * Preferred species for {@link LongVector}s. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long128Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector128.java similarity index 68% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long128Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector128.java index 01d721f64fc..b629c66df97 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long128Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector128.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Long128Vector extends LongVector { +final class LongVector128 extends LongVector { static final LongSpecies VSPECIES = (LongSpecies) LongVector.SPECIES_128; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Long128Vector.class; + static final Class VCLASS = LongVector128.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Long128Vector extends LongVector { static final Class ETYPE = long.class; // used by the JVM - Long128Vector(long[] v) { + LongVector128(long[] v) { super(v); } - // For compatibility as Long128Vector::new, + // For compatibility as LongVector128::new, // stored into species.vectorFactory. - Long128Vector(Object v) { + LongVector128(Object v) { this((long[]) v); } - static final Long128Vector ZERO = new Long128Vector(new long[VLENGTH]); - static final Long128Vector IOTA = new Long128Vector(VSPECIES.iotaArray()); + static final LongVector128 ZERO = new LongVector128(new long[VLENGTH]); + static final LongVector128 IOTA = new LongVector128(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,46 +130,46 @@ final class Long128Vector extends LongVector { @Override @ForceInline - public final Long128Vector broadcast(long e) { - return (Long128Vector) super.broadcastTemplate(e); // specialize + public final LongVector128 broadcast(long e) { + return (LongVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Long128Mask maskFromArray(boolean[] bits) { - return new Long128Mask(bits); + LongMask128 maskFromArray(boolean[] bits) { + return new LongMask128(bits); } @Override @ForceInline - Long128Shuffle iotaShuffle() { return Long128Shuffle.IOTA; } + LongShuffle128 iotaShuffle() { return LongShuffle128.IOTA; } @Override @ForceInline - Long128Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Long128Shuffle) iotaShuffleTemplate(start, step, wrap); + LongShuffle128 iotaShuffle(int start, int step, boolean wrap) { + return (LongShuffle128) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Long128Shuffle shuffleFromArray(int[] indices, int i) { return new Long128Shuffle(indices, i); } + LongShuffle128 shuffleFromArray(int[] indices, int i) { return new LongShuffle128(indices, i); } @Override @ForceInline - Long128Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Long128Shuffle(fn); } + LongShuffle128 shuffleFromOp(IntUnaryOperator fn) { return new LongShuffle128(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Long128Vector vectorFactory(long[] vec) { - return new Long128Vector(vec); + LongVector128 vectorFactory(long[] vec) { + return new LongVector128(vec); } @ForceInline final @Override - Byte128Vector asByteVectorRaw() { - return (Byte128Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector128 asByteVectorRaw() { + return (ByteVector128) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -182,31 +182,31 @@ final class Long128Vector extends LongVector { @ForceInline final @Override - Long128Vector uOp(FUnOp f) { - return (Long128Vector) super.uOpTemplate(f); // specialize + LongVector128 uOp(FUnOp f) { + return (LongVector128) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Long128Vector uOp(VectorMask m, FUnOp f) { - return (Long128Vector) - super.uOpTemplate((Long128Mask)m, f); // specialize + LongVector128 uOp(VectorMask m, FUnOp f) { + return (LongVector128) + super.uOpTemplate((LongMask128)m, f); // specialize } // Binary operator @ForceInline final @Override - Long128Vector bOp(Vector v, FBinOp f) { - return (Long128Vector) super.bOpTemplate((Long128Vector)v, f); // specialize + LongVector128 bOp(Vector v, FBinOp f) { + return (LongVector128) super.bOpTemplate((LongVector128)v, f); // specialize } @ForceInline final @Override - Long128Vector bOp(Vector v, + LongVector128 bOp(Vector v, VectorMask m, FBinOp f) { - return (Long128Vector) - super.bOpTemplate((Long128Vector)v, (Long128Mask)m, + return (LongVector128) + super.bOpTemplate((LongVector128)v, (LongMask128)m, f); // specialize } @@ -214,19 +214,19 @@ final class Long128Vector extends LongVector { @ForceInline final @Override - Long128Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Long128Vector) - super.tOpTemplate((Long128Vector)v1, (Long128Vector)v2, + LongVector128 tOp(Vector v1, Vector v2, FTriOp f) { + return (LongVector128) + super.tOpTemplate((LongVector128)v1, (LongVector128)v2, f); // specialize } @ForceInline final @Override - Long128Vector tOp(Vector v1, Vector v2, + LongVector128 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Long128Vector) - super.tOpTemplate((Long128Vector)v1, (Long128Vector)v2, - (Long128Mask)m, f); // specialize + return (LongVector128) + super.tOpTemplate((LongVector128)v1, (LongVector128)v2, + (LongMask128)m, f); // specialize } @ForceInline @@ -264,64 +264,64 @@ final class Long128Vector extends LongVector { @Override @ForceInline - public Long128Vector lanewise(Unary op) { - return (Long128Vector) super.lanewiseTemplate(op); // specialize + public LongVector128 lanewise(Unary op) { + return (LongVector128) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Long128Vector lanewise(Unary op, VectorMask m) { - return (Long128Vector) super.lanewiseTemplate(op, Long128Mask.class, (Long128Mask) m); // specialize + public LongVector128 lanewise(Unary op, VectorMask m) { + return (LongVector128) super.lanewiseTemplate(op, LongMask128.class, (LongMask128) m); // specialize } @Override @ForceInline - public Long128Vector lanewise(Binary op, Vector v) { - return (Long128Vector) super.lanewiseTemplate(op, v); // specialize + public LongVector128 lanewise(Binary op, Vector v) { + return (LongVector128) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Long128Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Long128Vector) super.lanewiseTemplate(op, Long128Mask.class, v, (Long128Mask) m); // specialize + public LongVector128 lanewise(Binary op, Vector v, VectorMask m) { + return (LongVector128) super.lanewiseTemplate(op, LongMask128.class, v, (LongMask128) m); // specialize } /*package-private*/ @Override - @ForceInline Long128Vector + @ForceInline LongVector128 lanewiseShift(VectorOperators.Binary op, int e) { - return (Long128Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (LongVector128) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Long128Vector + @ForceInline LongVector128 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Long128Vector) super.lanewiseShiftTemplate(op, Long128Mask.class, e, (Long128Mask) m); // specialize + return (LongVector128) super.lanewiseShiftTemplate(op, LongMask128.class, e, (LongMask128) m); // specialize } /*package-private*/ @Override @ForceInline public final - Long128Vector + LongVector128 lanewise(Ternary op, Vector v1, Vector v2) { - return (Long128Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (LongVector128) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Long128Vector + LongVector128 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Long128Vector) super.lanewiseTemplate(op, Long128Mask.class, v1, v2, (Long128Mask) m); // specialize + return (LongVector128) super.lanewiseTemplate(op, LongMask128.class, v1, v2, (LongMask128) m); // specialize } @Override @ForceInline public final - Long128Vector addIndex(int scale) { - return (Long128Vector) super.addIndexTemplate(scale); // specialize + LongVector128 addIndex(int scale) { + return (LongVector128) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -336,7 +336,7 @@ final class Long128Vector extends LongVector { @ForceInline public final long reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Long128Mask.class, (Long128Mask) m); // specialized + return super.reduceLanesTemplate(op, LongMask128.class, (LongMask128) m); // specialized } @Override @@ -349,7 +349,7 @@ final class Long128Vector extends LongVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Long128Mask.class, (Long128Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, LongMask128.class, (LongMask128) m); // specialized } @Override @@ -360,155 +360,155 @@ final class Long128Vector extends LongVector { @Override @ForceInline - public final Long128Shuffle toShuffle() { - return (Long128Shuffle) toShuffle(vspecies(), false); + public final LongShuffle128 toShuffle() { + return (LongShuffle128) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Long128Mask test(Test op) { - return super.testTemplate(Long128Mask.class, op); // specialize + public final LongMask128 test(Test op) { + return super.testTemplate(LongMask128.class, op); // specialize } @Override @ForceInline - public final Long128Mask test(Test op, VectorMask m) { - return super.testTemplate(Long128Mask.class, op, (Long128Mask) m); // specialize + public final LongMask128 test(Test op, VectorMask m) { + return super.testTemplate(LongMask128.class, op, (LongMask128) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Long128Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Long128Mask.class, op, v); // specialize + public final LongMask128 compare(Comparison op, Vector v) { + return super.compareTemplate(LongMask128.class, op, v); // specialize } @Override @ForceInline - public final Long128Mask compare(Comparison op, long s) { - return super.compareTemplate(Long128Mask.class, op, s); // specialize + public final LongMask128 compare(Comparison op, long s) { + return super.compareTemplate(LongMask128.class, op, s); // specialize } @Override @ForceInline - public final Long128Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Long128Mask.class, op, v, (Long128Mask) m); + public final LongMask128 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(LongMask128.class, op, v, (LongMask128) m); } @Override @ForceInline - public Long128Vector blend(Vector v, VectorMask m) { - return (Long128Vector) - super.blendTemplate(Long128Mask.class, - (Long128Vector) v, - (Long128Mask) m); // specialize + public LongVector128 blend(Vector v, VectorMask m) { + return (LongVector128) + super.blendTemplate(LongMask128.class, + (LongVector128) v, + (LongMask128) m); // specialize } @Override @ForceInline - public Long128Vector slice(int origin, Vector v) { - return (Long128Vector) super.sliceTemplate(origin, v); // specialize + public LongVector128 slice(int origin, Vector v) { + return (LongVector128) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Long128Vector slice(int origin) { - return (Long128Vector) super.sliceTemplate(origin); // specialize + public LongVector128 slice(int origin) { + return (LongVector128) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Long128Vector unslice(int origin, Vector w, int part) { - return (Long128Vector) super.unsliceTemplate(origin, w, part); // specialize + public LongVector128 unslice(int origin, Vector w, int part) { + return (LongVector128) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Long128Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Long128Vector) - super.unsliceTemplate(Long128Mask.class, + public LongVector128 unslice(int origin, Vector w, int part, VectorMask m) { + return (LongVector128) + super.unsliceTemplate(LongMask128.class, origin, w, part, - (Long128Mask) m); // specialize + (LongMask128) m); // specialize } @Override @ForceInline - public Long128Vector unslice(int origin) { - return (Long128Vector) super.unsliceTemplate(origin); // specialize + public LongVector128 unslice(int origin) { + return (LongVector128) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Long128Vector rearrange(VectorShuffle s) { - return (Long128Vector) - super.rearrangeTemplate(Long128Shuffle.class, - (Long128Shuffle) s); // specialize + public LongVector128 rearrange(VectorShuffle s) { + return (LongVector128) + super.rearrangeTemplate(LongShuffle128.class, + (LongShuffle128) s); // specialize } @Override @ForceInline - public Long128Vector rearrange(VectorShuffle shuffle, + public LongVector128 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Long128Vector) - super.rearrangeTemplate(Long128Shuffle.class, - Long128Mask.class, - (Long128Shuffle) shuffle, - (Long128Mask) m); // specialize + return (LongVector128) + super.rearrangeTemplate(LongShuffle128.class, + LongMask128.class, + (LongShuffle128) shuffle, + (LongMask128) m); // specialize } @Override @ForceInline - public Long128Vector rearrange(VectorShuffle s, + public LongVector128 rearrange(VectorShuffle s, Vector v) { - return (Long128Vector) - super.rearrangeTemplate(Long128Shuffle.class, - (Long128Shuffle) s, - (Long128Vector) v); // specialize + return (LongVector128) + super.rearrangeTemplate(LongShuffle128.class, + (LongShuffle128) s, + (LongVector128) v); // specialize } @Override @ForceInline - public Long128Vector compress(VectorMask m) { - return (Long128Vector) - super.compressTemplate(Long128Mask.class, - (Long128Mask) m); // specialize + public LongVector128 compress(VectorMask m) { + return (LongVector128) + super.compressTemplate(LongMask128.class, + (LongMask128) m); // specialize } @Override @ForceInline - public Long128Vector expand(VectorMask m) { - return (Long128Vector) - super.expandTemplate(Long128Mask.class, - (Long128Mask) m); // specialize + public LongVector128 expand(VectorMask m) { + return (LongVector128) + super.expandTemplate(LongMask128.class, + (LongMask128) m); // specialize } @Override @ForceInline - public Long128Vector selectFrom(Vector v) { - return (Long128Vector) - super.selectFromTemplate((Long128Vector) v); // specialize + public LongVector128 selectFrom(Vector v) { + return (LongVector128) + super.selectFromTemplate((LongVector128) v); // specialize } @Override @ForceInline - public Long128Vector selectFrom(Vector v, + public LongVector128 selectFrom(Vector v, VectorMask m) { - return (Long128Vector) - super.selectFromTemplate((Long128Vector) v, - Long128Mask.class, (Long128Mask) m); // specialize + return (LongVector128) + super.selectFromTemplate((LongVector128) v, + LongMask128.class, (LongMask128) m); // specialize } @Override @ForceInline - public Long128Vector selectFrom(Vector v1, + public LongVector128 selectFrom(Vector v1, Vector v2) { - return (Long128Vector) - super.selectFromTemplate((Long128Vector) v1, (Long128Vector) v2); // specialize + return (LongVector128) + super.selectFromTemplate((LongVector128) v1, (LongVector128) v2); // specialize } @ForceInline @@ -534,7 +534,7 @@ final class Long128Vector extends LongVector { @ForceInline @Override - public Long128Vector withLane(int i, long e) { + public LongVector128 withLane(int i, long e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -543,7 +543,7 @@ final class Long128Vector extends LongVector { } @ForceInline - public Long128Vector withLaneHelper(int i, long e) { + public LongVector128 withLaneHelper(int i, long e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -556,19 +556,19 @@ final class Long128Vector extends LongVector { // Mask - static final class Long128Mask extends AbstractMask { + static final class LongMask128 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Long128Mask(boolean[] bits) { + LongMask128(boolean[] bits) { this(bits, 0); } - Long128Mask(boolean[] bits, int offset) { + LongMask128(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Long128Mask(boolean val) { + LongMask128(boolean val) { super(prepare(val)); } @@ -601,31 +601,31 @@ final class Long128Vector extends LongVector { } @Override - Long128Mask uOp(MUnOp f) { + LongMask128 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Long128Mask(res); + return new LongMask128(res); } @Override - Long128Mask bOp(VectorMask m, MBinOp f) { + LongMask128 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Long128Mask)m).getBits(); + boolean[] mbits = ((LongMask128)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Long128Mask(res); + return new LongMask128(res); } @ForceInline @Override public final - Long128Vector toVector() { - return (Long128Vector) super.toVectorTemplate(); // specialize + LongVector128 toVector() { + return (LongVector128) super.toVectorTemplate(); // specialize } /** @@ -658,25 +658,25 @@ final class Long128Vector extends LongVector { @Override @ForceInline /*package-private*/ - Long128Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Long128Mask) VectorSupport.indexPartiallyInUpperRange( - Long128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Long128Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + LongMask128 indexPartiallyInUpperRange(long offset, long limit) { + return (LongMask128) VectorSupport.indexPartiallyInUpperRange( + LongMask128.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (LongMask128) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Long128Mask not() { + public LongMask128 not() { return xor(maskAll(true)); } @Override @ForceInline - public Long128Mask compress() { - return (Long128Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Long128Vector.class, Long128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public LongMask128 compress() { + return (LongMask128)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + LongVector128.class, LongMask128.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -685,30 +685,30 @@ final class Long128Vector extends LongVector { @Override @ForceInline - public Long128Mask and(VectorMask mask) { + public LongMask128 and(VectorMask mask) { Objects.requireNonNull(mask); - Long128Mask m = (Long128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Long128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask128 m = (LongMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, LongMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Long128Mask or(VectorMask mask) { + public LongMask128 or(VectorMask mask) { Objects.requireNonNull(mask); - Long128Mask m = (Long128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Long128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask128 m = (LongMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, LongMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Long128Mask xor(VectorMask mask) { + public LongMask128 xor(VectorMask mask) { Objects.requireNonNull(mask); - Long128Mask m = (Long128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Long128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask128 m = (LongMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, LongMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -718,21 +718,21 @@ final class Long128Vector extends LongVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Long128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, LongMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Long128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, LongMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Long128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, LongMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -742,7 +742,7 @@ final class Long128Vector extends LongVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Long128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, LongMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -752,7 +752,7 @@ final class Long128Vector extends LongVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Long128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(LongMask128.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -761,48 +761,48 @@ final class Long128Vector extends LongVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Long128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, LongMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Long128Mask)m).getBits())); + (m, __) -> anyTrueHelper(((LongMask128)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Long128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, LongMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Long128Mask)m).getBits())); + (m, __) -> allTrueHelper(((LongMask128)m).getBits())); } @ForceInline /*package-private*/ - static Long128Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Long128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static LongMask128 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(LongMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Long128Mask TRUE_MASK = new Long128Mask(true); - private static final Long128Mask FALSE_MASK = new Long128Mask(false); + private static final LongMask128 TRUE_MASK = new LongMask128(true); + private static final LongMask128 FALSE_MASK = new LongMask128(false); } // Shuffle - static final class Long128Shuffle extends AbstractShuffle { + static final class LongShuffle128 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Long128Shuffle(long[] indices) { + LongShuffle128(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Long128Shuffle(int[] indices, int i) { + LongShuffle128(int[] indices, int i) { this(prepare(indices, i)); } - Long128Shuffle(IntUnaryOperator fn) { + LongShuffle128(IntUnaryOperator fn) { this(prepare(fn)); } @@ -822,23 +822,23 @@ final class Long128Vector extends LongVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final Long128Shuffle IOTA = new Long128Shuffle(IDENTITY); + static final LongShuffle128 IOTA = new LongShuffle128(IDENTITY); @Override @ForceInline - public Long128Vector toVector() { + public LongVector128 toVector() { return toBitsVector(); } @Override @ForceInline - Long128Vector toBitsVector() { - return (Long128Vector) super.toBitsVectorTemplate(); + LongVector128 toBitsVector() { + return (LongVector128) super.toBitsVectorTemplate(); } @Override - Long128Vector toBitsVector0() { - return ((Long128Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVector128 toBitsVector0() { + return ((LongVector128) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -910,30 +910,30 @@ final class Long128Vector extends LongVector { @Override @ForceInline - public final Long128Mask laneIsValid() { - return (Long128Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final LongMask128 laneIsValid() { + return (LongMask128) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Long128Shuffle rearrange(VectorShuffle shuffle) { - Long128Shuffle concreteShuffle = (Long128Shuffle) shuffle; - return (Long128Shuffle) toBitsVector().rearrange(concreteShuffle) + public final LongShuffle128 rearrange(VectorShuffle shuffle) { + LongShuffle128 concreteShuffle = (LongShuffle128) shuffle; + return (LongShuffle128) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Long128Shuffle wrapIndexes() { - Long128Vector v = toBitsVector(); + public final LongShuffle128 wrapIndexes() { + LongVector128 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Long128Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVector128) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Long128Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVector128) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Long128Shuffle) v.toShuffle(vspecies(), false); + return (LongShuffle128) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -984,14 +984,14 @@ final class Long128Vector extends LongVector { @Override final LongVector fromArray0(long[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Long128Mask.class, a, offset, (Long128Mask) m, offsetInRange); // specialize + return super.fromArray0Template(LongMask128.class, a, offset, (LongMask128) m, offsetInRange); // specialize } @ForceInline @Override final LongVector fromArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Long128Mask.class, a, offset, indexMap, mapOffset, (Long128Mask) m); + return super.fromArray0Template(LongMask128.class, a, offset, indexMap, mapOffset, (LongMask128) m); } @@ -1007,7 +1007,7 @@ final class Long128Vector extends LongVector { @Override final LongVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Long128Mask.class, ms, offset, (Long128Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(LongMask128.class, ms, offset, (LongMask128) m, offsetInRange); // specialize } @ForceInline @@ -1021,14 +1021,14 @@ final class Long128Vector extends LongVector { @Override final void intoArray0(long[] a, int offset, VectorMask m) { - super.intoArray0Template(Long128Mask.class, a, offset, (Long128Mask) m); + super.intoArray0Template(LongMask128.class, a, offset, (LongMask128) m); } @ForceInline @Override final void intoArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Long128Mask.class, a, offset, indexMap, mapOffset, (Long128Mask) m); + super.intoArray0Template(LongMask128.class, a, offset, indexMap, mapOffset, (LongMask128) m); } @@ -1036,7 +1036,7 @@ final class Long128Vector extends LongVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Long128Mask.class, ms, offset, (Long128Mask) m); + super.intoMemorySegment0Template(LongMask128.class, ms, offset, (LongMask128) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long256Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector256.java similarity index 68% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long256Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector256.java index b3e7022771c..a1cfe199ed2 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long256Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector256.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Long256Vector extends LongVector { +final class LongVector256 extends LongVector { static final LongSpecies VSPECIES = (LongSpecies) LongVector.SPECIES_256; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Long256Vector.class; + static final Class VCLASS = LongVector256.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Long256Vector extends LongVector { static final Class ETYPE = long.class; // used by the JVM - Long256Vector(long[] v) { + LongVector256(long[] v) { super(v); } - // For compatibility as Long256Vector::new, + // For compatibility as LongVector256::new, // stored into species.vectorFactory. - Long256Vector(Object v) { + LongVector256(Object v) { this((long[]) v); } - static final Long256Vector ZERO = new Long256Vector(new long[VLENGTH]); - static final Long256Vector IOTA = new Long256Vector(VSPECIES.iotaArray()); + static final LongVector256 ZERO = new LongVector256(new long[VLENGTH]); + static final LongVector256 IOTA = new LongVector256(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,46 +130,46 @@ final class Long256Vector extends LongVector { @Override @ForceInline - public final Long256Vector broadcast(long e) { - return (Long256Vector) super.broadcastTemplate(e); // specialize + public final LongVector256 broadcast(long e) { + return (LongVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Long256Mask maskFromArray(boolean[] bits) { - return new Long256Mask(bits); + LongMask256 maskFromArray(boolean[] bits) { + return new LongMask256(bits); } @Override @ForceInline - Long256Shuffle iotaShuffle() { return Long256Shuffle.IOTA; } + LongShuffle256 iotaShuffle() { return LongShuffle256.IOTA; } @Override @ForceInline - Long256Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Long256Shuffle) iotaShuffleTemplate(start, step, wrap); + LongShuffle256 iotaShuffle(int start, int step, boolean wrap) { + return (LongShuffle256) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Long256Shuffle shuffleFromArray(int[] indices, int i) { return new Long256Shuffle(indices, i); } + LongShuffle256 shuffleFromArray(int[] indices, int i) { return new LongShuffle256(indices, i); } @Override @ForceInline - Long256Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Long256Shuffle(fn); } + LongShuffle256 shuffleFromOp(IntUnaryOperator fn) { return new LongShuffle256(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Long256Vector vectorFactory(long[] vec) { - return new Long256Vector(vec); + LongVector256 vectorFactory(long[] vec) { + return new LongVector256(vec); } @ForceInline final @Override - Byte256Vector asByteVectorRaw() { - return (Byte256Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector256 asByteVectorRaw() { + return (ByteVector256) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -182,31 +182,31 @@ final class Long256Vector extends LongVector { @ForceInline final @Override - Long256Vector uOp(FUnOp f) { - return (Long256Vector) super.uOpTemplate(f); // specialize + LongVector256 uOp(FUnOp f) { + return (LongVector256) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Long256Vector uOp(VectorMask m, FUnOp f) { - return (Long256Vector) - super.uOpTemplate((Long256Mask)m, f); // specialize + LongVector256 uOp(VectorMask m, FUnOp f) { + return (LongVector256) + super.uOpTemplate((LongMask256)m, f); // specialize } // Binary operator @ForceInline final @Override - Long256Vector bOp(Vector v, FBinOp f) { - return (Long256Vector) super.bOpTemplate((Long256Vector)v, f); // specialize + LongVector256 bOp(Vector v, FBinOp f) { + return (LongVector256) super.bOpTemplate((LongVector256)v, f); // specialize } @ForceInline final @Override - Long256Vector bOp(Vector v, + LongVector256 bOp(Vector v, VectorMask m, FBinOp f) { - return (Long256Vector) - super.bOpTemplate((Long256Vector)v, (Long256Mask)m, + return (LongVector256) + super.bOpTemplate((LongVector256)v, (LongMask256)m, f); // specialize } @@ -214,19 +214,19 @@ final class Long256Vector extends LongVector { @ForceInline final @Override - Long256Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Long256Vector) - super.tOpTemplate((Long256Vector)v1, (Long256Vector)v2, + LongVector256 tOp(Vector v1, Vector v2, FTriOp f) { + return (LongVector256) + super.tOpTemplate((LongVector256)v1, (LongVector256)v2, f); // specialize } @ForceInline final @Override - Long256Vector tOp(Vector v1, Vector v2, + LongVector256 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Long256Vector) - super.tOpTemplate((Long256Vector)v1, (Long256Vector)v2, - (Long256Mask)m, f); // specialize + return (LongVector256) + super.tOpTemplate((LongVector256)v1, (LongVector256)v2, + (LongMask256)m, f); // specialize } @ForceInline @@ -264,64 +264,64 @@ final class Long256Vector extends LongVector { @Override @ForceInline - public Long256Vector lanewise(Unary op) { - return (Long256Vector) super.lanewiseTemplate(op); // specialize + public LongVector256 lanewise(Unary op) { + return (LongVector256) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Long256Vector lanewise(Unary op, VectorMask m) { - return (Long256Vector) super.lanewiseTemplate(op, Long256Mask.class, (Long256Mask) m); // specialize + public LongVector256 lanewise(Unary op, VectorMask m) { + return (LongVector256) super.lanewiseTemplate(op, LongMask256.class, (LongMask256) m); // specialize } @Override @ForceInline - public Long256Vector lanewise(Binary op, Vector v) { - return (Long256Vector) super.lanewiseTemplate(op, v); // specialize + public LongVector256 lanewise(Binary op, Vector v) { + return (LongVector256) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Long256Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Long256Vector) super.lanewiseTemplate(op, Long256Mask.class, v, (Long256Mask) m); // specialize + public LongVector256 lanewise(Binary op, Vector v, VectorMask m) { + return (LongVector256) super.lanewiseTemplate(op, LongMask256.class, v, (LongMask256) m); // specialize } /*package-private*/ @Override - @ForceInline Long256Vector + @ForceInline LongVector256 lanewiseShift(VectorOperators.Binary op, int e) { - return (Long256Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (LongVector256) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Long256Vector + @ForceInline LongVector256 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Long256Vector) super.lanewiseShiftTemplate(op, Long256Mask.class, e, (Long256Mask) m); // specialize + return (LongVector256) super.lanewiseShiftTemplate(op, LongMask256.class, e, (LongMask256) m); // specialize } /*package-private*/ @Override @ForceInline public final - Long256Vector + LongVector256 lanewise(Ternary op, Vector v1, Vector v2) { - return (Long256Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (LongVector256) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Long256Vector + LongVector256 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Long256Vector) super.lanewiseTemplate(op, Long256Mask.class, v1, v2, (Long256Mask) m); // specialize + return (LongVector256) super.lanewiseTemplate(op, LongMask256.class, v1, v2, (LongMask256) m); // specialize } @Override @ForceInline public final - Long256Vector addIndex(int scale) { - return (Long256Vector) super.addIndexTemplate(scale); // specialize + LongVector256 addIndex(int scale) { + return (LongVector256) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -336,7 +336,7 @@ final class Long256Vector extends LongVector { @ForceInline public final long reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Long256Mask.class, (Long256Mask) m); // specialized + return super.reduceLanesTemplate(op, LongMask256.class, (LongMask256) m); // specialized } @Override @@ -349,7 +349,7 @@ final class Long256Vector extends LongVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Long256Mask.class, (Long256Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, LongMask256.class, (LongMask256) m); // specialized } @Override @@ -360,155 +360,155 @@ final class Long256Vector extends LongVector { @Override @ForceInline - public final Long256Shuffle toShuffle() { - return (Long256Shuffle) toShuffle(vspecies(), false); + public final LongShuffle256 toShuffle() { + return (LongShuffle256) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Long256Mask test(Test op) { - return super.testTemplate(Long256Mask.class, op); // specialize + public final LongMask256 test(Test op) { + return super.testTemplate(LongMask256.class, op); // specialize } @Override @ForceInline - public final Long256Mask test(Test op, VectorMask m) { - return super.testTemplate(Long256Mask.class, op, (Long256Mask) m); // specialize + public final LongMask256 test(Test op, VectorMask m) { + return super.testTemplate(LongMask256.class, op, (LongMask256) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Long256Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Long256Mask.class, op, v); // specialize + public final LongMask256 compare(Comparison op, Vector v) { + return super.compareTemplate(LongMask256.class, op, v); // specialize } @Override @ForceInline - public final Long256Mask compare(Comparison op, long s) { - return super.compareTemplate(Long256Mask.class, op, s); // specialize + public final LongMask256 compare(Comparison op, long s) { + return super.compareTemplate(LongMask256.class, op, s); // specialize } @Override @ForceInline - public final Long256Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Long256Mask.class, op, v, (Long256Mask) m); + public final LongMask256 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(LongMask256.class, op, v, (LongMask256) m); } @Override @ForceInline - public Long256Vector blend(Vector v, VectorMask m) { - return (Long256Vector) - super.blendTemplate(Long256Mask.class, - (Long256Vector) v, - (Long256Mask) m); // specialize + public LongVector256 blend(Vector v, VectorMask m) { + return (LongVector256) + super.blendTemplate(LongMask256.class, + (LongVector256) v, + (LongMask256) m); // specialize } @Override @ForceInline - public Long256Vector slice(int origin, Vector v) { - return (Long256Vector) super.sliceTemplate(origin, v); // specialize + public LongVector256 slice(int origin, Vector v) { + return (LongVector256) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Long256Vector slice(int origin) { - return (Long256Vector) super.sliceTemplate(origin); // specialize + public LongVector256 slice(int origin) { + return (LongVector256) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Long256Vector unslice(int origin, Vector w, int part) { - return (Long256Vector) super.unsliceTemplate(origin, w, part); // specialize + public LongVector256 unslice(int origin, Vector w, int part) { + return (LongVector256) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Long256Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Long256Vector) - super.unsliceTemplate(Long256Mask.class, + public LongVector256 unslice(int origin, Vector w, int part, VectorMask m) { + return (LongVector256) + super.unsliceTemplate(LongMask256.class, origin, w, part, - (Long256Mask) m); // specialize + (LongMask256) m); // specialize } @Override @ForceInline - public Long256Vector unslice(int origin) { - return (Long256Vector) super.unsliceTemplate(origin); // specialize + public LongVector256 unslice(int origin) { + return (LongVector256) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Long256Vector rearrange(VectorShuffle s) { - return (Long256Vector) - super.rearrangeTemplate(Long256Shuffle.class, - (Long256Shuffle) s); // specialize + public LongVector256 rearrange(VectorShuffle s) { + return (LongVector256) + super.rearrangeTemplate(LongShuffle256.class, + (LongShuffle256) s); // specialize } @Override @ForceInline - public Long256Vector rearrange(VectorShuffle shuffle, + public LongVector256 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Long256Vector) - super.rearrangeTemplate(Long256Shuffle.class, - Long256Mask.class, - (Long256Shuffle) shuffle, - (Long256Mask) m); // specialize + return (LongVector256) + super.rearrangeTemplate(LongShuffle256.class, + LongMask256.class, + (LongShuffle256) shuffle, + (LongMask256) m); // specialize } @Override @ForceInline - public Long256Vector rearrange(VectorShuffle s, + public LongVector256 rearrange(VectorShuffle s, Vector v) { - return (Long256Vector) - super.rearrangeTemplate(Long256Shuffle.class, - (Long256Shuffle) s, - (Long256Vector) v); // specialize + return (LongVector256) + super.rearrangeTemplate(LongShuffle256.class, + (LongShuffle256) s, + (LongVector256) v); // specialize } @Override @ForceInline - public Long256Vector compress(VectorMask m) { - return (Long256Vector) - super.compressTemplate(Long256Mask.class, - (Long256Mask) m); // specialize + public LongVector256 compress(VectorMask m) { + return (LongVector256) + super.compressTemplate(LongMask256.class, + (LongMask256) m); // specialize } @Override @ForceInline - public Long256Vector expand(VectorMask m) { - return (Long256Vector) - super.expandTemplate(Long256Mask.class, - (Long256Mask) m); // specialize + public LongVector256 expand(VectorMask m) { + return (LongVector256) + super.expandTemplate(LongMask256.class, + (LongMask256) m); // specialize } @Override @ForceInline - public Long256Vector selectFrom(Vector v) { - return (Long256Vector) - super.selectFromTemplate((Long256Vector) v); // specialize + public LongVector256 selectFrom(Vector v) { + return (LongVector256) + super.selectFromTemplate((LongVector256) v); // specialize } @Override @ForceInline - public Long256Vector selectFrom(Vector v, + public LongVector256 selectFrom(Vector v, VectorMask m) { - return (Long256Vector) - super.selectFromTemplate((Long256Vector) v, - Long256Mask.class, (Long256Mask) m); // specialize + return (LongVector256) + super.selectFromTemplate((LongVector256) v, + LongMask256.class, (LongMask256) m); // specialize } @Override @ForceInline - public Long256Vector selectFrom(Vector v1, + public LongVector256 selectFrom(Vector v1, Vector v2) { - return (Long256Vector) - super.selectFromTemplate((Long256Vector) v1, (Long256Vector) v2); // specialize + return (LongVector256) + super.selectFromTemplate((LongVector256) v1, (LongVector256) v2); // specialize } @ForceInline @@ -536,7 +536,7 @@ final class Long256Vector extends LongVector { @ForceInline @Override - public Long256Vector withLane(int i, long e) { + public LongVector256 withLane(int i, long e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -547,7 +547,7 @@ final class Long256Vector extends LongVector { } @ForceInline - public Long256Vector withLaneHelper(int i, long e) { + public LongVector256 withLaneHelper(int i, long e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -560,19 +560,19 @@ final class Long256Vector extends LongVector { // Mask - static final class Long256Mask extends AbstractMask { + static final class LongMask256 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Long256Mask(boolean[] bits) { + LongMask256(boolean[] bits) { this(bits, 0); } - Long256Mask(boolean[] bits, int offset) { + LongMask256(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Long256Mask(boolean val) { + LongMask256(boolean val) { super(prepare(val)); } @@ -605,31 +605,31 @@ final class Long256Vector extends LongVector { } @Override - Long256Mask uOp(MUnOp f) { + LongMask256 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Long256Mask(res); + return new LongMask256(res); } @Override - Long256Mask bOp(VectorMask m, MBinOp f) { + LongMask256 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Long256Mask)m).getBits(); + boolean[] mbits = ((LongMask256)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Long256Mask(res); + return new LongMask256(res); } @ForceInline @Override public final - Long256Vector toVector() { - return (Long256Vector) super.toVectorTemplate(); // specialize + LongVector256 toVector() { + return (LongVector256) super.toVectorTemplate(); // specialize } /** @@ -662,25 +662,25 @@ final class Long256Vector extends LongVector { @Override @ForceInline /*package-private*/ - Long256Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Long256Mask) VectorSupport.indexPartiallyInUpperRange( - Long256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Long256Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + LongMask256 indexPartiallyInUpperRange(long offset, long limit) { + return (LongMask256) VectorSupport.indexPartiallyInUpperRange( + LongMask256.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (LongMask256) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Long256Mask not() { + public LongMask256 not() { return xor(maskAll(true)); } @Override @ForceInline - public Long256Mask compress() { - return (Long256Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Long256Vector.class, Long256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public LongMask256 compress() { + return (LongMask256)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + LongVector256.class, LongMask256.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -689,30 +689,30 @@ final class Long256Vector extends LongVector { @Override @ForceInline - public Long256Mask and(VectorMask mask) { + public LongMask256 and(VectorMask mask) { Objects.requireNonNull(mask); - Long256Mask m = (Long256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Long256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask256 m = (LongMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, LongMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Long256Mask or(VectorMask mask) { + public LongMask256 or(VectorMask mask) { Objects.requireNonNull(mask); - Long256Mask m = (Long256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Long256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask256 m = (LongMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, LongMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Long256Mask xor(VectorMask mask) { + public LongMask256 xor(VectorMask mask) { Objects.requireNonNull(mask); - Long256Mask m = (Long256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Long256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask256 m = (LongMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, LongMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -722,21 +722,21 @@ final class Long256Vector extends LongVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Long256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, LongMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Long256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, LongMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Long256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, LongMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -746,7 +746,7 @@ final class Long256Vector extends LongVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Long256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, LongMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -756,7 +756,7 @@ final class Long256Vector extends LongVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Long256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(LongMask256.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -765,48 +765,48 @@ final class Long256Vector extends LongVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Long256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, LongMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Long256Mask)m).getBits())); + (m, __) -> anyTrueHelper(((LongMask256)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Long256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, LongMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Long256Mask)m).getBits())); + (m, __) -> allTrueHelper(((LongMask256)m).getBits())); } @ForceInline /*package-private*/ - static Long256Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Long256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static LongMask256 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(LongMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Long256Mask TRUE_MASK = new Long256Mask(true); - private static final Long256Mask FALSE_MASK = new Long256Mask(false); + private static final LongMask256 TRUE_MASK = new LongMask256(true); + private static final LongMask256 FALSE_MASK = new LongMask256(false); } // Shuffle - static final class Long256Shuffle extends AbstractShuffle { + static final class LongShuffle256 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Long256Shuffle(long[] indices) { + LongShuffle256(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Long256Shuffle(int[] indices, int i) { + LongShuffle256(int[] indices, int i) { this(prepare(indices, i)); } - Long256Shuffle(IntUnaryOperator fn) { + LongShuffle256(IntUnaryOperator fn) { this(prepare(fn)); } @@ -826,23 +826,23 @@ final class Long256Vector extends LongVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final Long256Shuffle IOTA = new Long256Shuffle(IDENTITY); + static final LongShuffle256 IOTA = new LongShuffle256(IDENTITY); @Override @ForceInline - public Long256Vector toVector() { + public LongVector256 toVector() { return toBitsVector(); } @Override @ForceInline - Long256Vector toBitsVector() { - return (Long256Vector) super.toBitsVectorTemplate(); + LongVector256 toBitsVector() { + return (LongVector256) super.toBitsVectorTemplate(); } @Override - Long256Vector toBitsVector0() { - return ((Long256Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVector256 toBitsVector0() { + return ((LongVector256) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -914,30 +914,30 @@ final class Long256Vector extends LongVector { @Override @ForceInline - public final Long256Mask laneIsValid() { - return (Long256Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final LongMask256 laneIsValid() { + return (LongMask256) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Long256Shuffle rearrange(VectorShuffle shuffle) { - Long256Shuffle concreteShuffle = (Long256Shuffle) shuffle; - return (Long256Shuffle) toBitsVector().rearrange(concreteShuffle) + public final LongShuffle256 rearrange(VectorShuffle shuffle) { + LongShuffle256 concreteShuffle = (LongShuffle256) shuffle; + return (LongShuffle256) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Long256Shuffle wrapIndexes() { - Long256Vector v = toBitsVector(); + public final LongShuffle256 wrapIndexes() { + LongVector256 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Long256Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVector256) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Long256Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVector256) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Long256Shuffle) v.toShuffle(vspecies(), false); + return (LongShuffle256) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -988,14 +988,14 @@ final class Long256Vector extends LongVector { @Override final LongVector fromArray0(long[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Long256Mask.class, a, offset, (Long256Mask) m, offsetInRange); // specialize + return super.fromArray0Template(LongMask256.class, a, offset, (LongMask256) m, offsetInRange); // specialize } @ForceInline @Override final LongVector fromArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Long256Mask.class, a, offset, indexMap, mapOffset, (Long256Mask) m); + return super.fromArray0Template(LongMask256.class, a, offset, indexMap, mapOffset, (LongMask256) m); } @@ -1011,7 +1011,7 @@ final class Long256Vector extends LongVector { @Override final LongVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Long256Mask.class, ms, offset, (Long256Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(LongMask256.class, ms, offset, (LongMask256) m, offsetInRange); // specialize } @ForceInline @@ -1025,14 +1025,14 @@ final class Long256Vector extends LongVector { @Override final void intoArray0(long[] a, int offset, VectorMask m) { - super.intoArray0Template(Long256Mask.class, a, offset, (Long256Mask) m); + super.intoArray0Template(LongMask256.class, a, offset, (LongMask256) m); } @ForceInline @Override final void intoArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Long256Mask.class, a, offset, indexMap, mapOffset, (Long256Mask) m); + super.intoArray0Template(LongMask256.class, a, offset, indexMap, mapOffset, (LongMask256) m); } @@ -1040,7 +1040,7 @@ final class Long256Vector extends LongVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Long256Mask.class, ms, offset, (Long256Mask) m); + super.intoMemorySegment0Template(LongMask256.class, ms, offset, (LongMask256) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long512Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector512.java similarity index 68% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long512Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector512.java index 169664bc242..3036ed8c06e 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long512Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector512.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Long512Vector extends LongVector { +final class LongVector512 extends LongVector { static final LongSpecies VSPECIES = (LongSpecies) LongVector.SPECIES_512; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Long512Vector.class; + static final Class VCLASS = LongVector512.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Long512Vector extends LongVector { static final Class ETYPE = long.class; // used by the JVM - Long512Vector(long[] v) { + LongVector512(long[] v) { super(v); } - // For compatibility as Long512Vector::new, + // For compatibility as LongVector512::new, // stored into species.vectorFactory. - Long512Vector(Object v) { + LongVector512(Object v) { this((long[]) v); } - static final Long512Vector ZERO = new Long512Vector(new long[VLENGTH]); - static final Long512Vector IOTA = new Long512Vector(VSPECIES.iotaArray()); + static final LongVector512 ZERO = new LongVector512(new long[VLENGTH]); + static final LongVector512 IOTA = new LongVector512(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,46 +130,46 @@ final class Long512Vector extends LongVector { @Override @ForceInline - public final Long512Vector broadcast(long e) { - return (Long512Vector) super.broadcastTemplate(e); // specialize + public final LongVector512 broadcast(long e) { + return (LongVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Long512Mask maskFromArray(boolean[] bits) { - return new Long512Mask(bits); + LongMask512 maskFromArray(boolean[] bits) { + return new LongMask512(bits); } @Override @ForceInline - Long512Shuffle iotaShuffle() { return Long512Shuffle.IOTA; } + LongShuffle512 iotaShuffle() { return LongShuffle512.IOTA; } @Override @ForceInline - Long512Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Long512Shuffle) iotaShuffleTemplate(start, step, wrap); + LongShuffle512 iotaShuffle(int start, int step, boolean wrap) { + return (LongShuffle512) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Long512Shuffle shuffleFromArray(int[] indices, int i) { return new Long512Shuffle(indices, i); } + LongShuffle512 shuffleFromArray(int[] indices, int i) { return new LongShuffle512(indices, i); } @Override @ForceInline - Long512Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Long512Shuffle(fn); } + LongShuffle512 shuffleFromOp(IntUnaryOperator fn) { return new LongShuffle512(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Long512Vector vectorFactory(long[] vec) { - return new Long512Vector(vec); + LongVector512 vectorFactory(long[] vec) { + return new LongVector512(vec); } @ForceInline final @Override - Byte512Vector asByteVectorRaw() { - return (Byte512Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector512 asByteVectorRaw() { + return (ByteVector512) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -182,31 +182,31 @@ final class Long512Vector extends LongVector { @ForceInline final @Override - Long512Vector uOp(FUnOp f) { - return (Long512Vector) super.uOpTemplate(f); // specialize + LongVector512 uOp(FUnOp f) { + return (LongVector512) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Long512Vector uOp(VectorMask m, FUnOp f) { - return (Long512Vector) - super.uOpTemplate((Long512Mask)m, f); // specialize + LongVector512 uOp(VectorMask m, FUnOp f) { + return (LongVector512) + super.uOpTemplate((LongMask512)m, f); // specialize } // Binary operator @ForceInline final @Override - Long512Vector bOp(Vector v, FBinOp f) { - return (Long512Vector) super.bOpTemplate((Long512Vector)v, f); // specialize + LongVector512 bOp(Vector v, FBinOp f) { + return (LongVector512) super.bOpTemplate((LongVector512)v, f); // specialize } @ForceInline final @Override - Long512Vector bOp(Vector v, + LongVector512 bOp(Vector v, VectorMask m, FBinOp f) { - return (Long512Vector) - super.bOpTemplate((Long512Vector)v, (Long512Mask)m, + return (LongVector512) + super.bOpTemplate((LongVector512)v, (LongMask512)m, f); // specialize } @@ -214,19 +214,19 @@ final class Long512Vector extends LongVector { @ForceInline final @Override - Long512Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Long512Vector) - super.tOpTemplate((Long512Vector)v1, (Long512Vector)v2, + LongVector512 tOp(Vector v1, Vector v2, FTriOp f) { + return (LongVector512) + super.tOpTemplate((LongVector512)v1, (LongVector512)v2, f); // specialize } @ForceInline final @Override - Long512Vector tOp(Vector v1, Vector v2, + LongVector512 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Long512Vector) - super.tOpTemplate((Long512Vector)v1, (Long512Vector)v2, - (Long512Mask)m, f); // specialize + return (LongVector512) + super.tOpTemplate((LongVector512)v1, (LongVector512)v2, + (LongMask512)m, f); // specialize } @ForceInline @@ -264,64 +264,64 @@ final class Long512Vector extends LongVector { @Override @ForceInline - public Long512Vector lanewise(Unary op) { - return (Long512Vector) super.lanewiseTemplate(op); // specialize + public LongVector512 lanewise(Unary op) { + return (LongVector512) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Long512Vector lanewise(Unary op, VectorMask m) { - return (Long512Vector) super.lanewiseTemplate(op, Long512Mask.class, (Long512Mask) m); // specialize + public LongVector512 lanewise(Unary op, VectorMask m) { + return (LongVector512) super.lanewiseTemplate(op, LongMask512.class, (LongMask512) m); // specialize } @Override @ForceInline - public Long512Vector lanewise(Binary op, Vector v) { - return (Long512Vector) super.lanewiseTemplate(op, v); // specialize + public LongVector512 lanewise(Binary op, Vector v) { + return (LongVector512) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Long512Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Long512Vector) super.lanewiseTemplate(op, Long512Mask.class, v, (Long512Mask) m); // specialize + public LongVector512 lanewise(Binary op, Vector v, VectorMask m) { + return (LongVector512) super.lanewiseTemplate(op, LongMask512.class, v, (LongMask512) m); // specialize } /*package-private*/ @Override - @ForceInline Long512Vector + @ForceInline LongVector512 lanewiseShift(VectorOperators.Binary op, int e) { - return (Long512Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (LongVector512) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Long512Vector + @ForceInline LongVector512 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Long512Vector) super.lanewiseShiftTemplate(op, Long512Mask.class, e, (Long512Mask) m); // specialize + return (LongVector512) super.lanewiseShiftTemplate(op, LongMask512.class, e, (LongMask512) m); // specialize } /*package-private*/ @Override @ForceInline public final - Long512Vector + LongVector512 lanewise(Ternary op, Vector v1, Vector v2) { - return (Long512Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (LongVector512) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Long512Vector + LongVector512 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Long512Vector) super.lanewiseTemplate(op, Long512Mask.class, v1, v2, (Long512Mask) m); // specialize + return (LongVector512) super.lanewiseTemplate(op, LongMask512.class, v1, v2, (LongMask512) m); // specialize } @Override @ForceInline public final - Long512Vector addIndex(int scale) { - return (Long512Vector) super.addIndexTemplate(scale); // specialize + LongVector512 addIndex(int scale) { + return (LongVector512) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -336,7 +336,7 @@ final class Long512Vector extends LongVector { @ForceInline public final long reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Long512Mask.class, (Long512Mask) m); // specialized + return super.reduceLanesTemplate(op, LongMask512.class, (LongMask512) m); // specialized } @Override @@ -349,7 +349,7 @@ final class Long512Vector extends LongVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Long512Mask.class, (Long512Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, LongMask512.class, (LongMask512) m); // specialized } @Override @@ -360,155 +360,155 @@ final class Long512Vector extends LongVector { @Override @ForceInline - public final Long512Shuffle toShuffle() { - return (Long512Shuffle) toShuffle(vspecies(), false); + public final LongShuffle512 toShuffle() { + return (LongShuffle512) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Long512Mask test(Test op) { - return super.testTemplate(Long512Mask.class, op); // specialize + public final LongMask512 test(Test op) { + return super.testTemplate(LongMask512.class, op); // specialize } @Override @ForceInline - public final Long512Mask test(Test op, VectorMask m) { - return super.testTemplate(Long512Mask.class, op, (Long512Mask) m); // specialize + public final LongMask512 test(Test op, VectorMask m) { + return super.testTemplate(LongMask512.class, op, (LongMask512) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Long512Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Long512Mask.class, op, v); // specialize + public final LongMask512 compare(Comparison op, Vector v) { + return super.compareTemplate(LongMask512.class, op, v); // specialize } @Override @ForceInline - public final Long512Mask compare(Comparison op, long s) { - return super.compareTemplate(Long512Mask.class, op, s); // specialize + public final LongMask512 compare(Comparison op, long s) { + return super.compareTemplate(LongMask512.class, op, s); // specialize } @Override @ForceInline - public final Long512Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Long512Mask.class, op, v, (Long512Mask) m); + public final LongMask512 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(LongMask512.class, op, v, (LongMask512) m); } @Override @ForceInline - public Long512Vector blend(Vector v, VectorMask m) { - return (Long512Vector) - super.blendTemplate(Long512Mask.class, - (Long512Vector) v, - (Long512Mask) m); // specialize + public LongVector512 blend(Vector v, VectorMask m) { + return (LongVector512) + super.blendTemplate(LongMask512.class, + (LongVector512) v, + (LongMask512) m); // specialize } @Override @ForceInline - public Long512Vector slice(int origin, Vector v) { - return (Long512Vector) super.sliceTemplate(origin, v); // specialize + public LongVector512 slice(int origin, Vector v) { + return (LongVector512) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Long512Vector slice(int origin) { - return (Long512Vector) super.sliceTemplate(origin); // specialize + public LongVector512 slice(int origin) { + return (LongVector512) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Long512Vector unslice(int origin, Vector w, int part) { - return (Long512Vector) super.unsliceTemplate(origin, w, part); // specialize + public LongVector512 unslice(int origin, Vector w, int part) { + return (LongVector512) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Long512Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Long512Vector) - super.unsliceTemplate(Long512Mask.class, + public LongVector512 unslice(int origin, Vector w, int part, VectorMask m) { + return (LongVector512) + super.unsliceTemplate(LongMask512.class, origin, w, part, - (Long512Mask) m); // specialize + (LongMask512) m); // specialize } @Override @ForceInline - public Long512Vector unslice(int origin) { - return (Long512Vector) super.unsliceTemplate(origin); // specialize + public LongVector512 unslice(int origin) { + return (LongVector512) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Long512Vector rearrange(VectorShuffle s) { - return (Long512Vector) - super.rearrangeTemplate(Long512Shuffle.class, - (Long512Shuffle) s); // specialize + public LongVector512 rearrange(VectorShuffle s) { + return (LongVector512) + super.rearrangeTemplate(LongShuffle512.class, + (LongShuffle512) s); // specialize } @Override @ForceInline - public Long512Vector rearrange(VectorShuffle shuffle, + public LongVector512 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Long512Vector) - super.rearrangeTemplate(Long512Shuffle.class, - Long512Mask.class, - (Long512Shuffle) shuffle, - (Long512Mask) m); // specialize + return (LongVector512) + super.rearrangeTemplate(LongShuffle512.class, + LongMask512.class, + (LongShuffle512) shuffle, + (LongMask512) m); // specialize } @Override @ForceInline - public Long512Vector rearrange(VectorShuffle s, + public LongVector512 rearrange(VectorShuffle s, Vector v) { - return (Long512Vector) - super.rearrangeTemplate(Long512Shuffle.class, - (Long512Shuffle) s, - (Long512Vector) v); // specialize + return (LongVector512) + super.rearrangeTemplate(LongShuffle512.class, + (LongShuffle512) s, + (LongVector512) v); // specialize } @Override @ForceInline - public Long512Vector compress(VectorMask m) { - return (Long512Vector) - super.compressTemplate(Long512Mask.class, - (Long512Mask) m); // specialize + public LongVector512 compress(VectorMask m) { + return (LongVector512) + super.compressTemplate(LongMask512.class, + (LongMask512) m); // specialize } @Override @ForceInline - public Long512Vector expand(VectorMask m) { - return (Long512Vector) - super.expandTemplate(Long512Mask.class, - (Long512Mask) m); // specialize + public LongVector512 expand(VectorMask m) { + return (LongVector512) + super.expandTemplate(LongMask512.class, + (LongMask512) m); // specialize } @Override @ForceInline - public Long512Vector selectFrom(Vector v) { - return (Long512Vector) - super.selectFromTemplate((Long512Vector) v); // specialize + public LongVector512 selectFrom(Vector v) { + return (LongVector512) + super.selectFromTemplate((LongVector512) v); // specialize } @Override @ForceInline - public Long512Vector selectFrom(Vector v, + public LongVector512 selectFrom(Vector v, VectorMask m) { - return (Long512Vector) - super.selectFromTemplate((Long512Vector) v, - Long512Mask.class, (Long512Mask) m); // specialize + return (LongVector512) + super.selectFromTemplate((LongVector512) v, + LongMask512.class, (LongMask512) m); // specialize } @Override @ForceInline - public Long512Vector selectFrom(Vector v1, + public LongVector512 selectFrom(Vector v1, Vector v2) { - return (Long512Vector) - super.selectFromTemplate((Long512Vector) v1, (Long512Vector) v2); // specialize + return (LongVector512) + super.selectFromTemplate((LongVector512) v1, (LongVector512) v2); // specialize } @ForceInline @@ -540,7 +540,7 @@ final class Long512Vector extends LongVector { @ForceInline @Override - public Long512Vector withLane(int i, long e) { + public LongVector512 withLane(int i, long e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -555,7 +555,7 @@ final class Long512Vector extends LongVector { } @ForceInline - public Long512Vector withLaneHelper(int i, long e) { + public LongVector512 withLaneHelper(int i, long e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -568,19 +568,19 @@ final class Long512Vector extends LongVector { // Mask - static final class Long512Mask extends AbstractMask { + static final class LongMask512 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Long512Mask(boolean[] bits) { + LongMask512(boolean[] bits) { this(bits, 0); } - Long512Mask(boolean[] bits, int offset) { + LongMask512(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Long512Mask(boolean val) { + LongMask512(boolean val) { super(prepare(val)); } @@ -613,31 +613,31 @@ final class Long512Vector extends LongVector { } @Override - Long512Mask uOp(MUnOp f) { + LongMask512 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Long512Mask(res); + return new LongMask512(res); } @Override - Long512Mask bOp(VectorMask m, MBinOp f) { + LongMask512 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Long512Mask)m).getBits(); + boolean[] mbits = ((LongMask512)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Long512Mask(res); + return new LongMask512(res); } @ForceInline @Override public final - Long512Vector toVector() { - return (Long512Vector) super.toVectorTemplate(); // specialize + LongVector512 toVector() { + return (LongVector512) super.toVectorTemplate(); // specialize } /** @@ -670,25 +670,25 @@ final class Long512Vector extends LongVector { @Override @ForceInline /*package-private*/ - Long512Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Long512Mask) VectorSupport.indexPartiallyInUpperRange( - Long512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Long512Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + LongMask512 indexPartiallyInUpperRange(long offset, long limit) { + return (LongMask512) VectorSupport.indexPartiallyInUpperRange( + LongMask512.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (LongMask512) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Long512Mask not() { + public LongMask512 not() { return xor(maskAll(true)); } @Override @ForceInline - public Long512Mask compress() { - return (Long512Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Long512Vector.class, Long512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public LongMask512 compress() { + return (LongMask512)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + LongVector512.class, LongMask512.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -697,30 +697,30 @@ final class Long512Vector extends LongVector { @Override @ForceInline - public Long512Mask and(VectorMask mask) { + public LongMask512 and(VectorMask mask) { Objects.requireNonNull(mask); - Long512Mask m = (Long512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Long512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask512 m = (LongMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, LongMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Long512Mask or(VectorMask mask) { + public LongMask512 or(VectorMask mask) { Objects.requireNonNull(mask); - Long512Mask m = (Long512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Long512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask512 m = (LongMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, LongMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Long512Mask xor(VectorMask mask) { + public LongMask512 xor(VectorMask mask) { Objects.requireNonNull(mask); - Long512Mask m = (Long512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Long512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask512 m = (LongMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, LongMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -730,21 +730,21 @@ final class Long512Vector extends LongVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Long512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, LongMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Long512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, LongMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Long512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, LongMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -754,7 +754,7 @@ final class Long512Vector extends LongVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Long512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, LongMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -764,7 +764,7 @@ final class Long512Vector extends LongVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Long512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(LongMask512.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -773,48 +773,48 @@ final class Long512Vector extends LongVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Long512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, LongMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Long512Mask)m).getBits())); + (m, __) -> anyTrueHelper(((LongMask512)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Long512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, LongMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Long512Mask)m).getBits())); + (m, __) -> allTrueHelper(((LongMask512)m).getBits())); } @ForceInline /*package-private*/ - static Long512Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Long512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static LongMask512 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(LongMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Long512Mask TRUE_MASK = new Long512Mask(true); - private static final Long512Mask FALSE_MASK = new Long512Mask(false); + private static final LongMask512 TRUE_MASK = new LongMask512(true); + private static final LongMask512 FALSE_MASK = new LongMask512(false); } // Shuffle - static final class Long512Shuffle extends AbstractShuffle { + static final class LongShuffle512 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Long512Shuffle(long[] indices) { + LongShuffle512(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Long512Shuffle(int[] indices, int i) { + LongShuffle512(int[] indices, int i) { this(prepare(indices, i)); } - Long512Shuffle(IntUnaryOperator fn) { + LongShuffle512(IntUnaryOperator fn) { this(prepare(fn)); } @@ -834,23 +834,23 @@ final class Long512Vector extends LongVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final Long512Shuffle IOTA = new Long512Shuffle(IDENTITY); + static final LongShuffle512 IOTA = new LongShuffle512(IDENTITY); @Override @ForceInline - public Long512Vector toVector() { + public LongVector512 toVector() { return toBitsVector(); } @Override @ForceInline - Long512Vector toBitsVector() { - return (Long512Vector) super.toBitsVectorTemplate(); + LongVector512 toBitsVector() { + return (LongVector512) super.toBitsVectorTemplate(); } @Override - Long512Vector toBitsVector0() { - return ((Long512Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVector512 toBitsVector0() { + return ((LongVector512) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -922,30 +922,30 @@ final class Long512Vector extends LongVector { @Override @ForceInline - public final Long512Mask laneIsValid() { - return (Long512Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final LongMask512 laneIsValid() { + return (LongMask512) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Long512Shuffle rearrange(VectorShuffle shuffle) { - Long512Shuffle concreteShuffle = (Long512Shuffle) shuffle; - return (Long512Shuffle) toBitsVector().rearrange(concreteShuffle) + public final LongShuffle512 rearrange(VectorShuffle shuffle) { + LongShuffle512 concreteShuffle = (LongShuffle512) shuffle; + return (LongShuffle512) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Long512Shuffle wrapIndexes() { - Long512Vector v = toBitsVector(); + public final LongShuffle512 wrapIndexes() { + LongVector512 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Long512Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVector512) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Long512Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVector512) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Long512Shuffle) v.toShuffle(vspecies(), false); + return (LongShuffle512) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -996,14 +996,14 @@ final class Long512Vector extends LongVector { @Override final LongVector fromArray0(long[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Long512Mask.class, a, offset, (Long512Mask) m, offsetInRange); // specialize + return super.fromArray0Template(LongMask512.class, a, offset, (LongMask512) m, offsetInRange); // specialize } @ForceInline @Override final LongVector fromArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Long512Mask.class, a, offset, indexMap, mapOffset, (Long512Mask) m); + return super.fromArray0Template(LongMask512.class, a, offset, indexMap, mapOffset, (LongMask512) m); } @@ -1019,7 +1019,7 @@ final class Long512Vector extends LongVector { @Override final LongVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Long512Mask.class, ms, offset, (Long512Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(LongMask512.class, ms, offset, (LongMask512) m, offsetInRange); // specialize } @ForceInline @@ -1033,14 +1033,14 @@ final class Long512Vector extends LongVector { @Override final void intoArray0(long[] a, int offset, VectorMask m) { - super.intoArray0Template(Long512Mask.class, a, offset, (Long512Mask) m); + super.intoArray0Template(LongMask512.class, a, offset, (LongMask512) m); } @ForceInline @Override final void intoArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Long512Mask.class, a, offset, indexMap, mapOffset, (Long512Mask) m); + super.intoArray0Template(LongMask512.class, a, offset, indexMap, mapOffset, (LongMask512) m); } @@ -1048,7 +1048,7 @@ final class Long512Vector extends LongVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Long512Mask.class, ms, offset, (Long512Mask) m); + super.intoMemorySegment0Template(LongMask512.class, ms, offset, (LongMask512) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long64Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector64.java similarity index 68% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long64Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector64.java index 66c84fde56f..201261a83f3 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Long64Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector64.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Long64Vector extends LongVector { +final class LongVector64 extends LongVector { static final LongSpecies VSPECIES = (LongSpecies) LongVector.SPECIES_64; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Long64Vector.class; + static final Class VCLASS = LongVector64.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Long64Vector extends LongVector { static final Class ETYPE = long.class; // used by the JVM - Long64Vector(long[] v) { + LongVector64(long[] v) { super(v); } - // For compatibility as Long64Vector::new, + // For compatibility as LongVector64::new, // stored into species.vectorFactory. - Long64Vector(Object v) { + LongVector64(Object v) { this((long[]) v); } - static final Long64Vector ZERO = new Long64Vector(new long[VLENGTH]); - static final Long64Vector IOTA = new Long64Vector(VSPECIES.iotaArray()); + static final LongVector64 ZERO = new LongVector64(new long[VLENGTH]); + static final LongVector64 IOTA = new LongVector64(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,46 +130,46 @@ final class Long64Vector extends LongVector { @Override @ForceInline - public final Long64Vector broadcast(long e) { - return (Long64Vector) super.broadcastTemplate(e); // specialize + public final LongVector64 broadcast(long e) { + return (LongVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Long64Mask maskFromArray(boolean[] bits) { - return new Long64Mask(bits); + LongMask64 maskFromArray(boolean[] bits) { + return new LongMask64(bits); } @Override @ForceInline - Long64Shuffle iotaShuffle() { return Long64Shuffle.IOTA; } + LongShuffle64 iotaShuffle() { return LongShuffle64.IOTA; } @Override @ForceInline - Long64Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Long64Shuffle) iotaShuffleTemplate(start, step, wrap); + LongShuffle64 iotaShuffle(int start, int step, boolean wrap) { + return (LongShuffle64) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - Long64Shuffle shuffleFromArray(int[] indices, int i) { return new Long64Shuffle(indices, i); } + LongShuffle64 shuffleFromArray(int[] indices, int i) { return new LongShuffle64(indices, i); } @Override @ForceInline - Long64Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Long64Shuffle(fn); } + LongShuffle64 shuffleFromOp(IntUnaryOperator fn) { return new LongShuffle64(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Long64Vector vectorFactory(long[] vec) { - return new Long64Vector(vec); + LongVector64 vectorFactory(long[] vec) { + return new LongVector64(vec); } @ForceInline final @Override - Byte64Vector asByteVectorRaw() { - return (Byte64Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector64 asByteVectorRaw() { + return (ByteVector64) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -182,31 +182,31 @@ final class Long64Vector extends LongVector { @ForceInline final @Override - Long64Vector uOp(FUnOp f) { - return (Long64Vector) super.uOpTemplate(f); // specialize + LongVector64 uOp(FUnOp f) { + return (LongVector64) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Long64Vector uOp(VectorMask m, FUnOp f) { - return (Long64Vector) - super.uOpTemplate((Long64Mask)m, f); // specialize + LongVector64 uOp(VectorMask m, FUnOp f) { + return (LongVector64) + super.uOpTemplate((LongMask64)m, f); // specialize } // Binary operator @ForceInline final @Override - Long64Vector bOp(Vector v, FBinOp f) { - return (Long64Vector) super.bOpTemplate((Long64Vector)v, f); // specialize + LongVector64 bOp(Vector v, FBinOp f) { + return (LongVector64) super.bOpTemplate((LongVector64)v, f); // specialize } @ForceInline final @Override - Long64Vector bOp(Vector v, + LongVector64 bOp(Vector v, VectorMask m, FBinOp f) { - return (Long64Vector) - super.bOpTemplate((Long64Vector)v, (Long64Mask)m, + return (LongVector64) + super.bOpTemplate((LongVector64)v, (LongMask64)m, f); // specialize } @@ -214,19 +214,19 @@ final class Long64Vector extends LongVector { @ForceInline final @Override - Long64Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Long64Vector) - super.tOpTemplate((Long64Vector)v1, (Long64Vector)v2, + LongVector64 tOp(Vector v1, Vector v2, FTriOp f) { + return (LongVector64) + super.tOpTemplate((LongVector64)v1, (LongVector64)v2, f); // specialize } @ForceInline final @Override - Long64Vector tOp(Vector v1, Vector v2, + LongVector64 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Long64Vector) - super.tOpTemplate((Long64Vector)v1, (Long64Vector)v2, - (Long64Mask)m, f); // specialize + return (LongVector64) + super.tOpTemplate((LongVector64)v1, (LongVector64)v2, + (LongMask64)m, f); // specialize } @ForceInline @@ -264,64 +264,64 @@ final class Long64Vector extends LongVector { @Override @ForceInline - public Long64Vector lanewise(Unary op) { - return (Long64Vector) super.lanewiseTemplate(op); // specialize + public LongVector64 lanewise(Unary op) { + return (LongVector64) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Long64Vector lanewise(Unary op, VectorMask m) { - return (Long64Vector) super.lanewiseTemplate(op, Long64Mask.class, (Long64Mask) m); // specialize + public LongVector64 lanewise(Unary op, VectorMask m) { + return (LongVector64) super.lanewiseTemplate(op, LongMask64.class, (LongMask64) m); // specialize } @Override @ForceInline - public Long64Vector lanewise(Binary op, Vector v) { - return (Long64Vector) super.lanewiseTemplate(op, v); // specialize + public LongVector64 lanewise(Binary op, Vector v) { + return (LongVector64) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Long64Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Long64Vector) super.lanewiseTemplate(op, Long64Mask.class, v, (Long64Mask) m); // specialize + public LongVector64 lanewise(Binary op, Vector v, VectorMask m) { + return (LongVector64) super.lanewiseTemplate(op, LongMask64.class, v, (LongMask64) m); // specialize } /*package-private*/ @Override - @ForceInline Long64Vector + @ForceInline LongVector64 lanewiseShift(VectorOperators.Binary op, int e) { - return (Long64Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (LongVector64) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Long64Vector + @ForceInline LongVector64 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Long64Vector) super.lanewiseShiftTemplate(op, Long64Mask.class, e, (Long64Mask) m); // specialize + return (LongVector64) super.lanewiseShiftTemplate(op, LongMask64.class, e, (LongMask64) m); // specialize } /*package-private*/ @Override @ForceInline public final - Long64Vector + LongVector64 lanewise(Ternary op, Vector v1, Vector v2) { - return (Long64Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (LongVector64) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Long64Vector + LongVector64 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Long64Vector) super.lanewiseTemplate(op, Long64Mask.class, v1, v2, (Long64Mask) m); // specialize + return (LongVector64) super.lanewiseTemplate(op, LongMask64.class, v1, v2, (LongMask64) m); // specialize } @Override @ForceInline public final - Long64Vector addIndex(int scale) { - return (Long64Vector) super.addIndexTemplate(scale); // specialize + LongVector64 addIndex(int scale) { + return (LongVector64) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -336,7 +336,7 @@ final class Long64Vector extends LongVector { @ForceInline public final long reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Long64Mask.class, (Long64Mask) m); // specialized + return super.reduceLanesTemplate(op, LongMask64.class, (LongMask64) m); // specialized } @Override @@ -349,7 +349,7 @@ final class Long64Vector extends LongVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Long64Mask.class, (Long64Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, LongMask64.class, (LongMask64) m); // specialized } @Override @@ -360,155 +360,155 @@ final class Long64Vector extends LongVector { @Override @ForceInline - public final Long64Shuffle toShuffle() { - return (Long64Shuffle) toShuffle(vspecies(), false); + public final LongShuffle64 toShuffle() { + return (LongShuffle64) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Long64Mask test(Test op) { - return super.testTemplate(Long64Mask.class, op); // specialize + public final LongMask64 test(Test op) { + return super.testTemplate(LongMask64.class, op); // specialize } @Override @ForceInline - public final Long64Mask test(Test op, VectorMask m) { - return super.testTemplate(Long64Mask.class, op, (Long64Mask) m); // specialize + public final LongMask64 test(Test op, VectorMask m) { + return super.testTemplate(LongMask64.class, op, (LongMask64) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Long64Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Long64Mask.class, op, v); // specialize + public final LongMask64 compare(Comparison op, Vector v) { + return super.compareTemplate(LongMask64.class, op, v); // specialize } @Override @ForceInline - public final Long64Mask compare(Comparison op, long s) { - return super.compareTemplate(Long64Mask.class, op, s); // specialize + public final LongMask64 compare(Comparison op, long s) { + return super.compareTemplate(LongMask64.class, op, s); // specialize } @Override @ForceInline - public final Long64Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Long64Mask.class, op, v, (Long64Mask) m); + public final LongMask64 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(LongMask64.class, op, v, (LongMask64) m); } @Override @ForceInline - public Long64Vector blend(Vector v, VectorMask m) { - return (Long64Vector) - super.blendTemplate(Long64Mask.class, - (Long64Vector) v, - (Long64Mask) m); // specialize + public LongVector64 blend(Vector v, VectorMask m) { + return (LongVector64) + super.blendTemplate(LongMask64.class, + (LongVector64) v, + (LongMask64) m); // specialize } @Override @ForceInline - public Long64Vector slice(int origin, Vector v) { - return (Long64Vector) super.sliceTemplate(origin, v); // specialize + public LongVector64 slice(int origin, Vector v) { + return (LongVector64) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Long64Vector slice(int origin) { - return (Long64Vector) super.sliceTemplate(origin); // specialize + public LongVector64 slice(int origin) { + return (LongVector64) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Long64Vector unslice(int origin, Vector w, int part) { - return (Long64Vector) super.unsliceTemplate(origin, w, part); // specialize + public LongVector64 unslice(int origin, Vector w, int part) { + return (LongVector64) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Long64Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Long64Vector) - super.unsliceTemplate(Long64Mask.class, + public LongVector64 unslice(int origin, Vector w, int part, VectorMask m) { + return (LongVector64) + super.unsliceTemplate(LongMask64.class, origin, w, part, - (Long64Mask) m); // specialize + (LongMask64) m); // specialize } @Override @ForceInline - public Long64Vector unslice(int origin) { - return (Long64Vector) super.unsliceTemplate(origin); // specialize + public LongVector64 unslice(int origin) { + return (LongVector64) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Long64Vector rearrange(VectorShuffle s) { - return (Long64Vector) - super.rearrangeTemplate(Long64Shuffle.class, - (Long64Shuffle) s); // specialize + public LongVector64 rearrange(VectorShuffle s) { + return (LongVector64) + super.rearrangeTemplate(LongShuffle64.class, + (LongShuffle64) s); // specialize } @Override @ForceInline - public Long64Vector rearrange(VectorShuffle shuffle, + public LongVector64 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Long64Vector) - super.rearrangeTemplate(Long64Shuffle.class, - Long64Mask.class, - (Long64Shuffle) shuffle, - (Long64Mask) m); // specialize + return (LongVector64) + super.rearrangeTemplate(LongShuffle64.class, + LongMask64.class, + (LongShuffle64) shuffle, + (LongMask64) m); // specialize } @Override @ForceInline - public Long64Vector rearrange(VectorShuffle s, + public LongVector64 rearrange(VectorShuffle s, Vector v) { - return (Long64Vector) - super.rearrangeTemplate(Long64Shuffle.class, - (Long64Shuffle) s, - (Long64Vector) v); // specialize + return (LongVector64) + super.rearrangeTemplate(LongShuffle64.class, + (LongShuffle64) s, + (LongVector64) v); // specialize } @Override @ForceInline - public Long64Vector compress(VectorMask m) { - return (Long64Vector) - super.compressTemplate(Long64Mask.class, - (Long64Mask) m); // specialize + public LongVector64 compress(VectorMask m) { + return (LongVector64) + super.compressTemplate(LongMask64.class, + (LongMask64) m); // specialize } @Override @ForceInline - public Long64Vector expand(VectorMask m) { - return (Long64Vector) - super.expandTemplate(Long64Mask.class, - (Long64Mask) m); // specialize + public LongVector64 expand(VectorMask m) { + return (LongVector64) + super.expandTemplate(LongMask64.class, + (LongMask64) m); // specialize } @Override @ForceInline - public Long64Vector selectFrom(Vector v) { - return (Long64Vector) - super.selectFromTemplate((Long64Vector) v); // specialize + public LongVector64 selectFrom(Vector v) { + return (LongVector64) + super.selectFromTemplate((LongVector64) v); // specialize } @Override @ForceInline - public Long64Vector selectFrom(Vector v, + public LongVector64 selectFrom(Vector v, VectorMask m) { - return (Long64Vector) - super.selectFromTemplate((Long64Vector) v, - Long64Mask.class, (Long64Mask) m); // specialize + return (LongVector64) + super.selectFromTemplate((LongVector64) v, + LongMask64.class, (LongMask64) m); // specialize } @Override @ForceInline - public Long64Vector selectFrom(Vector v1, + public LongVector64 selectFrom(Vector v1, Vector v2) { - return (Long64Vector) - super.selectFromTemplate((Long64Vector) v1, (Long64Vector) v2); // specialize + return (LongVector64) + super.selectFromTemplate((LongVector64) v1, (LongVector64) v2); // specialize } @ForceInline @@ -533,7 +533,7 @@ final class Long64Vector extends LongVector { @ForceInline @Override - public Long64Vector withLane(int i, long e) { + public LongVector64 withLane(int i, long e) { switch (i) { case 0: return withLaneHelper(0, e); default: throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); @@ -541,7 +541,7 @@ final class Long64Vector extends LongVector { } @ForceInline - public Long64Vector withLaneHelper(int i, long e) { + public LongVector64 withLaneHelper(int i, long e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -554,19 +554,19 @@ final class Long64Vector extends LongVector { // Mask - static final class Long64Mask extends AbstractMask { + static final class LongMask64 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Long64Mask(boolean[] bits) { + LongMask64(boolean[] bits) { this(bits, 0); } - Long64Mask(boolean[] bits, int offset) { + LongMask64(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Long64Mask(boolean val) { + LongMask64(boolean val) { super(prepare(val)); } @@ -599,31 +599,31 @@ final class Long64Vector extends LongVector { } @Override - Long64Mask uOp(MUnOp f) { + LongMask64 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Long64Mask(res); + return new LongMask64(res); } @Override - Long64Mask bOp(VectorMask m, MBinOp f) { + LongMask64 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Long64Mask)m).getBits(); + boolean[] mbits = ((LongMask64)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Long64Mask(res); + return new LongMask64(res); } @ForceInline @Override public final - Long64Vector toVector() { - return (Long64Vector) super.toVectorTemplate(); // specialize + LongVector64 toVector() { + return (LongVector64) super.toVectorTemplate(); // specialize } /** @@ -656,25 +656,25 @@ final class Long64Vector extends LongVector { @Override @ForceInline /*package-private*/ - Long64Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Long64Mask) VectorSupport.indexPartiallyInUpperRange( - Long64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Long64Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + LongMask64 indexPartiallyInUpperRange(long offset, long limit) { + return (LongMask64) VectorSupport.indexPartiallyInUpperRange( + LongMask64.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (LongMask64) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Long64Mask not() { + public LongMask64 not() { return xor(maskAll(true)); } @Override @ForceInline - public Long64Mask compress() { - return (Long64Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Long64Vector.class, Long64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public LongMask64 compress() { + return (LongMask64)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + LongVector64.class, LongMask64.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -683,30 +683,30 @@ final class Long64Vector extends LongVector { @Override @ForceInline - public Long64Mask and(VectorMask mask) { + public LongMask64 and(VectorMask mask) { Objects.requireNonNull(mask); - Long64Mask m = (Long64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Long64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask64 m = (LongMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, LongMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Long64Mask or(VectorMask mask) { + public LongMask64 or(VectorMask mask) { Objects.requireNonNull(mask); - Long64Mask m = (Long64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Long64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask64 m = (LongMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, LongMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Long64Mask xor(VectorMask mask) { + public LongMask64 xor(VectorMask mask) { Objects.requireNonNull(mask); - Long64Mask m = (Long64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Long64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMask64 m = (LongMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, LongMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -716,21 +716,21 @@ final class Long64Vector extends LongVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Long64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, LongMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Long64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, LongMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Long64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, LongMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -740,7 +740,7 @@ final class Long64Vector extends LongVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Long64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, LongMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -750,7 +750,7 @@ final class Long64Vector extends LongVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Long64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(LongMask64.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -759,48 +759,48 @@ final class Long64Vector extends LongVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Long64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, LongMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Long64Mask)m).getBits())); + (m, __) -> anyTrueHelper(((LongMask64)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Long64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, LongMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Long64Mask)m).getBits())); + (m, __) -> allTrueHelper(((LongMask64)m).getBits())); } @ForceInline /*package-private*/ - static Long64Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Long64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static LongMask64 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(LongMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Long64Mask TRUE_MASK = new Long64Mask(true); - private static final Long64Mask FALSE_MASK = new Long64Mask(false); + private static final LongMask64 TRUE_MASK = new LongMask64(true); + private static final LongMask64 FALSE_MASK = new LongMask64(false); } // Shuffle - static final class Long64Shuffle extends AbstractShuffle { + static final class LongShuffle64 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - Long64Shuffle(long[] indices) { + LongShuffle64(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Long64Shuffle(int[] indices, int i) { + LongShuffle64(int[] indices, int i) { this(prepare(indices, i)); } - Long64Shuffle(IntUnaryOperator fn) { + LongShuffle64(IntUnaryOperator fn) { this(prepare(fn)); } @@ -820,23 +820,23 @@ final class Long64Vector extends LongVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final Long64Shuffle IOTA = new Long64Shuffle(IDENTITY); + static final LongShuffle64 IOTA = new LongShuffle64(IDENTITY); @Override @ForceInline - public Long64Vector toVector() { + public LongVector64 toVector() { return toBitsVector(); } @Override @ForceInline - Long64Vector toBitsVector() { - return (Long64Vector) super.toBitsVectorTemplate(); + LongVector64 toBitsVector() { + return (LongVector64) super.toBitsVectorTemplate(); } @Override - Long64Vector toBitsVector0() { - return ((Long64Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVector64 toBitsVector0() { + return ((LongVector64) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -908,30 +908,30 @@ final class Long64Vector extends LongVector { @Override @ForceInline - public final Long64Mask laneIsValid() { - return (Long64Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final LongMask64 laneIsValid() { + return (LongMask64) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Long64Shuffle rearrange(VectorShuffle shuffle) { - Long64Shuffle concreteShuffle = (Long64Shuffle) shuffle; - return (Long64Shuffle) toBitsVector().rearrange(concreteShuffle) + public final LongShuffle64 rearrange(VectorShuffle shuffle) { + LongShuffle64 concreteShuffle = (LongShuffle64) shuffle; + return (LongShuffle64) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Long64Shuffle wrapIndexes() { - Long64Vector v = toBitsVector(); + public final LongShuffle64 wrapIndexes() { + LongVector64 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Long64Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVector64) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Long64Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVector64) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Long64Shuffle) v.toShuffle(vspecies(), false); + return (LongShuffle64) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -982,14 +982,14 @@ final class Long64Vector extends LongVector { @Override final LongVector fromArray0(long[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Long64Mask.class, a, offset, (Long64Mask) m, offsetInRange); // specialize + return super.fromArray0Template(LongMask64.class, a, offset, (LongMask64) m, offsetInRange); // specialize } @ForceInline @Override final LongVector fromArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Long64Mask.class, a, offset, indexMap, mapOffset, (Long64Mask) m); + return super.fromArray0Template(LongMask64.class, a, offset, indexMap, mapOffset, (LongMask64) m); } @@ -1005,7 +1005,7 @@ final class Long64Vector extends LongVector { @Override final LongVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Long64Mask.class, ms, offset, (Long64Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(LongMask64.class, ms, offset, (LongMask64) m, offsetInRange); // specialize } @ForceInline @@ -1019,14 +1019,14 @@ final class Long64Vector extends LongVector { @Override final void intoArray0(long[] a, int offset, VectorMask m) { - super.intoArray0Template(Long64Mask.class, a, offset, (Long64Mask) m); + super.intoArray0Template(LongMask64.class, a, offset, (LongMask64) m); } @ForceInline @Override final void intoArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(Long64Mask.class, a, offset, indexMap, mapOffset, (Long64Mask) m); + super.intoArray0Template(LongMask64.class, a, offset, indexMap, mapOffset, (LongMask64) m); } @@ -1034,7 +1034,7 @@ final class Long64Vector extends LongVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Long64Mask.class, ms, offset, (Long64Mask) m); + super.intoMemorySegment0Template(LongMask64.class, ms, offset, (LongMask64) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongMaxVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVectorMax.java similarity index 68% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongMaxVector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVectorMax.java index c95db0c4482..2f747299573 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongMaxVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVectorMax.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class LongMaxVector extends LongVector { +final class LongVectorMax extends LongVector { static final LongSpecies VSPECIES = (LongSpecies) LongVector.SPECIES_MAX; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = LongMaxVector.class; + static final Class VCLASS = LongVectorMax.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class LongMaxVector extends LongVector { static final Class ETYPE = long.class; // used by the JVM - LongMaxVector(long[] v) { + LongVectorMax(long[] v) { super(v); } - // For compatibility as LongMaxVector::new, + // For compatibility as LongVectorMax::new, // stored into species.vectorFactory. - LongMaxVector(Object v) { + LongVectorMax(Object v) { this((long[]) v); } - static final LongMaxVector ZERO = new LongMaxVector(new long[VLENGTH]); - static final LongMaxVector IOTA = new LongMaxVector(VSPECIES.iotaArray()); + static final LongVectorMax ZERO = new LongVectorMax(new long[VLENGTH]); + static final LongVectorMax IOTA = new LongVectorMax(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,46 +130,46 @@ final class LongMaxVector extends LongVector { @Override @ForceInline - public final LongMaxVector broadcast(long e) { - return (LongMaxVector) super.broadcastTemplate(e); // specialize + public final LongVectorMax broadcast(long e) { + return (LongVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - LongMaxMask maskFromArray(boolean[] bits) { - return new LongMaxMask(bits); + LongMaskMax maskFromArray(boolean[] bits) { + return new LongMaskMax(bits); } @Override @ForceInline - LongMaxShuffle iotaShuffle() { return LongMaxShuffle.IOTA; } + LongShuffleMax iotaShuffle() { return LongShuffleMax.IOTA; } @Override @ForceInline - LongMaxShuffle iotaShuffle(int start, int step, boolean wrap) { - return (LongMaxShuffle) iotaShuffleTemplate(start, step, wrap); + LongShuffleMax iotaShuffle(int start, int step, boolean wrap) { + return (LongShuffleMax) iotaShuffleTemplate(start, step, wrap); } @Override @ForceInline - LongMaxShuffle shuffleFromArray(int[] indices, int i) { return new LongMaxShuffle(indices, i); } + LongShuffleMax shuffleFromArray(int[] indices, int i) { return new LongShuffleMax(indices, i); } @Override @ForceInline - LongMaxShuffle shuffleFromOp(IntUnaryOperator fn) { return new LongMaxShuffle(fn); } + LongShuffleMax shuffleFromOp(IntUnaryOperator fn) { return new LongShuffleMax(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - LongMaxVector vectorFactory(long[] vec) { - return new LongMaxVector(vec); + LongVectorMax vectorFactory(long[] vec) { + return new LongVectorMax(vec); } @ForceInline final @Override - ByteMaxVector asByteVectorRaw() { - return (ByteMaxVector) super.asByteVectorRawTemplate(); // specialize + ByteVectorMax asByteVectorRaw() { + return (ByteVectorMax) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -182,31 +182,31 @@ final class LongMaxVector extends LongVector { @ForceInline final @Override - LongMaxVector uOp(FUnOp f) { - return (LongMaxVector) super.uOpTemplate(f); // specialize + LongVectorMax uOp(FUnOp f) { + return (LongVectorMax) super.uOpTemplate(f); // specialize } @ForceInline final @Override - LongMaxVector uOp(VectorMask m, FUnOp f) { - return (LongMaxVector) - super.uOpTemplate((LongMaxMask)m, f); // specialize + LongVectorMax uOp(VectorMask m, FUnOp f) { + return (LongVectorMax) + super.uOpTemplate((LongMaskMax)m, f); // specialize } // Binary operator @ForceInline final @Override - LongMaxVector bOp(Vector v, FBinOp f) { - return (LongMaxVector) super.bOpTemplate((LongMaxVector)v, f); // specialize + LongVectorMax bOp(Vector v, FBinOp f) { + return (LongVectorMax) super.bOpTemplate((LongVectorMax)v, f); // specialize } @ForceInline final @Override - LongMaxVector bOp(Vector v, + LongVectorMax bOp(Vector v, VectorMask m, FBinOp f) { - return (LongMaxVector) - super.bOpTemplate((LongMaxVector)v, (LongMaxMask)m, + return (LongVectorMax) + super.bOpTemplate((LongVectorMax)v, (LongMaskMax)m, f); // specialize } @@ -214,19 +214,19 @@ final class LongMaxVector extends LongVector { @ForceInline final @Override - LongMaxVector tOp(Vector v1, Vector v2, FTriOp f) { - return (LongMaxVector) - super.tOpTemplate((LongMaxVector)v1, (LongMaxVector)v2, + LongVectorMax tOp(Vector v1, Vector v2, FTriOp f) { + return (LongVectorMax) + super.tOpTemplate((LongVectorMax)v1, (LongVectorMax)v2, f); // specialize } @ForceInline final @Override - LongMaxVector tOp(Vector v1, Vector v2, + LongVectorMax tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (LongMaxVector) - super.tOpTemplate((LongMaxVector)v1, (LongMaxVector)v2, - (LongMaxMask)m, f); // specialize + return (LongVectorMax) + super.tOpTemplate((LongVectorMax)v1, (LongVectorMax)v2, + (LongMaskMax)m, f); // specialize } @ForceInline @@ -264,64 +264,64 @@ final class LongMaxVector extends LongVector { @Override @ForceInline - public LongMaxVector lanewise(Unary op) { - return (LongMaxVector) super.lanewiseTemplate(op); // specialize + public LongVectorMax lanewise(Unary op) { + return (LongVectorMax) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public LongMaxVector lanewise(Unary op, VectorMask m) { - return (LongMaxVector) super.lanewiseTemplate(op, LongMaxMask.class, (LongMaxMask) m); // specialize + public LongVectorMax lanewise(Unary op, VectorMask m) { + return (LongVectorMax) super.lanewiseTemplate(op, LongMaskMax.class, (LongMaskMax) m); // specialize } @Override @ForceInline - public LongMaxVector lanewise(Binary op, Vector v) { - return (LongMaxVector) super.lanewiseTemplate(op, v); // specialize + public LongVectorMax lanewise(Binary op, Vector v) { + return (LongVectorMax) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public LongMaxVector lanewise(Binary op, Vector v, VectorMask m) { - return (LongMaxVector) super.lanewiseTemplate(op, LongMaxMask.class, v, (LongMaxMask) m); // specialize + public LongVectorMax lanewise(Binary op, Vector v, VectorMask m) { + return (LongVectorMax) super.lanewiseTemplate(op, LongMaskMax.class, v, (LongMaskMax) m); // specialize } /*package-private*/ @Override - @ForceInline LongMaxVector + @ForceInline LongVectorMax lanewiseShift(VectorOperators.Binary op, int e) { - return (LongMaxVector) super.lanewiseShiftTemplate(op, e); // specialize + return (LongVectorMax) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline LongMaxVector + @ForceInline LongVectorMax lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (LongMaxVector) super.lanewiseShiftTemplate(op, LongMaxMask.class, e, (LongMaxMask) m); // specialize + return (LongVectorMax) super.lanewiseShiftTemplate(op, LongMaskMax.class, e, (LongMaskMax) m); // specialize } /*package-private*/ @Override @ForceInline public final - LongMaxVector + LongVectorMax lanewise(Ternary op, Vector v1, Vector v2) { - return (LongMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize + return (LongVectorMax) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - LongMaxVector + LongVectorMax lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (LongMaxVector) super.lanewiseTemplate(op, LongMaxMask.class, v1, v2, (LongMaxMask) m); // specialize + return (LongVectorMax) super.lanewiseTemplate(op, LongMaskMax.class, v1, v2, (LongMaskMax) m); // specialize } @Override @ForceInline public final - LongMaxVector addIndex(int scale) { - return (LongMaxVector) super.addIndexTemplate(scale); // specialize + LongVectorMax addIndex(int scale) { + return (LongVectorMax) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -336,7 +336,7 @@ final class LongMaxVector extends LongVector { @ForceInline public final long reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, LongMaxMask.class, (LongMaxMask) m); // specialized + return super.reduceLanesTemplate(op, LongMaskMax.class, (LongMaskMax) m); // specialized } @Override @@ -349,7 +349,7 @@ final class LongMaxVector extends LongVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, LongMaxMask.class, (LongMaxMask) m); // specialized + return (long) super.reduceLanesTemplate(op, LongMaskMax.class, (LongMaskMax) m); // specialized } @Override @@ -360,155 +360,155 @@ final class LongMaxVector extends LongVector { @Override @ForceInline - public final LongMaxShuffle toShuffle() { - return (LongMaxShuffle) toShuffle(vspecies(), false); + public final LongShuffleMax toShuffle() { + return (LongShuffleMax) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final LongMaxMask test(Test op) { - return super.testTemplate(LongMaxMask.class, op); // specialize + public final LongMaskMax test(Test op) { + return super.testTemplate(LongMaskMax.class, op); // specialize } @Override @ForceInline - public final LongMaxMask test(Test op, VectorMask m) { - return super.testTemplate(LongMaxMask.class, op, (LongMaxMask) m); // specialize + public final LongMaskMax test(Test op, VectorMask m) { + return super.testTemplate(LongMaskMax.class, op, (LongMaskMax) m); // specialize } // Specialized comparisons @Override @ForceInline - public final LongMaxMask compare(Comparison op, Vector v) { - return super.compareTemplate(LongMaxMask.class, op, v); // specialize + public final LongMaskMax compare(Comparison op, Vector v) { + return super.compareTemplate(LongMaskMax.class, op, v); // specialize } @Override @ForceInline - public final LongMaxMask compare(Comparison op, long s) { - return super.compareTemplate(LongMaxMask.class, op, s); // specialize + public final LongMaskMax compare(Comparison op, long s) { + return super.compareTemplate(LongMaskMax.class, op, s); // specialize } @Override @ForceInline - public final LongMaxMask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(LongMaxMask.class, op, v, (LongMaxMask) m); + public final LongMaskMax compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(LongMaskMax.class, op, v, (LongMaskMax) m); } @Override @ForceInline - public LongMaxVector blend(Vector v, VectorMask m) { - return (LongMaxVector) - super.blendTemplate(LongMaxMask.class, - (LongMaxVector) v, - (LongMaxMask) m); // specialize + public LongVectorMax blend(Vector v, VectorMask m) { + return (LongVectorMax) + super.blendTemplate(LongMaskMax.class, + (LongVectorMax) v, + (LongMaskMax) m); // specialize } @Override @ForceInline - public LongMaxVector slice(int origin, Vector v) { - return (LongMaxVector) super.sliceTemplate(origin, v); // specialize + public LongVectorMax slice(int origin, Vector v) { + return (LongVectorMax) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public LongMaxVector slice(int origin) { - return (LongMaxVector) super.sliceTemplate(origin); // specialize + public LongVectorMax slice(int origin) { + return (LongVectorMax) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public LongMaxVector unslice(int origin, Vector w, int part) { - return (LongMaxVector) super.unsliceTemplate(origin, w, part); // specialize + public LongVectorMax unslice(int origin, Vector w, int part) { + return (LongVectorMax) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public LongMaxVector unslice(int origin, Vector w, int part, VectorMask m) { - return (LongMaxVector) - super.unsliceTemplate(LongMaxMask.class, + public LongVectorMax unslice(int origin, Vector w, int part, VectorMask m) { + return (LongVectorMax) + super.unsliceTemplate(LongMaskMax.class, origin, w, part, - (LongMaxMask) m); // specialize + (LongMaskMax) m); // specialize } @Override @ForceInline - public LongMaxVector unslice(int origin) { - return (LongMaxVector) super.unsliceTemplate(origin); // specialize + public LongVectorMax unslice(int origin) { + return (LongVectorMax) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public LongMaxVector rearrange(VectorShuffle s) { - return (LongMaxVector) - super.rearrangeTemplate(LongMaxShuffle.class, - (LongMaxShuffle) s); // specialize + public LongVectorMax rearrange(VectorShuffle s) { + return (LongVectorMax) + super.rearrangeTemplate(LongShuffleMax.class, + (LongShuffleMax) s); // specialize } @Override @ForceInline - public LongMaxVector rearrange(VectorShuffle shuffle, + public LongVectorMax rearrange(VectorShuffle shuffle, VectorMask m) { - return (LongMaxVector) - super.rearrangeTemplate(LongMaxShuffle.class, - LongMaxMask.class, - (LongMaxShuffle) shuffle, - (LongMaxMask) m); // specialize + return (LongVectorMax) + super.rearrangeTemplate(LongShuffleMax.class, + LongMaskMax.class, + (LongShuffleMax) shuffle, + (LongMaskMax) m); // specialize } @Override @ForceInline - public LongMaxVector rearrange(VectorShuffle s, + public LongVectorMax rearrange(VectorShuffle s, Vector v) { - return (LongMaxVector) - super.rearrangeTemplate(LongMaxShuffle.class, - (LongMaxShuffle) s, - (LongMaxVector) v); // specialize + return (LongVectorMax) + super.rearrangeTemplate(LongShuffleMax.class, + (LongShuffleMax) s, + (LongVectorMax) v); // specialize } @Override @ForceInline - public LongMaxVector compress(VectorMask m) { - return (LongMaxVector) - super.compressTemplate(LongMaxMask.class, - (LongMaxMask) m); // specialize + public LongVectorMax compress(VectorMask m) { + return (LongVectorMax) + super.compressTemplate(LongMaskMax.class, + (LongMaskMax) m); // specialize } @Override @ForceInline - public LongMaxVector expand(VectorMask m) { - return (LongMaxVector) - super.expandTemplate(LongMaxMask.class, - (LongMaxMask) m); // specialize + public LongVectorMax expand(VectorMask m) { + return (LongVectorMax) + super.expandTemplate(LongMaskMax.class, + (LongMaskMax) m); // specialize } @Override @ForceInline - public LongMaxVector selectFrom(Vector v) { - return (LongMaxVector) - super.selectFromTemplate((LongMaxVector) v); // specialize + public LongVectorMax selectFrom(Vector v) { + return (LongVectorMax) + super.selectFromTemplate((LongVectorMax) v); // specialize } @Override @ForceInline - public LongMaxVector selectFrom(Vector v, + public LongVectorMax selectFrom(Vector v, VectorMask m) { - return (LongMaxVector) - super.selectFromTemplate((LongMaxVector) v, - LongMaxMask.class, (LongMaxMask) m); // specialize + return (LongVectorMax) + super.selectFromTemplate((LongVectorMax) v, + LongMaskMax.class, (LongMaskMax) m); // specialize } @Override @ForceInline - public LongMaxVector selectFrom(Vector v1, + public LongVectorMax selectFrom(Vector v1, Vector v2) { - return (LongMaxVector) - super.selectFromTemplate((LongMaxVector) v1, (LongMaxVector) v2); // specialize + return (LongVectorMax) + super.selectFromTemplate((LongVectorMax) v1, (LongVectorMax) v2); // specialize } @ForceInline @@ -533,7 +533,7 @@ final class LongMaxVector extends LongVector { @ForceInline @Override - public LongMaxVector withLane(int i, long e) { + public LongVectorMax withLane(int i, long e) { if (i < 0 || i >= VLENGTH) { throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); } @@ -541,7 +541,7 @@ final class LongMaxVector extends LongVector { } @ForceInline - public LongMaxVector withLaneHelper(int i, long e) { + public LongVectorMax withLaneHelper(int i, long e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -554,19 +554,19 @@ final class LongMaxVector extends LongVector { // Mask - static final class LongMaxMask extends AbstractMask { + static final class LongMaskMax extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - LongMaxMask(boolean[] bits) { + LongMaskMax(boolean[] bits) { this(bits, 0); } - LongMaxMask(boolean[] bits, int offset) { + LongMaskMax(boolean[] bits, int offset) { super(prepare(bits, offset)); } - LongMaxMask(boolean val) { + LongMaskMax(boolean val) { super(prepare(val)); } @@ -599,31 +599,31 @@ final class LongMaxVector extends LongVector { } @Override - LongMaxMask uOp(MUnOp f) { + LongMaskMax uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new LongMaxMask(res); + return new LongMaskMax(res); } @Override - LongMaxMask bOp(VectorMask m, MBinOp f) { + LongMaskMax bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((LongMaxMask)m).getBits(); + boolean[] mbits = ((LongMaskMax)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new LongMaxMask(res); + return new LongMaskMax(res); } @ForceInline @Override public final - LongMaxVector toVector() { - return (LongMaxVector) super.toVectorTemplate(); // specialize + LongVectorMax toVector() { + return (LongVectorMax) super.toVectorTemplate(); // specialize } /** @@ -656,25 +656,25 @@ final class LongMaxVector extends LongVector { @Override @ForceInline /*package-private*/ - LongMaxMask indexPartiallyInUpperRange(long offset, long limit) { - return (LongMaxMask) VectorSupport.indexPartiallyInUpperRange( - LongMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (LongMaxMask) TRUE_MASK.indexPartiallyInRange(o, l)); + LongMaskMax indexPartiallyInUpperRange(long offset, long limit) { + return (LongMaskMax) VectorSupport.indexPartiallyInUpperRange( + LongMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (LongMaskMax) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public LongMaxMask not() { + public LongMaskMax not() { return xor(maskAll(true)); } @Override @ForceInline - public LongMaxMask compress() { - return (LongMaxMask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - LongMaxVector.class, LongMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public LongMaskMax compress() { + return (LongMaskMax)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + LongVectorMax.class, LongMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -683,30 +683,30 @@ final class LongMaxVector extends LongVector { @Override @ForceInline - public LongMaxMask and(VectorMask mask) { + public LongMaskMax and(VectorMask mask) { Objects.requireNonNull(mask); - LongMaxMask m = (LongMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, LongMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMaskMax m = (LongMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, LongMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public LongMaxMask or(VectorMask mask) { + public LongMaskMax or(VectorMask mask) { Objects.requireNonNull(mask); - LongMaxMask m = (LongMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, LongMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMaskMax m = (LongMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, LongMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public LongMaxMask xor(VectorMask mask) { + public LongMaskMax xor(VectorMask mask) { Objects.requireNonNull(mask); - LongMaxMask m = (LongMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, LongMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + LongMaskMax m = (LongMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, LongMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -716,21 +716,21 @@ final class LongMaxVector extends LongVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, LongMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, LongMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, LongMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, LongMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, LongMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, LongMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -740,7 +740,7 @@ final class LongMaxVector extends LongVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, LongMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, LongMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -750,7 +750,7 @@ final class LongMaxVector extends LongVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(LongMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(LongMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -759,48 +759,48 @@ final class LongMaxVector extends LongVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, LongMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, LongMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((LongMaxMask)m).getBits())); + (m, __) -> anyTrueHelper(((LongMaskMax)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, LongMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, LongMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((LongMaxMask)m).getBits())); + (m, __) -> allTrueHelper(((LongMaskMax)m).getBits())); } @ForceInline /*package-private*/ - static LongMaxMask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(LongMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static LongMaskMax maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(LongMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final LongMaxMask TRUE_MASK = new LongMaxMask(true); - private static final LongMaxMask FALSE_MASK = new LongMaxMask(false); + private static final LongMaskMax TRUE_MASK = new LongMaskMax(true); + private static final LongMaskMax FALSE_MASK = new LongMaskMax(false); } // Shuffle - static final class LongMaxShuffle extends AbstractShuffle { + static final class LongShuffleMax extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = long.class; // used by the JVM - LongMaxShuffle(long[] indices) { + LongShuffleMax(long[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - LongMaxShuffle(int[] indices, int i) { + LongShuffleMax(int[] indices, int i) { this(prepare(indices, i)); } - LongMaxShuffle(IntUnaryOperator fn) { + LongShuffleMax(IntUnaryOperator fn) { this(prepare(fn)); } @@ -820,23 +820,23 @@ final class LongMaxVector extends LongVector { assert(VLENGTH < Long.MAX_VALUE); assert(Long.MIN_VALUE <= -VLENGTH); } - static final LongMaxShuffle IOTA = new LongMaxShuffle(IDENTITY); + static final LongShuffleMax IOTA = new LongShuffleMax(IDENTITY); @Override @ForceInline - public LongMaxVector toVector() { + public LongVectorMax toVector() { return toBitsVector(); } @Override @ForceInline - LongMaxVector toBitsVector() { - return (LongMaxVector) super.toBitsVectorTemplate(); + LongVectorMax toBitsVector() { + return (LongVectorMax) super.toBitsVectorTemplate(); } @Override - LongMaxVector toBitsVector0() { - return ((LongMaxVector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + LongVectorMax toBitsVector0() { + return ((LongVectorMax) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -908,30 +908,30 @@ final class LongMaxVector extends LongVector { @Override @ForceInline - public final LongMaxMask laneIsValid() { - return (LongMaxMask) toBitsVector().compare(VectorOperators.GE, 0) + public final LongMaskMax laneIsValid() { + return (LongMaskMax) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final LongMaxShuffle rearrange(VectorShuffle shuffle) { - LongMaxShuffle concreteShuffle = (LongMaxShuffle) shuffle; - return (LongMaxShuffle) toBitsVector().rearrange(concreteShuffle) + public final LongShuffleMax rearrange(VectorShuffle shuffle) { + LongShuffleMax concreteShuffle = (LongShuffleMax) shuffle; + return (LongShuffleMax) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final LongMaxShuffle wrapIndexes() { - LongMaxVector v = toBitsVector(); + public final LongShuffleMax wrapIndexes() { + LongVectorMax v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (LongMaxVector) v.lanewise(VectorOperators.AND, length() - 1); + v = (LongVectorMax) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (LongMaxVector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (LongVectorMax) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (LongMaxShuffle) v.toShuffle(vspecies(), false); + return (LongShuffleMax) v.toShuffle(vspecies(), false); } private static long[] prepare(int[] indices, int offset) { @@ -982,14 +982,14 @@ final class LongMaxVector extends LongVector { @Override final LongVector fromArray0(long[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(LongMaxMask.class, a, offset, (LongMaxMask) m, offsetInRange); // specialize + return super.fromArray0Template(LongMaskMax.class, a, offset, (LongMaskMax) m, offsetInRange); // specialize } @ForceInline @Override final LongVector fromArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(LongMaxMask.class, a, offset, indexMap, mapOffset, (LongMaxMask) m); + return super.fromArray0Template(LongMaskMax.class, a, offset, indexMap, mapOffset, (LongMaskMax) m); } @@ -1005,7 +1005,7 @@ final class LongMaxVector extends LongVector { @Override final LongVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(LongMaxMask.class, ms, offset, (LongMaxMask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(LongMaskMax.class, ms, offset, (LongMaskMax) m, offsetInRange); // specialize } @ForceInline @@ -1019,14 +1019,14 @@ final class LongMaxVector extends LongVector { @Override final void intoArray0(long[] a, int offset, VectorMask m) { - super.intoArray0Template(LongMaxMask.class, a, offset, (LongMaxMask) m); + super.intoArray0Template(LongMaskMax.class, a, offset, (LongMaskMax) m); } @ForceInline @Override final void intoArray0(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - super.intoArray0Template(LongMaxMask.class, a, offset, indexMap, mapOffset, (LongMaxMask) m); + super.intoArray0Template(LongMaskMax.class, a, offset, indexMap, mapOffset, (LongMaskMax) m); } @@ -1034,7 +1034,7 @@ final class LongMaxVector extends LongVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(LongMaxMask.class, ms, offset, (LongMaxMask) m); + super.intoMemorySegment0Template(LongMaskMax.class, ms, offset, (LongMaskMax) m); } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java index 03b7bb030b9..7ba465706e8 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java @@ -84,8 +84,8 @@ public abstract class ShortVector extends AbstractVector { // The various shape-specific subclasses // also specialize them by wrapping // them in a call like this: - // return (Byte128Vector) - // super.bOp((Byte128Vector) o); + // return (ByteVector128) + // super.bOp((ByteVector128) o); // The purpose of that is to forcibly inline // the generic definition from this file // into a sharply-typed and size-specific @@ -4455,13 +4455,13 @@ public abstract class ShortVector extends AbstractVector { @Override @ForceInline public final ShortVector zero() { - if ((Class) vectorType() == ShortMaxVector.class) - return ShortMaxVector.ZERO; + if ((Class) vectorType() == ShortVectorMax.class) + return ShortVectorMax.ZERO; switch (vectorBitSize()) { - case 64: return Short64Vector.ZERO; - case 128: return Short128Vector.ZERO; - case 256: return Short256Vector.ZERO; - case 512: return Short512Vector.ZERO; + case 64: return ShortVector64.ZERO; + case 128: return ShortVector128.ZERO; + case 256: return ShortVector256.ZERO; + case 512: return ShortVector512.ZERO; } throw new AssertionError(); } @@ -4469,13 +4469,13 @@ public abstract class ShortVector extends AbstractVector { @Override @ForceInline public final ShortVector iota() { - if ((Class) vectorType() == ShortMaxVector.class) - return ShortMaxVector.IOTA; + if ((Class) vectorType() == ShortVectorMax.class) + return ShortVectorMax.IOTA; switch (vectorBitSize()) { - case 64: return Short64Vector.IOTA; - case 128: return Short128Vector.IOTA; - case 256: return Short256Vector.IOTA; - case 512: return Short512Vector.IOTA; + case 64: return ShortVector64.IOTA; + case 128: return ShortVector128.IOTA; + case 256: return ShortVector256.IOTA; + case 512: return ShortVector512.IOTA; } throw new AssertionError(); } @@ -4484,13 +4484,13 @@ public abstract class ShortVector extends AbstractVector { @Override @ForceInline public final VectorMask maskAll(boolean bit) { - if ((Class) vectorType() == ShortMaxVector.class) - return ShortMaxVector.ShortMaxMask.maskAll(bit); + if ((Class) vectorType() == ShortVectorMax.class) + return ShortVectorMax.ShortMaskMax.maskAll(bit); switch (vectorBitSize()) { - case 64: return Short64Vector.Short64Mask.maskAll(bit); - case 128: return Short128Vector.Short128Mask.maskAll(bit); - case 256: return Short256Vector.Short256Mask.maskAll(bit); - case 512: return Short512Vector.Short512Mask.maskAll(bit); + case 64: return ShortVector64.ShortMask64.maskAll(bit); + case 128: return ShortVector128.ShortMask128.maskAll(bit); + case 256: return ShortVector256.ShortMask256.maskAll(bit); + case 512: return ShortVector512.ShortMask512.maskAll(bit); } throw new AssertionError(); } @@ -4518,42 +4518,42 @@ public abstract class ShortVector extends AbstractVector { /** Species representing {@link ShortVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ public static final VectorSpecies SPECIES_64 = new ShortSpecies(VectorShape.S_64_BIT, - Short64Vector.class, - Short64Vector.Short64Mask.class, - Short64Vector.Short64Shuffle.class, - Short64Vector::new); + ShortVector64.class, + ShortVector64.ShortMask64.class, + ShortVector64.ShortShuffle64.class, + ShortVector64::new); /** Species representing {@link ShortVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ public static final VectorSpecies SPECIES_128 = new ShortSpecies(VectorShape.S_128_BIT, - Short128Vector.class, - Short128Vector.Short128Mask.class, - Short128Vector.Short128Shuffle.class, - Short128Vector::new); + ShortVector128.class, + ShortVector128.ShortMask128.class, + ShortVector128.ShortShuffle128.class, + ShortVector128::new); /** Species representing {@link ShortVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ public static final VectorSpecies SPECIES_256 = new ShortSpecies(VectorShape.S_256_BIT, - Short256Vector.class, - Short256Vector.Short256Mask.class, - Short256Vector.Short256Shuffle.class, - Short256Vector::new); + ShortVector256.class, + ShortVector256.ShortMask256.class, + ShortVector256.ShortShuffle256.class, + ShortVector256::new); /** Species representing {@link ShortVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ public static final VectorSpecies SPECIES_512 = new ShortSpecies(VectorShape.S_512_BIT, - Short512Vector.class, - Short512Vector.Short512Mask.class, - Short512Vector.Short512Shuffle.class, - Short512Vector::new); + ShortVector512.class, + ShortVector512.ShortMask512.class, + ShortVector512.ShortShuffle512.class, + ShortVector512::new); /** Species representing {@link ShortVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ public static final VectorSpecies SPECIES_MAX = new ShortSpecies(VectorShape.S_Max_BIT, - ShortMaxVector.class, - ShortMaxVector.ShortMaxMask.class, - ShortMaxVector.ShortMaxShuffle.class, - ShortMaxVector::new); + ShortVectorMax.class, + ShortVectorMax.ShortMaskMax.class, + ShortVectorMax.ShortShuffleMax.class, + ShortVectorMax::new); /** * Preferred species for {@link ShortVector}s. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short128Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector128.java similarity index 66% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short128Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector128.java index cc35a1ea069..97df871c9c0 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short128Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector128.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Short128Vector extends ShortVector { +final class ShortVector128 extends ShortVector { static final ShortSpecies VSPECIES = (ShortSpecies) ShortVector.SPECIES_128; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Short128Vector.class; + static final Class VCLASS = ShortVector128.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Short128Vector extends ShortVector { static final Class ETYPE = short.class; // used by the JVM - Short128Vector(short[] v) { + ShortVector128(short[] v) { super(v); } - // For compatibility as Short128Vector::new, + // For compatibility as ShortVector128::new, // stored into species.vectorFactory. - Short128Vector(Object v) { + ShortVector128(Object v) { this((short[]) v); } - static final Short128Vector ZERO = new Short128Vector(new short[VLENGTH]); - static final Short128Vector IOTA = new Short128Vector(VSPECIES.iotaArray()); + static final ShortVector128 ZERO = new ShortVector128(new short[VLENGTH]); + static final ShortVector128 IOTA = new ShortVector128(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Short128Vector extends ShortVector { @Override @ForceInline - public final Short128Vector broadcast(short e) { - return (Short128Vector) super.broadcastTemplate(e); // specialize + public final ShortVector128 broadcast(short e) { + return (ShortVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Short128Vector broadcast(long e) { - return (Short128Vector) super.broadcastTemplate(e); // specialize + public final ShortVector128 broadcast(long e) { + return (ShortVector128) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Short128Mask maskFromArray(boolean[] bits) { - return new Short128Mask(bits); + ShortMask128 maskFromArray(boolean[] bits) { + return new ShortMask128(bits); } @Override @ForceInline - Short128Shuffle iotaShuffle() { return Short128Shuffle.IOTA; } + ShortShuffle128 iotaShuffle() { return ShortShuffle128.IOTA; } @Override @ForceInline - Short128Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Short128Shuffle) iotaShuffleTemplate((short) start, (short) step, wrap); + ShortShuffle128 iotaShuffle(int start, int step, boolean wrap) { + return (ShortShuffle128) iotaShuffleTemplate((short) start, (short) step, wrap); } @Override @ForceInline - Short128Shuffle shuffleFromArray(int[] indices, int i) { return new Short128Shuffle(indices, i); } + ShortShuffle128 shuffleFromArray(int[] indices, int i) { return new ShortShuffle128(indices, i); } @Override @ForceInline - Short128Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Short128Shuffle(fn); } + ShortShuffle128 shuffleFromOp(IntUnaryOperator fn) { return new ShortShuffle128(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Short128Vector vectorFactory(short[] vec) { - return new Short128Vector(vec); + ShortVector128 vectorFactory(short[] vec) { + return new ShortVector128(vec); } @ForceInline final @Override - Byte128Vector asByteVectorRaw() { - return (Byte128Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector128 asByteVectorRaw() { + return (ByteVector128) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Short128Vector extends ShortVector { @ForceInline final @Override - Short128Vector uOp(FUnOp f) { - return (Short128Vector) super.uOpTemplate(f); // specialize + ShortVector128 uOp(FUnOp f) { + return (ShortVector128) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Short128Vector uOp(VectorMask m, FUnOp f) { - return (Short128Vector) - super.uOpTemplate((Short128Mask)m, f); // specialize + ShortVector128 uOp(VectorMask m, FUnOp f) { + return (ShortVector128) + super.uOpTemplate((ShortMask128)m, f); // specialize } // Binary operator @ForceInline final @Override - Short128Vector bOp(Vector v, FBinOp f) { - return (Short128Vector) super.bOpTemplate((Short128Vector)v, f); // specialize + ShortVector128 bOp(Vector v, FBinOp f) { + return (ShortVector128) super.bOpTemplate((ShortVector128)v, f); // specialize } @ForceInline final @Override - Short128Vector bOp(Vector v, + ShortVector128 bOp(Vector v, VectorMask m, FBinOp f) { - return (Short128Vector) - super.bOpTemplate((Short128Vector)v, (Short128Mask)m, + return (ShortVector128) + super.bOpTemplate((ShortVector128)v, (ShortMask128)m, f); // specialize } @@ -219,19 +219,19 @@ final class Short128Vector extends ShortVector { @ForceInline final @Override - Short128Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Short128Vector) - super.tOpTemplate((Short128Vector)v1, (Short128Vector)v2, + ShortVector128 tOp(Vector v1, Vector v2, FTriOp f) { + return (ShortVector128) + super.tOpTemplate((ShortVector128)v1, (ShortVector128)v2, f); // specialize } @ForceInline final @Override - Short128Vector tOp(Vector v1, Vector v2, + ShortVector128 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Short128Vector) - super.tOpTemplate((Short128Vector)v1, (Short128Vector)v2, - (Short128Mask)m, f); // specialize + return (ShortVector128) + super.tOpTemplate((ShortVector128)v1, (ShortVector128)v2, + (ShortMask128)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Short128Vector extends ShortVector { @Override @ForceInline - public Short128Vector lanewise(Unary op) { - return (Short128Vector) super.lanewiseTemplate(op); // specialize + public ShortVector128 lanewise(Unary op) { + return (ShortVector128) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Short128Vector lanewise(Unary op, VectorMask m) { - return (Short128Vector) super.lanewiseTemplate(op, Short128Mask.class, (Short128Mask) m); // specialize + public ShortVector128 lanewise(Unary op, VectorMask m) { + return (ShortVector128) super.lanewiseTemplate(op, ShortMask128.class, (ShortMask128) m); // specialize } @Override @ForceInline - public Short128Vector lanewise(Binary op, Vector v) { - return (Short128Vector) super.lanewiseTemplate(op, v); // specialize + public ShortVector128 lanewise(Binary op, Vector v) { + return (ShortVector128) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Short128Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Short128Vector) super.lanewiseTemplate(op, Short128Mask.class, v, (Short128Mask) m); // specialize + public ShortVector128 lanewise(Binary op, Vector v, VectorMask m) { + return (ShortVector128) super.lanewiseTemplate(op, ShortMask128.class, v, (ShortMask128) m); // specialize } /*package-private*/ @Override - @ForceInline Short128Vector + @ForceInline ShortVector128 lanewiseShift(VectorOperators.Binary op, int e) { - return (Short128Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (ShortVector128) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Short128Vector + @ForceInline ShortVector128 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Short128Vector) super.lanewiseShiftTemplate(op, Short128Mask.class, e, (Short128Mask) m); // specialize + return (ShortVector128) super.lanewiseShiftTemplate(op, ShortMask128.class, e, (ShortMask128) m); // specialize } /*package-private*/ @Override @ForceInline public final - Short128Vector + ShortVector128 lanewise(Ternary op, Vector v1, Vector v2) { - return (Short128Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ShortVector128) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Short128Vector + ShortVector128 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Short128Vector) super.lanewiseTemplate(op, Short128Mask.class, v1, v2, (Short128Mask) m); // specialize + return (ShortVector128) super.lanewiseTemplate(op, ShortMask128.class, v1, v2, (ShortMask128) m); // specialize } @Override @ForceInline public final - Short128Vector addIndex(int scale) { - return (Short128Vector) super.addIndexTemplate(scale); // specialize + ShortVector128 addIndex(int scale) { + return (ShortVector128) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Short128Vector extends ShortVector { @ForceInline public final short reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Short128Mask.class, (Short128Mask) m); // specialized + return super.reduceLanesTemplate(op, ShortMask128.class, (ShortMask128) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Short128Vector extends ShortVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Short128Mask.class, (Short128Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, ShortMask128.class, (ShortMask128) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Short128Vector extends ShortVector { @Override @ForceInline - public final Short128Shuffle toShuffle() { - return (Short128Shuffle) toShuffle(vspecies(), false); + public final ShortShuffle128 toShuffle() { + return (ShortShuffle128) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Short128Mask test(Test op) { - return super.testTemplate(Short128Mask.class, op); // specialize + public final ShortMask128 test(Test op) { + return super.testTemplate(ShortMask128.class, op); // specialize } @Override @ForceInline - public final Short128Mask test(Test op, VectorMask m) { - return super.testTemplate(Short128Mask.class, op, (Short128Mask) m); // specialize + public final ShortMask128 test(Test op, VectorMask m) { + return super.testTemplate(ShortMask128.class, op, (ShortMask128) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Short128Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Short128Mask.class, op, v); // specialize + public final ShortMask128 compare(Comparison op, Vector v) { + return super.compareTemplate(ShortMask128.class, op, v); // specialize } @Override @ForceInline - public final Short128Mask compare(Comparison op, short s) { - return super.compareTemplate(Short128Mask.class, op, s); // specialize + public final ShortMask128 compare(Comparison op, short s) { + return super.compareTemplate(ShortMask128.class, op, s); // specialize } @Override @ForceInline - public final Short128Mask compare(Comparison op, long s) { - return super.compareTemplate(Short128Mask.class, op, s); // specialize + public final ShortMask128 compare(Comparison op, long s) { + return super.compareTemplate(ShortMask128.class, op, s); // specialize } @Override @ForceInline - public final Short128Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Short128Mask.class, op, v, (Short128Mask) m); + public final ShortMask128 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ShortMask128.class, op, v, (ShortMask128) m); } @Override @ForceInline - public Short128Vector blend(Vector v, VectorMask m) { - return (Short128Vector) - super.blendTemplate(Short128Mask.class, - (Short128Vector) v, - (Short128Mask) m); // specialize + public ShortVector128 blend(Vector v, VectorMask m) { + return (ShortVector128) + super.blendTemplate(ShortMask128.class, + (ShortVector128) v, + (ShortMask128) m); // specialize } @Override @ForceInline - public Short128Vector slice(int origin, Vector v) { - return (Short128Vector) super.sliceTemplate(origin, v); // specialize + public ShortVector128 slice(int origin, Vector v) { + return (ShortVector128) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Short128Vector slice(int origin) { - return (Short128Vector) super.sliceTemplate(origin); // specialize + public ShortVector128 slice(int origin) { + return (ShortVector128) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Short128Vector unslice(int origin, Vector w, int part) { - return (Short128Vector) super.unsliceTemplate(origin, w, part); // specialize + public ShortVector128 unslice(int origin, Vector w, int part) { + return (ShortVector128) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Short128Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Short128Vector) - super.unsliceTemplate(Short128Mask.class, + public ShortVector128 unslice(int origin, Vector w, int part, VectorMask m) { + return (ShortVector128) + super.unsliceTemplate(ShortMask128.class, origin, w, part, - (Short128Mask) m); // specialize + (ShortMask128) m); // specialize } @Override @ForceInline - public Short128Vector unslice(int origin) { - return (Short128Vector) super.unsliceTemplate(origin); // specialize + public ShortVector128 unslice(int origin) { + return (ShortVector128) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Short128Vector rearrange(VectorShuffle s) { - return (Short128Vector) - super.rearrangeTemplate(Short128Shuffle.class, - (Short128Shuffle) s); // specialize + public ShortVector128 rearrange(VectorShuffle s) { + return (ShortVector128) + super.rearrangeTemplate(ShortShuffle128.class, + (ShortShuffle128) s); // specialize } @Override @ForceInline - public Short128Vector rearrange(VectorShuffle shuffle, + public ShortVector128 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Short128Vector) - super.rearrangeTemplate(Short128Shuffle.class, - Short128Mask.class, - (Short128Shuffle) shuffle, - (Short128Mask) m); // specialize + return (ShortVector128) + super.rearrangeTemplate(ShortShuffle128.class, + ShortMask128.class, + (ShortShuffle128) shuffle, + (ShortMask128) m); // specialize } @Override @ForceInline - public Short128Vector rearrange(VectorShuffle s, + public ShortVector128 rearrange(VectorShuffle s, Vector v) { - return (Short128Vector) - super.rearrangeTemplate(Short128Shuffle.class, - (Short128Shuffle) s, - (Short128Vector) v); // specialize + return (ShortVector128) + super.rearrangeTemplate(ShortShuffle128.class, + (ShortShuffle128) s, + (ShortVector128) v); // specialize } @Override @ForceInline - public Short128Vector compress(VectorMask m) { - return (Short128Vector) - super.compressTemplate(Short128Mask.class, - (Short128Mask) m); // specialize + public ShortVector128 compress(VectorMask m) { + return (ShortVector128) + super.compressTemplate(ShortMask128.class, + (ShortMask128) m); // specialize } @Override @ForceInline - public Short128Vector expand(VectorMask m) { - return (Short128Vector) - super.expandTemplate(Short128Mask.class, - (Short128Mask) m); // specialize + public ShortVector128 expand(VectorMask m) { + return (ShortVector128) + super.expandTemplate(ShortMask128.class, + (ShortMask128) m); // specialize } @Override @ForceInline - public Short128Vector selectFrom(Vector v) { - return (Short128Vector) - super.selectFromTemplate((Short128Vector) v); // specialize + public ShortVector128 selectFrom(Vector v) { + return (ShortVector128) + super.selectFromTemplate((ShortVector128) v); // specialize } @Override @ForceInline - public Short128Vector selectFrom(Vector v, + public ShortVector128 selectFrom(Vector v, VectorMask m) { - return (Short128Vector) - super.selectFromTemplate((Short128Vector) v, - Short128Mask.class, (Short128Mask) m); // specialize + return (ShortVector128) + super.selectFromTemplate((ShortVector128) v, + ShortMask128.class, (ShortMask128) m); // specialize } @Override @ForceInline - public Short128Vector selectFrom(Vector v1, + public ShortVector128 selectFrom(Vector v1, Vector v2) { - return (Short128Vector) - super.selectFromTemplate((Short128Vector) v1, (Short128Vector) v2); // specialize + return (ShortVector128) + super.selectFromTemplate((ShortVector128) v1, (ShortVector128) v2); // specialize } @ForceInline @@ -550,7 +550,7 @@ final class Short128Vector extends ShortVector { @ForceInline @Override - public Short128Vector withLane(int i, short e) { + public ShortVector128 withLane(int i, short e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -565,7 +565,7 @@ final class Short128Vector extends ShortVector { } @ForceInline - public Short128Vector withLaneHelper(int i, short e) { + public ShortVector128 withLaneHelper(int i, short e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -578,19 +578,19 @@ final class Short128Vector extends ShortVector { // Mask - static final class Short128Mask extends AbstractMask { + static final class ShortMask128 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - Short128Mask(boolean[] bits) { + ShortMask128(boolean[] bits) { this(bits, 0); } - Short128Mask(boolean[] bits, int offset) { + ShortMask128(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Short128Mask(boolean val) { + ShortMask128(boolean val) { super(prepare(val)); } @@ -623,31 +623,31 @@ final class Short128Vector extends ShortVector { } @Override - Short128Mask uOp(MUnOp f) { + ShortMask128 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Short128Mask(res); + return new ShortMask128(res); } @Override - Short128Mask bOp(VectorMask m, MBinOp f) { + ShortMask128 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Short128Mask)m).getBits(); + boolean[] mbits = ((ShortMask128)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Short128Mask(res); + return new ShortMask128(res); } @ForceInline @Override public final - Short128Vector toVector() { - return (Short128Vector) super.toVectorTemplate(); // specialize + ShortVector128 toVector() { + return (ShortVector128) super.toVectorTemplate(); // specialize } /** @@ -680,25 +680,25 @@ final class Short128Vector extends ShortVector { @Override @ForceInline /*package-private*/ - Short128Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Short128Mask) VectorSupport.indexPartiallyInUpperRange( - Short128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Short128Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + ShortMask128 indexPartiallyInUpperRange(long offset, long limit) { + return (ShortMask128) VectorSupport.indexPartiallyInUpperRange( + ShortMask128.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ShortMask128) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Short128Mask not() { + public ShortMask128 not() { return xor(maskAll(true)); } @Override @ForceInline - public Short128Mask compress() { - return (Short128Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Short128Vector.class, Short128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ShortMask128 compress() { + return (ShortMask128)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ShortVector128.class, ShortMask128.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -707,30 +707,30 @@ final class Short128Vector extends ShortVector { @Override @ForceInline - public Short128Mask and(VectorMask mask) { + public ShortMask128 and(VectorMask mask) { Objects.requireNonNull(mask); - Short128Mask m = (Short128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Short128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask128 m = (ShortMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ShortMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Short128Mask or(VectorMask mask) { + public ShortMask128 or(VectorMask mask) { Objects.requireNonNull(mask); - Short128Mask m = (Short128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Short128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask128 m = (ShortMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ShortMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Short128Mask xor(VectorMask mask) { + public ShortMask128 xor(VectorMask mask) { Objects.requireNonNull(mask); - Short128Mask m = (Short128Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Short128Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask128 m = (ShortMask128)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ShortMask128.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -740,21 +740,21 @@ final class Short128Vector extends ShortVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Short128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ShortMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Short128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ShortMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Short128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ShortMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -764,7 +764,7 @@ final class Short128Vector extends ShortVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Short128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ShortMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -774,7 +774,7 @@ final class Short128Vector extends ShortVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Short128Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ShortMask128.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -783,48 +783,48 @@ final class Short128Vector extends ShortVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Short128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ShortMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Short128Mask)m).getBits())); + (m, __) -> anyTrueHelper(((ShortMask128)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Short128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ShortMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Short128Mask)m).getBits())); + (m, __) -> allTrueHelper(((ShortMask128)m).getBits())); } @ForceInline /*package-private*/ - static Short128Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Short128Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ShortMask128 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ShortMask128.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Short128Mask TRUE_MASK = new Short128Mask(true); - private static final Short128Mask FALSE_MASK = new Short128Mask(false); + private static final ShortMask128 TRUE_MASK = new ShortMask128(true); + private static final ShortMask128 FALSE_MASK = new ShortMask128(false); } // Shuffle - static final class Short128Shuffle extends AbstractShuffle { + static final class ShortShuffle128 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - Short128Shuffle(short[] indices) { + ShortShuffle128(short[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Short128Shuffle(int[] indices, int i) { + ShortShuffle128(int[] indices, int i) { this(prepare(indices, i)); } - Short128Shuffle(IntUnaryOperator fn) { + ShortShuffle128(IntUnaryOperator fn) { this(prepare(fn)); } @@ -844,23 +844,23 @@ final class Short128Vector extends ShortVector { assert(VLENGTH < Short.MAX_VALUE); assert(Short.MIN_VALUE <= -VLENGTH); } - static final Short128Shuffle IOTA = new Short128Shuffle(IDENTITY); + static final ShortShuffle128 IOTA = new ShortShuffle128(IDENTITY); @Override @ForceInline - public Short128Vector toVector() { + public ShortVector128 toVector() { return toBitsVector(); } @Override @ForceInline - Short128Vector toBitsVector() { - return (Short128Vector) super.toBitsVectorTemplate(); + ShortVector128 toBitsVector() { + return (ShortVector128) super.toBitsVectorTemplate(); } @Override - Short128Vector toBitsVector0() { - return ((Short128Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ShortVector128 toBitsVector0() { + return ((ShortVector128) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -897,30 +897,30 @@ final class Short128Vector extends ShortVector { @Override @ForceInline - public final Short128Mask laneIsValid() { - return (Short128Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final ShortMask128 laneIsValid() { + return (ShortMask128) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Short128Shuffle rearrange(VectorShuffle shuffle) { - Short128Shuffle concreteShuffle = (Short128Shuffle) shuffle; - return (Short128Shuffle) toBitsVector().rearrange(concreteShuffle) + public final ShortShuffle128 rearrange(VectorShuffle shuffle) { + ShortShuffle128 concreteShuffle = (ShortShuffle128) shuffle; + return (ShortShuffle128) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Short128Shuffle wrapIndexes() { - Short128Vector v = toBitsVector(); + public final ShortShuffle128 wrapIndexes() { + ShortVector128 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Short128Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ShortVector128) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Short128Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ShortVector128) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Short128Shuffle) v.toShuffle(vspecies(), false); + return (ShortShuffle128) v.toShuffle(vspecies(), false); } private static short[] prepare(int[] indices, int offset) { @@ -971,14 +971,14 @@ final class Short128Vector extends ShortVector { @Override final ShortVector fromArray0(short[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Short128Mask.class, a, offset, (Short128Mask) m, offsetInRange); // specialize + return super.fromArray0Template(ShortMask128.class, a, offset, (ShortMask128) m, offsetInRange); // specialize } @ForceInline @Override final ShortVector fromArray0(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Short128Mask.class, a, offset, indexMap, mapOffset, (Short128Mask) m); + return super.fromArray0Template(ShortMask128.class, a, offset, indexMap, mapOffset, (ShortMask128) m); } @ForceInline @@ -992,7 +992,7 @@ final class Short128Vector extends ShortVector { @Override final ShortVector fromCharArray0(char[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromCharArray0Template(Short128Mask.class, a, offset, (Short128Mask) m, offsetInRange); // specialize + return super.fromCharArray0Template(ShortMask128.class, a, offset, (ShortMask128) m, offsetInRange); // specialize } @@ -1007,7 +1007,7 @@ final class Short128Vector extends ShortVector { @Override final ShortVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Short128Mask.class, ms, offset, (Short128Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ShortMask128.class, ms, offset, (ShortMask128) m, offsetInRange); // specialize } @ForceInline @@ -1021,7 +1021,7 @@ final class Short128Vector extends ShortVector { @Override final void intoArray0(short[] a, int offset, VectorMask m) { - super.intoArray0Template(Short128Mask.class, a, offset, (Short128Mask) m); + super.intoArray0Template(ShortMask128.class, a, offset, (ShortMask128) m); } @@ -1030,14 +1030,14 @@ final class Short128Vector extends ShortVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Short128Mask.class, ms, offset, (Short128Mask) m); + super.intoMemorySegment0Template(ShortMask128.class, ms, offset, (ShortMask128) m); } @ForceInline @Override final void intoCharArray0(char[] a, int offset, VectorMask m) { - super.intoCharArray0Template(Short128Mask.class, a, offset, (Short128Mask) m); + super.intoCharArray0Template(ShortMask128.class, a, offset, (ShortMask128) m); } // End of specialized low-level memory operations. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short256Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector256.java similarity index 67% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short256Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector256.java index a3841eb63dc..d3f526a636d 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short256Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector256.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Short256Vector extends ShortVector { +final class ShortVector256 extends ShortVector { static final ShortSpecies VSPECIES = (ShortSpecies) ShortVector.SPECIES_256; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Short256Vector.class; + static final Class VCLASS = ShortVector256.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Short256Vector extends ShortVector { static final Class ETYPE = short.class; // used by the JVM - Short256Vector(short[] v) { + ShortVector256(short[] v) { super(v); } - // For compatibility as Short256Vector::new, + // For compatibility as ShortVector256::new, // stored into species.vectorFactory. - Short256Vector(Object v) { + ShortVector256(Object v) { this((short[]) v); } - static final Short256Vector ZERO = new Short256Vector(new short[VLENGTH]); - static final Short256Vector IOTA = new Short256Vector(VSPECIES.iotaArray()); + static final ShortVector256 ZERO = new ShortVector256(new short[VLENGTH]); + static final ShortVector256 IOTA = new ShortVector256(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Short256Vector extends ShortVector { @Override @ForceInline - public final Short256Vector broadcast(short e) { - return (Short256Vector) super.broadcastTemplate(e); // specialize + public final ShortVector256 broadcast(short e) { + return (ShortVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Short256Vector broadcast(long e) { - return (Short256Vector) super.broadcastTemplate(e); // specialize + public final ShortVector256 broadcast(long e) { + return (ShortVector256) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Short256Mask maskFromArray(boolean[] bits) { - return new Short256Mask(bits); + ShortMask256 maskFromArray(boolean[] bits) { + return new ShortMask256(bits); } @Override @ForceInline - Short256Shuffle iotaShuffle() { return Short256Shuffle.IOTA; } + ShortShuffle256 iotaShuffle() { return ShortShuffle256.IOTA; } @Override @ForceInline - Short256Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Short256Shuffle) iotaShuffleTemplate((short) start, (short) step, wrap); + ShortShuffle256 iotaShuffle(int start, int step, boolean wrap) { + return (ShortShuffle256) iotaShuffleTemplate((short) start, (short) step, wrap); } @Override @ForceInline - Short256Shuffle shuffleFromArray(int[] indices, int i) { return new Short256Shuffle(indices, i); } + ShortShuffle256 shuffleFromArray(int[] indices, int i) { return new ShortShuffle256(indices, i); } @Override @ForceInline - Short256Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Short256Shuffle(fn); } + ShortShuffle256 shuffleFromOp(IntUnaryOperator fn) { return new ShortShuffle256(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Short256Vector vectorFactory(short[] vec) { - return new Short256Vector(vec); + ShortVector256 vectorFactory(short[] vec) { + return new ShortVector256(vec); } @ForceInline final @Override - Byte256Vector asByteVectorRaw() { - return (Byte256Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector256 asByteVectorRaw() { + return (ByteVector256) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Short256Vector extends ShortVector { @ForceInline final @Override - Short256Vector uOp(FUnOp f) { - return (Short256Vector) super.uOpTemplate(f); // specialize + ShortVector256 uOp(FUnOp f) { + return (ShortVector256) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Short256Vector uOp(VectorMask m, FUnOp f) { - return (Short256Vector) - super.uOpTemplate((Short256Mask)m, f); // specialize + ShortVector256 uOp(VectorMask m, FUnOp f) { + return (ShortVector256) + super.uOpTemplate((ShortMask256)m, f); // specialize } // Binary operator @ForceInline final @Override - Short256Vector bOp(Vector v, FBinOp f) { - return (Short256Vector) super.bOpTemplate((Short256Vector)v, f); // specialize + ShortVector256 bOp(Vector v, FBinOp f) { + return (ShortVector256) super.bOpTemplate((ShortVector256)v, f); // specialize } @ForceInline final @Override - Short256Vector bOp(Vector v, + ShortVector256 bOp(Vector v, VectorMask m, FBinOp f) { - return (Short256Vector) - super.bOpTemplate((Short256Vector)v, (Short256Mask)m, + return (ShortVector256) + super.bOpTemplate((ShortVector256)v, (ShortMask256)m, f); // specialize } @@ -219,19 +219,19 @@ final class Short256Vector extends ShortVector { @ForceInline final @Override - Short256Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Short256Vector) - super.tOpTemplate((Short256Vector)v1, (Short256Vector)v2, + ShortVector256 tOp(Vector v1, Vector v2, FTriOp f) { + return (ShortVector256) + super.tOpTemplate((ShortVector256)v1, (ShortVector256)v2, f); // specialize } @ForceInline final @Override - Short256Vector tOp(Vector v1, Vector v2, + ShortVector256 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Short256Vector) - super.tOpTemplate((Short256Vector)v1, (Short256Vector)v2, - (Short256Mask)m, f); // specialize + return (ShortVector256) + super.tOpTemplate((ShortVector256)v1, (ShortVector256)v2, + (ShortMask256)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Short256Vector extends ShortVector { @Override @ForceInline - public Short256Vector lanewise(Unary op) { - return (Short256Vector) super.lanewiseTemplate(op); // specialize + public ShortVector256 lanewise(Unary op) { + return (ShortVector256) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Short256Vector lanewise(Unary op, VectorMask m) { - return (Short256Vector) super.lanewiseTemplate(op, Short256Mask.class, (Short256Mask) m); // specialize + public ShortVector256 lanewise(Unary op, VectorMask m) { + return (ShortVector256) super.lanewiseTemplate(op, ShortMask256.class, (ShortMask256) m); // specialize } @Override @ForceInline - public Short256Vector lanewise(Binary op, Vector v) { - return (Short256Vector) super.lanewiseTemplate(op, v); // specialize + public ShortVector256 lanewise(Binary op, Vector v) { + return (ShortVector256) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Short256Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Short256Vector) super.lanewiseTemplate(op, Short256Mask.class, v, (Short256Mask) m); // specialize + public ShortVector256 lanewise(Binary op, Vector v, VectorMask m) { + return (ShortVector256) super.lanewiseTemplate(op, ShortMask256.class, v, (ShortMask256) m); // specialize } /*package-private*/ @Override - @ForceInline Short256Vector + @ForceInline ShortVector256 lanewiseShift(VectorOperators.Binary op, int e) { - return (Short256Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (ShortVector256) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Short256Vector + @ForceInline ShortVector256 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Short256Vector) super.lanewiseShiftTemplate(op, Short256Mask.class, e, (Short256Mask) m); // specialize + return (ShortVector256) super.lanewiseShiftTemplate(op, ShortMask256.class, e, (ShortMask256) m); // specialize } /*package-private*/ @Override @ForceInline public final - Short256Vector + ShortVector256 lanewise(Ternary op, Vector v1, Vector v2) { - return (Short256Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ShortVector256) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Short256Vector + ShortVector256 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Short256Vector) super.lanewiseTemplate(op, Short256Mask.class, v1, v2, (Short256Mask) m); // specialize + return (ShortVector256) super.lanewiseTemplate(op, ShortMask256.class, v1, v2, (ShortMask256) m); // specialize } @Override @ForceInline public final - Short256Vector addIndex(int scale) { - return (Short256Vector) super.addIndexTemplate(scale); // specialize + ShortVector256 addIndex(int scale) { + return (ShortVector256) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Short256Vector extends ShortVector { @ForceInline public final short reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Short256Mask.class, (Short256Mask) m); // specialized + return super.reduceLanesTemplate(op, ShortMask256.class, (ShortMask256) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Short256Vector extends ShortVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Short256Mask.class, (Short256Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, ShortMask256.class, (ShortMask256) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Short256Vector extends ShortVector { @Override @ForceInline - public final Short256Shuffle toShuffle() { - return (Short256Shuffle) toShuffle(vspecies(), false); + public final ShortShuffle256 toShuffle() { + return (ShortShuffle256) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Short256Mask test(Test op) { - return super.testTemplate(Short256Mask.class, op); // specialize + public final ShortMask256 test(Test op) { + return super.testTemplate(ShortMask256.class, op); // specialize } @Override @ForceInline - public final Short256Mask test(Test op, VectorMask m) { - return super.testTemplate(Short256Mask.class, op, (Short256Mask) m); // specialize + public final ShortMask256 test(Test op, VectorMask m) { + return super.testTemplate(ShortMask256.class, op, (ShortMask256) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Short256Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Short256Mask.class, op, v); // specialize + public final ShortMask256 compare(Comparison op, Vector v) { + return super.compareTemplate(ShortMask256.class, op, v); // specialize } @Override @ForceInline - public final Short256Mask compare(Comparison op, short s) { - return super.compareTemplate(Short256Mask.class, op, s); // specialize + public final ShortMask256 compare(Comparison op, short s) { + return super.compareTemplate(ShortMask256.class, op, s); // specialize } @Override @ForceInline - public final Short256Mask compare(Comparison op, long s) { - return super.compareTemplate(Short256Mask.class, op, s); // specialize + public final ShortMask256 compare(Comparison op, long s) { + return super.compareTemplate(ShortMask256.class, op, s); // specialize } @Override @ForceInline - public final Short256Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Short256Mask.class, op, v, (Short256Mask) m); + public final ShortMask256 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ShortMask256.class, op, v, (ShortMask256) m); } @Override @ForceInline - public Short256Vector blend(Vector v, VectorMask m) { - return (Short256Vector) - super.blendTemplate(Short256Mask.class, - (Short256Vector) v, - (Short256Mask) m); // specialize + public ShortVector256 blend(Vector v, VectorMask m) { + return (ShortVector256) + super.blendTemplate(ShortMask256.class, + (ShortVector256) v, + (ShortMask256) m); // specialize } @Override @ForceInline - public Short256Vector slice(int origin, Vector v) { - return (Short256Vector) super.sliceTemplate(origin, v); // specialize + public ShortVector256 slice(int origin, Vector v) { + return (ShortVector256) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Short256Vector slice(int origin) { - return (Short256Vector) super.sliceTemplate(origin); // specialize + public ShortVector256 slice(int origin) { + return (ShortVector256) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Short256Vector unslice(int origin, Vector w, int part) { - return (Short256Vector) super.unsliceTemplate(origin, w, part); // specialize + public ShortVector256 unslice(int origin, Vector w, int part) { + return (ShortVector256) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Short256Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Short256Vector) - super.unsliceTemplate(Short256Mask.class, + public ShortVector256 unslice(int origin, Vector w, int part, VectorMask m) { + return (ShortVector256) + super.unsliceTemplate(ShortMask256.class, origin, w, part, - (Short256Mask) m); // specialize + (ShortMask256) m); // specialize } @Override @ForceInline - public Short256Vector unslice(int origin) { - return (Short256Vector) super.unsliceTemplate(origin); // specialize + public ShortVector256 unslice(int origin) { + return (ShortVector256) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Short256Vector rearrange(VectorShuffle s) { - return (Short256Vector) - super.rearrangeTemplate(Short256Shuffle.class, - (Short256Shuffle) s); // specialize + public ShortVector256 rearrange(VectorShuffle s) { + return (ShortVector256) + super.rearrangeTemplate(ShortShuffle256.class, + (ShortShuffle256) s); // specialize } @Override @ForceInline - public Short256Vector rearrange(VectorShuffle shuffle, + public ShortVector256 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Short256Vector) - super.rearrangeTemplate(Short256Shuffle.class, - Short256Mask.class, - (Short256Shuffle) shuffle, - (Short256Mask) m); // specialize + return (ShortVector256) + super.rearrangeTemplate(ShortShuffle256.class, + ShortMask256.class, + (ShortShuffle256) shuffle, + (ShortMask256) m); // specialize } @Override @ForceInline - public Short256Vector rearrange(VectorShuffle s, + public ShortVector256 rearrange(VectorShuffle s, Vector v) { - return (Short256Vector) - super.rearrangeTemplate(Short256Shuffle.class, - (Short256Shuffle) s, - (Short256Vector) v); // specialize + return (ShortVector256) + super.rearrangeTemplate(ShortShuffle256.class, + (ShortShuffle256) s, + (ShortVector256) v); // specialize } @Override @ForceInline - public Short256Vector compress(VectorMask m) { - return (Short256Vector) - super.compressTemplate(Short256Mask.class, - (Short256Mask) m); // specialize + public ShortVector256 compress(VectorMask m) { + return (ShortVector256) + super.compressTemplate(ShortMask256.class, + (ShortMask256) m); // specialize } @Override @ForceInline - public Short256Vector expand(VectorMask m) { - return (Short256Vector) - super.expandTemplate(Short256Mask.class, - (Short256Mask) m); // specialize + public ShortVector256 expand(VectorMask m) { + return (ShortVector256) + super.expandTemplate(ShortMask256.class, + (ShortMask256) m); // specialize } @Override @ForceInline - public Short256Vector selectFrom(Vector v) { - return (Short256Vector) - super.selectFromTemplate((Short256Vector) v); // specialize + public ShortVector256 selectFrom(Vector v) { + return (ShortVector256) + super.selectFromTemplate((ShortVector256) v); // specialize } @Override @ForceInline - public Short256Vector selectFrom(Vector v, + public ShortVector256 selectFrom(Vector v, VectorMask m) { - return (Short256Vector) - super.selectFromTemplate((Short256Vector) v, - Short256Mask.class, (Short256Mask) m); // specialize + return (ShortVector256) + super.selectFromTemplate((ShortVector256) v, + ShortMask256.class, (ShortMask256) m); // specialize } @Override @ForceInline - public Short256Vector selectFrom(Vector v1, + public ShortVector256 selectFrom(Vector v1, Vector v2) { - return (Short256Vector) - super.selectFromTemplate((Short256Vector) v1, (Short256Vector) v2); // specialize + return (ShortVector256) + super.selectFromTemplate((ShortVector256) v1, (ShortVector256) v2); // specialize } @ForceInline @@ -558,7 +558,7 @@ final class Short256Vector extends ShortVector { @ForceInline @Override - public Short256Vector withLane(int i, short e) { + public ShortVector256 withLane(int i, short e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -581,7 +581,7 @@ final class Short256Vector extends ShortVector { } @ForceInline - public Short256Vector withLaneHelper(int i, short e) { + public ShortVector256 withLaneHelper(int i, short e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -594,19 +594,19 @@ final class Short256Vector extends ShortVector { // Mask - static final class Short256Mask extends AbstractMask { + static final class ShortMask256 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - Short256Mask(boolean[] bits) { + ShortMask256(boolean[] bits) { this(bits, 0); } - Short256Mask(boolean[] bits, int offset) { + ShortMask256(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Short256Mask(boolean val) { + ShortMask256(boolean val) { super(prepare(val)); } @@ -639,31 +639,31 @@ final class Short256Vector extends ShortVector { } @Override - Short256Mask uOp(MUnOp f) { + ShortMask256 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Short256Mask(res); + return new ShortMask256(res); } @Override - Short256Mask bOp(VectorMask m, MBinOp f) { + ShortMask256 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Short256Mask)m).getBits(); + boolean[] mbits = ((ShortMask256)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Short256Mask(res); + return new ShortMask256(res); } @ForceInline @Override public final - Short256Vector toVector() { - return (Short256Vector) super.toVectorTemplate(); // specialize + ShortVector256 toVector() { + return (ShortVector256) super.toVectorTemplate(); // specialize } /** @@ -696,25 +696,25 @@ final class Short256Vector extends ShortVector { @Override @ForceInline /*package-private*/ - Short256Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Short256Mask) VectorSupport.indexPartiallyInUpperRange( - Short256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Short256Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + ShortMask256 indexPartiallyInUpperRange(long offset, long limit) { + return (ShortMask256) VectorSupport.indexPartiallyInUpperRange( + ShortMask256.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ShortMask256) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Short256Mask not() { + public ShortMask256 not() { return xor(maskAll(true)); } @Override @ForceInline - public Short256Mask compress() { - return (Short256Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Short256Vector.class, Short256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ShortMask256 compress() { + return (ShortMask256)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ShortVector256.class, ShortMask256.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -723,30 +723,30 @@ final class Short256Vector extends ShortVector { @Override @ForceInline - public Short256Mask and(VectorMask mask) { + public ShortMask256 and(VectorMask mask) { Objects.requireNonNull(mask); - Short256Mask m = (Short256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Short256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask256 m = (ShortMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ShortMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Short256Mask or(VectorMask mask) { + public ShortMask256 or(VectorMask mask) { Objects.requireNonNull(mask); - Short256Mask m = (Short256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Short256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask256 m = (ShortMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ShortMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Short256Mask xor(VectorMask mask) { + public ShortMask256 xor(VectorMask mask) { Objects.requireNonNull(mask); - Short256Mask m = (Short256Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Short256Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask256 m = (ShortMask256)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ShortMask256.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -756,21 +756,21 @@ final class Short256Vector extends ShortVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Short256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ShortMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Short256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ShortMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Short256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ShortMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -780,7 +780,7 @@ final class Short256Vector extends ShortVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Short256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ShortMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -790,7 +790,7 @@ final class Short256Vector extends ShortVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Short256Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ShortMask256.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -799,48 +799,48 @@ final class Short256Vector extends ShortVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Short256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ShortMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Short256Mask)m).getBits())); + (m, __) -> anyTrueHelper(((ShortMask256)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Short256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ShortMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Short256Mask)m).getBits())); + (m, __) -> allTrueHelper(((ShortMask256)m).getBits())); } @ForceInline /*package-private*/ - static Short256Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Short256Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ShortMask256 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ShortMask256.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Short256Mask TRUE_MASK = new Short256Mask(true); - private static final Short256Mask FALSE_MASK = new Short256Mask(false); + private static final ShortMask256 TRUE_MASK = new ShortMask256(true); + private static final ShortMask256 FALSE_MASK = new ShortMask256(false); } // Shuffle - static final class Short256Shuffle extends AbstractShuffle { + static final class ShortShuffle256 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - Short256Shuffle(short[] indices) { + ShortShuffle256(short[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Short256Shuffle(int[] indices, int i) { + ShortShuffle256(int[] indices, int i) { this(prepare(indices, i)); } - Short256Shuffle(IntUnaryOperator fn) { + ShortShuffle256(IntUnaryOperator fn) { this(prepare(fn)); } @@ -860,23 +860,23 @@ final class Short256Vector extends ShortVector { assert(VLENGTH < Short.MAX_VALUE); assert(Short.MIN_VALUE <= -VLENGTH); } - static final Short256Shuffle IOTA = new Short256Shuffle(IDENTITY); + static final ShortShuffle256 IOTA = new ShortShuffle256(IDENTITY); @Override @ForceInline - public Short256Vector toVector() { + public ShortVector256 toVector() { return toBitsVector(); } @Override @ForceInline - Short256Vector toBitsVector() { - return (Short256Vector) super.toBitsVectorTemplate(); + ShortVector256 toBitsVector() { + return (ShortVector256) super.toBitsVectorTemplate(); } @Override - Short256Vector toBitsVector0() { - return ((Short256Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ShortVector256 toBitsVector0() { + return ((ShortVector256) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -913,30 +913,30 @@ final class Short256Vector extends ShortVector { @Override @ForceInline - public final Short256Mask laneIsValid() { - return (Short256Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final ShortMask256 laneIsValid() { + return (ShortMask256) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Short256Shuffle rearrange(VectorShuffle shuffle) { - Short256Shuffle concreteShuffle = (Short256Shuffle) shuffle; - return (Short256Shuffle) toBitsVector().rearrange(concreteShuffle) + public final ShortShuffle256 rearrange(VectorShuffle shuffle) { + ShortShuffle256 concreteShuffle = (ShortShuffle256) shuffle; + return (ShortShuffle256) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Short256Shuffle wrapIndexes() { - Short256Vector v = toBitsVector(); + public final ShortShuffle256 wrapIndexes() { + ShortVector256 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Short256Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ShortVector256) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Short256Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ShortVector256) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Short256Shuffle) v.toShuffle(vspecies(), false); + return (ShortShuffle256) v.toShuffle(vspecies(), false); } private static short[] prepare(int[] indices, int offset) { @@ -987,14 +987,14 @@ final class Short256Vector extends ShortVector { @Override final ShortVector fromArray0(short[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Short256Mask.class, a, offset, (Short256Mask) m, offsetInRange); // specialize + return super.fromArray0Template(ShortMask256.class, a, offset, (ShortMask256) m, offsetInRange); // specialize } @ForceInline @Override final ShortVector fromArray0(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Short256Mask.class, a, offset, indexMap, mapOffset, (Short256Mask) m); + return super.fromArray0Template(ShortMask256.class, a, offset, indexMap, mapOffset, (ShortMask256) m); } @ForceInline @@ -1008,7 +1008,7 @@ final class Short256Vector extends ShortVector { @Override final ShortVector fromCharArray0(char[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromCharArray0Template(Short256Mask.class, a, offset, (Short256Mask) m, offsetInRange); // specialize + return super.fromCharArray0Template(ShortMask256.class, a, offset, (ShortMask256) m, offsetInRange); // specialize } @@ -1023,7 +1023,7 @@ final class Short256Vector extends ShortVector { @Override final ShortVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Short256Mask.class, ms, offset, (Short256Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ShortMask256.class, ms, offset, (ShortMask256) m, offsetInRange); // specialize } @ForceInline @@ -1037,7 +1037,7 @@ final class Short256Vector extends ShortVector { @Override final void intoArray0(short[] a, int offset, VectorMask m) { - super.intoArray0Template(Short256Mask.class, a, offset, (Short256Mask) m); + super.intoArray0Template(ShortMask256.class, a, offset, (ShortMask256) m); } @@ -1046,14 +1046,14 @@ final class Short256Vector extends ShortVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Short256Mask.class, ms, offset, (Short256Mask) m); + super.intoMemorySegment0Template(ShortMask256.class, ms, offset, (ShortMask256) m); } @ForceInline @Override final void intoCharArray0(char[] a, int offset, VectorMask m) { - super.intoCharArray0Template(Short256Mask.class, a, offset, (Short256Mask) m); + super.intoCharArray0Template(ShortMask256.class, a, offset, (ShortMask256) m); } // End of specialized low-level memory operations. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short512Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector512.java similarity index 69% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short512Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector512.java index 3da20257a8d..2d11eedc28c 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short512Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector512.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Short512Vector extends ShortVector { +final class ShortVector512 extends ShortVector { static final ShortSpecies VSPECIES = (ShortSpecies) ShortVector.SPECIES_512; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Short512Vector.class; + static final Class VCLASS = ShortVector512.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Short512Vector extends ShortVector { static final Class ETYPE = short.class; // used by the JVM - Short512Vector(short[] v) { + ShortVector512(short[] v) { super(v); } - // For compatibility as Short512Vector::new, + // For compatibility as ShortVector512::new, // stored into species.vectorFactory. - Short512Vector(Object v) { + ShortVector512(Object v) { this((short[]) v); } - static final Short512Vector ZERO = new Short512Vector(new short[VLENGTH]); - static final Short512Vector IOTA = new Short512Vector(VSPECIES.iotaArray()); + static final ShortVector512 ZERO = new ShortVector512(new short[VLENGTH]); + static final ShortVector512 IOTA = new ShortVector512(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Short512Vector extends ShortVector { @Override @ForceInline - public final Short512Vector broadcast(short e) { - return (Short512Vector) super.broadcastTemplate(e); // specialize + public final ShortVector512 broadcast(short e) { + return (ShortVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Short512Vector broadcast(long e) { - return (Short512Vector) super.broadcastTemplate(e); // specialize + public final ShortVector512 broadcast(long e) { + return (ShortVector512) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Short512Mask maskFromArray(boolean[] bits) { - return new Short512Mask(bits); + ShortMask512 maskFromArray(boolean[] bits) { + return new ShortMask512(bits); } @Override @ForceInline - Short512Shuffle iotaShuffle() { return Short512Shuffle.IOTA; } + ShortShuffle512 iotaShuffle() { return ShortShuffle512.IOTA; } @Override @ForceInline - Short512Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Short512Shuffle) iotaShuffleTemplate((short) start, (short) step, wrap); + ShortShuffle512 iotaShuffle(int start, int step, boolean wrap) { + return (ShortShuffle512) iotaShuffleTemplate((short) start, (short) step, wrap); } @Override @ForceInline - Short512Shuffle shuffleFromArray(int[] indices, int i) { return new Short512Shuffle(indices, i); } + ShortShuffle512 shuffleFromArray(int[] indices, int i) { return new ShortShuffle512(indices, i); } @Override @ForceInline - Short512Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Short512Shuffle(fn); } + ShortShuffle512 shuffleFromOp(IntUnaryOperator fn) { return new ShortShuffle512(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Short512Vector vectorFactory(short[] vec) { - return new Short512Vector(vec); + ShortVector512 vectorFactory(short[] vec) { + return new ShortVector512(vec); } @ForceInline final @Override - Byte512Vector asByteVectorRaw() { - return (Byte512Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector512 asByteVectorRaw() { + return (ByteVector512) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Short512Vector extends ShortVector { @ForceInline final @Override - Short512Vector uOp(FUnOp f) { - return (Short512Vector) super.uOpTemplate(f); // specialize + ShortVector512 uOp(FUnOp f) { + return (ShortVector512) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Short512Vector uOp(VectorMask m, FUnOp f) { - return (Short512Vector) - super.uOpTemplate((Short512Mask)m, f); // specialize + ShortVector512 uOp(VectorMask m, FUnOp f) { + return (ShortVector512) + super.uOpTemplate((ShortMask512)m, f); // specialize } // Binary operator @ForceInline final @Override - Short512Vector bOp(Vector v, FBinOp f) { - return (Short512Vector) super.bOpTemplate((Short512Vector)v, f); // specialize + ShortVector512 bOp(Vector v, FBinOp f) { + return (ShortVector512) super.bOpTemplate((ShortVector512)v, f); // specialize } @ForceInline final @Override - Short512Vector bOp(Vector v, + ShortVector512 bOp(Vector v, VectorMask m, FBinOp f) { - return (Short512Vector) - super.bOpTemplate((Short512Vector)v, (Short512Mask)m, + return (ShortVector512) + super.bOpTemplate((ShortVector512)v, (ShortMask512)m, f); // specialize } @@ -219,19 +219,19 @@ final class Short512Vector extends ShortVector { @ForceInline final @Override - Short512Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Short512Vector) - super.tOpTemplate((Short512Vector)v1, (Short512Vector)v2, + ShortVector512 tOp(Vector v1, Vector v2, FTriOp f) { + return (ShortVector512) + super.tOpTemplate((ShortVector512)v1, (ShortVector512)v2, f); // specialize } @ForceInline final @Override - Short512Vector tOp(Vector v1, Vector v2, + ShortVector512 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Short512Vector) - super.tOpTemplate((Short512Vector)v1, (Short512Vector)v2, - (Short512Mask)m, f); // specialize + return (ShortVector512) + super.tOpTemplate((ShortVector512)v1, (ShortVector512)v2, + (ShortMask512)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Short512Vector extends ShortVector { @Override @ForceInline - public Short512Vector lanewise(Unary op) { - return (Short512Vector) super.lanewiseTemplate(op); // specialize + public ShortVector512 lanewise(Unary op) { + return (ShortVector512) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Short512Vector lanewise(Unary op, VectorMask m) { - return (Short512Vector) super.lanewiseTemplate(op, Short512Mask.class, (Short512Mask) m); // specialize + public ShortVector512 lanewise(Unary op, VectorMask m) { + return (ShortVector512) super.lanewiseTemplate(op, ShortMask512.class, (ShortMask512) m); // specialize } @Override @ForceInline - public Short512Vector lanewise(Binary op, Vector v) { - return (Short512Vector) super.lanewiseTemplate(op, v); // specialize + public ShortVector512 lanewise(Binary op, Vector v) { + return (ShortVector512) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Short512Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Short512Vector) super.lanewiseTemplate(op, Short512Mask.class, v, (Short512Mask) m); // specialize + public ShortVector512 lanewise(Binary op, Vector v, VectorMask m) { + return (ShortVector512) super.lanewiseTemplate(op, ShortMask512.class, v, (ShortMask512) m); // specialize } /*package-private*/ @Override - @ForceInline Short512Vector + @ForceInline ShortVector512 lanewiseShift(VectorOperators.Binary op, int e) { - return (Short512Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (ShortVector512) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Short512Vector + @ForceInline ShortVector512 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Short512Vector) super.lanewiseShiftTemplate(op, Short512Mask.class, e, (Short512Mask) m); // specialize + return (ShortVector512) super.lanewiseShiftTemplate(op, ShortMask512.class, e, (ShortMask512) m); // specialize } /*package-private*/ @Override @ForceInline public final - Short512Vector + ShortVector512 lanewise(Ternary op, Vector v1, Vector v2) { - return (Short512Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ShortVector512) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Short512Vector + ShortVector512 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Short512Vector) super.lanewiseTemplate(op, Short512Mask.class, v1, v2, (Short512Mask) m); // specialize + return (ShortVector512) super.lanewiseTemplate(op, ShortMask512.class, v1, v2, (ShortMask512) m); // specialize } @Override @ForceInline public final - Short512Vector addIndex(int scale) { - return (Short512Vector) super.addIndexTemplate(scale); // specialize + ShortVector512 addIndex(int scale) { + return (ShortVector512) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Short512Vector extends ShortVector { @ForceInline public final short reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Short512Mask.class, (Short512Mask) m); // specialized + return super.reduceLanesTemplate(op, ShortMask512.class, (ShortMask512) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Short512Vector extends ShortVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Short512Mask.class, (Short512Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, ShortMask512.class, (ShortMask512) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Short512Vector extends ShortVector { @Override @ForceInline - public final Short512Shuffle toShuffle() { - return (Short512Shuffle) toShuffle(vspecies(), false); + public final ShortShuffle512 toShuffle() { + return (ShortShuffle512) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Short512Mask test(Test op) { - return super.testTemplate(Short512Mask.class, op); // specialize + public final ShortMask512 test(Test op) { + return super.testTemplate(ShortMask512.class, op); // specialize } @Override @ForceInline - public final Short512Mask test(Test op, VectorMask m) { - return super.testTemplate(Short512Mask.class, op, (Short512Mask) m); // specialize + public final ShortMask512 test(Test op, VectorMask m) { + return super.testTemplate(ShortMask512.class, op, (ShortMask512) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Short512Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Short512Mask.class, op, v); // specialize + public final ShortMask512 compare(Comparison op, Vector v) { + return super.compareTemplate(ShortMask512.class, op, v); // specialize } @Override @ForceInline - public final Short512Mask compare(Comparison op, short s) { - return super.compareTemplate(Short512Mask.class, op, s); // specialize + public final ShortMask512 compare(Comparison op, short s) { + return super.compareTemplate(ShortMask512.class, op, s); // specialize } @Override @ForceInline - public final Short512Mask compare(Comparison op, long s) { - return super.compareTemplate(Short512Mask.class, op, s); // specialize + public final ShortMask512 compare(Comparison op, long s) { + return super.compareTemplate(ShortMask512.class, op, s); // specialize } @Override @ForceInline - public final Short512Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Short512Mask.class, op, v, (Short512Mask) m); + public final ShortMask512 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ShortMask512.class, op, v, (ShortMask512) m); } @Override @ForceInline - public Short512Vector blend(Vector v, VectorMask m) { - return (Short512Vector) - super.blendTemplate(Short512Mask.class, - (Short512Vector) v, - (Short512Mask) m); // specialize + public ShortVector512 blend(Vector v, VectorMask m) { + return (ShortVector512) + super.blendTemplate(ShortMask512.class, + (ShortVector512) v, + (ShortMask512) m); // specialize } @Override @ForceInline - public Short512Vector slice(int origin, Vector v) { - return (Short512Vector) super.sliceTemplate(origin, v); // specialize + public ShortVector512 slice(int origin, Vector v) { + return (ShortVector512) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Short512Vector slice(int origin) { - return (Short512Vector) super.sliceTemplate(origin); // specialize + public ShortVector512 slice(int origin) { + return (ShortVector512) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Short512Vector unslice(int origin, Vector w, int part) { - return (Short512Vector) super.unsliceTemplate(origin, w, part); // specialize + public ShortVector512 unslice(int origin, Vector w, int part) { + return (ShortVector512) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Short512Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Short512Vector) - super.unsliceTemplate(Short512Mask.class, + public ShortVector512 unslice(int origin, Vector w, int part, VectorMask m) { + return (ShortVector512) + super.unsliceTemplate(ShortMask512.class, origin, w, part, - (Short512Mask) m); // specialize + (ShortMask512) m); // specialize } @Override @ForceInline - public Short512Vector unslice(int origin) { - return (Short512Vector) super.unsliceTemplate(origin); // specialize + public ShortVector512 unslice(int origin) { + return (ShortVector512) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Short512Vector rearrange(VectorShuffle s) { - return (Short512Vector) - super.rearrangeTemplate(Short512Shuffle.class, - (Short512Shuffle) s); // specialize + public ShortVector512 rearrange(VectorShuffle s) { + return (ShortVector512) + super.rearrangeTemplate(ShortShuffle512.class, + (ShortShuffle512) s); // specialize } @Override @ForceInline - public Short512Vector rearrange(VectorShuffle shuffle, + public ShortVector512 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Short512Vector) - super.rearrangeTemplate(Short512Shuffle.class, - Short512Mask.class, - (Short512Shuffle) shuffle, - (Short512Mask) m); // specialize + return (ShortVector512) + super.rearrangeTemplate(ShortShuffle512.class, + ShortMask512.class, + (ShortShuffle512) shuffle, + (ShortMask512) m); // specialize } @Override @ForceInline - public Short512Vector rearrange(VectorShuffle s, + public ShortVector512 rearrange(VectorShuffle s, Vector v) { - return (Short512Vector) - super.rearrangeTemplate(Short512Shuffle.class, - (Short512Shuffle) s, - (Short512Vector) v); // specialize + return (ShortVector512) + super.rearrangeTemplate(ShortShuffle512.class, + (ShortShuffle512) s, + (ShortVector512) v); // specialize } @Override @ForceInline - public Short512Vector compress(VectorMask m) { - return (Short512Vector) - super.compressTemplate(Short512Mask.class, - (Short512Mask) m); // specialize + public ShortVector512 compress(VectorMask m) { + return (ShortVector512) + super.compressTemplate(ShortMask512.class, + (ShortMask512) m); // specialize } @Override @ForceInline - public Short512Vector expand(VectorMask m) { - return (Short512Vector) - super.expandTemplate(Short512Mask.class, - (Short512Mask) m); // specialize + public ShortVector512 expand(VectorMask m) { + return (ShortVector512) + super.expandTemplate(ShortMask512.class, + (ShortMask512) m); // specialize } @Override @ForceInline - public Short512Vector selectFrom(Vector v) { - return (Short512Vector) - super.selectFromTemplate((Short512Vector) v); // specialize + public ShortVector512 selectFrom(Vector v) { + return (ShortVector512) + super.selectFromTemplate((ShortVector512) v); // specialize } @Override @ForceInline - public Short512Vector selectFrom(Vector v, + public ShortVector512 selectFrom(Vector v, VectorMask m) { - return (Short512Vector) - super.selectFromTemplate((Short512Vector) v, - Short512Mask.class, (Short512Mask) m); // specialize + return (ShortVector512) + super.selectFromTemplate((ShortVector512) v, + ShortMask512.class, (ShortMask512) m); // specialize } @Override @ForceInline - public Short512Vector selectFrom(Vector v1, + public ShortVector512 selectFrom(Vector v1, Vector v2) { - return (Short512Vector) - super.selectFromTemplate((Short512Vector) v1, (Short512Vector) v2); // specialize + return (ShortVector512) + super.selectFromTemplate((ShortVector512) v1, (ShortVector512) v2); // specialize } @ForceInline @@ -574,7 +574,7 @@ final class Short512Vector extends ShortVector { @ForceInline @Override - public Short512Vector withLane(int i, short e) { + public ShortVector512 withLane(int i, short e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -613,7 +613,7 @@ final class Short512Vector extends ShortVector { } @ForceInline - public Short512Vector withLaneHelper(int i, short e) { + public ShortVector512 withLaneHelper(int i, short e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -626,19 +626,19 @@ final class Short512Vector extends ShortVector { // Mask - static final class Short512Mask extends AbstractMask { + static final class ShortMask512 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - Short512Mask(boolean[] bits) { + ShortMask512(boolean[] bits) { this(bits, 0); } - Short512Mask(boolean[] bits, int offset) { + ShortMask512(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Short512Mask(boolean val) { + ShortMask512(boolean val) { super(prepare(val)); } @@ -671,31 +671,31 @@ final class Short512Vector extends ShortVector { } @Override - Short512Mask uOp(MUnOp f) { + ShortMask512 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Short512Mask(res); + return new ShortMask512(res); } @Override - Short512Mask bOp(VectorMask m, MBinOp f) { + ShortMask512 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Short512Mask)m).getBits(); + boolean[] mbits = ((ShortMask512)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Short512Mask(res); + return new ShortMask512(res); } @ForceInline @Override public final - Short512Vector toVector() { - return (Short512Vector) super.toVectorTemplate(); // specialize + ShortVector512 toVector() { + return (ShortVector512) super.toVectorTemplate(); // specialize } /** @@ -728,25 +728,25 @@ final class Short512Vector extends ShortVector { @Override @ForceInline /*package-private*/ - Short512Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Short512Mask) VectorSupport.indexPartiallyInUpperRange( - Short512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Short512Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + ShortMask512 indexPartiallyInUpperRange(long offset, long limit) { + return (ShortMask512) VectorSupport.indexPartiallyInUpperRange( + ShortMask512.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ShortMask512) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Short512Mask not() { + public ShortMask512 not() { return xor(maskAll(true)); } @Override @ForceInline - public Short512Mask compress() { - return (Short512Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Short512Vector.class, Short512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ShortMask512 compress() { + return (ShortMask512)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ShortVector512.class, ShortMask512.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -755,30 +755,30 @@ final class Short512Vector extends ShortVector { @Override @ForceInline - public Short512Mask and(VectorMask mask) { + public ShortMask512 and(VectorMask mask) { Objects.requireNonNull(mask); - Short512Mask m = (Short512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Short512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask512 m = (ShortMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ShortMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Short512Mask or(VectorMask mask) { + public ShortMask512 or(VectorMask mask) { Objects.requireNonNull(mask); - Short512Mask m = (Short512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Short512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask512 m = (ShortMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ShortMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Short512Mask xor(VectorMask mask) { + public ShortMask512 xor(VectorMask mask) { Objects.requireNonNull(mask); - Short512Mask m = (Short512Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Short512Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask512 m = (ShortMask512)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ShortMask512.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -788,21 +788,21 @@ final class Short512Vector extends ShortVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Short512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ShortMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Short512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ShortMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Short512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ShortMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -812,7 +812,7 @@ final class Short512Vector extends ShortVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Short512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ShortMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -822,7 +822,7 @@ final class Short512Vector extends ShortVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Short512Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ShortMask512.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -831,48 +831,48 @@ final class Short512Vector extends ShortVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Short512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ShortMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Short512Mask)m).getBits())); + (m, __) -> anyTrueHelper(((ShortMask512)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Short512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ShortMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Short512Mask)m).getBits())); + (m, __) -> allTrueHelper(((ShortMask512)m).getBits())); } @ForceInline /*package-private*/ - static Short512Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Short512Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ShortMask512 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ShortMask512.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Short512Mask TRUE_MASK = new Short512Mask(true); - private static final Short512Mask FALSE_MASK = new Short512Mask(false); + private static final ShortMask512 TRUE_MASK = new ShortMask512(true); + private static final ShortMask512 FALSE_MASK = new ShortMask512(false); } // Shuffle - static final class Short512Shuffle extends AbstractShuffle { + static final class ShortShuffle512 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - Short512Shuffle(short[] indices) { + ShortShuffle512(short[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Short512Shuffle(int[] indices, int i) { + ShortShuffle512(int[] indices, int i) { this(prepare(indices, i)); } - Short512Shuffle(IntUnaryOperator fn) { + ShortShuffle512(IntUnaryOperator fn) { this(prepare(fn)); } @@ -892,23 +892,23 @@ final class Short512Vector extends ShortVector { assert(VLENGTH < Short.MAX_VALUE); assert(Short.MIN_VALUE <= -VLENGTH); } - static final Short512Shuffle IOTA = new Short512Shuffle(IDENTITY); + static final ShortShuffle512 IOTA = new ShortShuffle512(IDENTITY); @Override @ForceInline - public Short512Vector toVector() { + public ShortVector512 toVector() { return toBitsVector(); } @Override @ForceInline - Short512Vector toBitsVector() { - return (Short512Vector) super.toBitsVectorTemplate(); + ShortVector512 toBitsVector() { + return (ShortVector512) super.toBitsVectorTemplate(); } @Override - Short512Vector toBitsVector0() { - return ((Short512Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ShortVector512 toBitsVector0() { + return ((ShortVector512) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -945,30 +945,30 @@ final class Short512Vector extends ShortVector { @Override @ForceInline - public final Short512Mask laneIsValid() { - return (Short512Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final ShortMask512 laneIsValid() { + return (ShortMask512) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Short512Shuffle rearrange(VectorShuffle shuffle) { - Short512Shuffle concreteShuffle = (Short512Shuffle) shuffle; - return (Short512Shuffle) toBitsVector().rearrange(concreteShuffle) + public final ShortShuffle512 rearrange(VectorShuffle shuffle) { + ShortShuffle512 concreteShuffle = (ShortShuffle512) shuffle; + return (ShortShuffle512) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Short512Shuffle wrapIndexes() { - Short512Vector v = toBitsVector(); + public final ShortShuffle512 wrapIndexes() { + ShortVector512 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Short512Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ShortVector512) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Short512Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ShortVector512) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Short512Shuffle) v.toShuffle(vspecies(), false); + return (ShortShuffle512) v.toShuffle(vspecies(), false); } private static short[] prepare(int[] indices, int offset) { @@ -1019,14 +1019,14 @@ final class Short512Vector extends ShortVector { @Override final ShortVector fromArray0(short[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Short512Mask.class, a, offset, (Short512Mask) m, offsetInRange); // specialize + return super.fromArray0Template(ShortMask512.class, a, offset, (ShortMask512) m, offsetInRange); // specialize } @ForceInline @Override final ShortVector fromArray0(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Short512Mask.class, a, offset, indexMap, mapOffset, (Short512Mask) m); + return super.fromArray0Template(ShortMask512.class, a, offset, indexMap, mapOffset, (ShortMask512) m); } @ForceInline @@ -1040,7 +1040,7 @@ final class Short512Vector extends ShortVector { @Override final ShortVector fromCharArray0(char[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromCharArray0Template(Short512Mask.class, a, offset, (Short512Mask) m, offsetInRange); // specialize + return super.fromCharArray0Template(ShortMask512.class, a, offset, (ShortMask512) m, offsetInRange); // specialize } @@ -1055,7 +1055,7 @@ final class Short512Vector extends ShortVector { @Override final ShortVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Short512Mask.class, ms, offset, (Short512Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ShortMask512.class, ms, offset, (ShortMask512) m, offsetInRange); // specialize } @ForceInline @@ -1069,7 +1069,7 @@ final class Short512Vector extends ShortVector { @Override final void intoArray0(short[] a, int offset, VectorMask m) { - super.intoArray0Template(Short512Mask.class, a, offset, (Short512Mask) m); + super.intoArray0Template(ShortMask512.class, a, offset, (ShortMask512) m); } @@ -1078,14 +1078,14 @@ final class Short512Vector extends ShortVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Short512Mask.class, ms, offset, (Short512Mask) m); + super.intoMemorySegment0Template(ShortMask512.class, ms, offset, (ShortMask512) m); } @ForceInline @Override final void intoCharArray0(char[] a, int offset, VectorMask m) { - super.intoCharArray0Template(Short512Mask.class, a, offset, (Short512Mask) m); + super.intoCharArray0Template(ShortMask512.class, a, offset, (ShortMask512) m); } // End of specialized low-level memory operations. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short64Vector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector64.java similarity index 66% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short64Vector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector64.java index 8b3246996f3..0ae35404225 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Short64Vector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector64.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class Short64Vector extends ShortVector { +final class ShortVector64 extends ShortVector { static final ShortSpecies VSPECIES = (ShortSpecies) ShortVector.SPECIES_64; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = Short64Vector.class; + static final Class VCLASS = ShortVector64.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class Short64Vector extends ShortVector { static final Class ETYPE = short.class; // used by the JVM - Short64Vector(short[] v) { + ShortVector64(short[] v) { super(v); } - // For compatibility as Short64Vector::new, + // For compatibility as ShortVector64::new, // stored into species.vectorFactory. - Short64Vector(Object v) { + ShortVector64(Object v) { this((short[]) v); } - static final Short64Vector ZERO = new Short64Vector(new short[VLENGTH]); - static final Short64Vector IOTA = new Short64Vector(VSPECIES.iotaArray()); + static final ShortVector64 ZERO = new ShortVector64(new short[VLENGTH]); + static final ShortVector64 IOTA = new ShortVector64(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class Short64Vector extends ShortVector { @Override @ForceInline - public final Short64Vector broadcast(short e) { - return (Short64Vector) super.broadcastTemplate(e); // specialize + public final ShortVector64 broadcast(short e) { + return (ShortVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final Short64Vector broadcast(long e) { - return (Short64Vector) super.broadcastTemplate(e); // specialize + public final ShortVector64 broadcast(long e) { + return (ShortVector64) super.broadcastTemplate(e); // specialize } @Override @ForceInline - Short64Mask maskFromArray(boolean[] bits) { - return new Short64Mask(bits); + ShortMask64 maskFromArray(boolean[] bits) { + return new ShortMask64(bits); } @Override @ForceInline - Short64Shuffle iotaShuffle() { return Short64Shuffle.IOTA; } + ShortShuffle64 iotaShuffle() { return ShortShuffle64.IOTA; } @Override @ForceInline - Short64Shuffle iotaShuffle(int start, int step, boolean wrap) { - return (Short64Shuffle) iotaShuffleTemplate((short) start, (short) step, wrap); + ShortShuffle64 iotaShuffle(int start, int step, boolean wrap) { + return (ShortShuffle64) iotaShuffleTemplate((short) start, (short) step, wrap); } @Override @ForceInline - Short64Shuffle shuffleFromArray(int[] indices, int i) { return new Short64Shuffle(indices, i); } + ShortShuffle64 shuffleFromArray(int[] indices, int i) { return new ShortShuffle64(indices, i); } @Override @ForceInline - Short64Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Short64Shuffle(fn); } + ShortShuffle64 shuffleFromOp(IntUnaryOperator fn) { return new ShortShuffle64(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - Short64Vector vectorFactory(short[] vec) { - return new Short64Vector(vec); + ShortVector64 vectorFactory(short[] vec) { + return new ShortVector64(vec); } @ForceInline final @Override - Byte64Vector asByteVectorRaw() { - return (Byte64Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector64 asByteVectorRaw() { + return (ByteVector64) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class Short64Vector extends ShortVector { @ForceInline final @Override - Short64Vector uOp(FUnOp f) { - return (Short64Vector) super.uOpTemplate(f); // specialize + ShortVector64 uOp(FUnOp f) { + return (ShortVector64) super.uOpTemplate(f); // specialize } @ForceInline final @Override - Short64Vector uOp(VectorMask m, FUnOp f) { - return (Short64Vector) - super.uOpTemplate((Short64Mask)m, f); // specialize + ShortVector64 uOp(VectorMask m, FUnOp f) { + return (ShortVector64) + super.uOpTemplate((ShortMask64)m, f); // specialize } // Binary operator @ForceInline final @Override - Short64Vector bOp(Vector v, FBinOp f) { - return (Short64Vector) super.bOpTemplate((Short64Vector)v, f); // specialize + ShortVector64 bOp(Vector v, FBinOp f) { + return (ShortVector64) super.bOpTemplate((ShortVector64)v, f); // specialize } @ForceInline final @Override - Short64Vector bOp(Vector v, + ShortVector64 bOp(Vector v, VectorMask m, FBinOp f) { - return (Short64Vector) - super.bOpTemplate((Short64Vector)v, (Short64Mask)m, + return (ShortVector64) + super.bOpTemplate((ShortVector64)v, (ShortMask64)m, f); // specialize } @@ -219,19 +219,19 @@ final class Short64Vector extends ShortVector { @ForceInline final @Override - Short64Vector tOp(Vector v1, Vector v2, FTriOp f) { - return (Short64Vector) - super.tOpTemplate((Short64Vector)v1, (Short64Vector)v2, + ShortVector64 tOp(Vector v1, Vector v2, FTriOp f) { + return (ShortVector64) + super.tOpTemplate((ShortVector64)v1, (ShortVector64)v2, f); // specialize } @ForceInline final @Override - Short64Vector tOp(Vector v1, Vector v2, + ShortVector64 tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (Short64Vector) - super.tOpTemplate((Short64Vector)v1, (Short64Vector)v2, - (Short64Mask)m, f); // specialize + return (ShortVector64) + super.tOpTemplate((ShortVector64)v1, (ShortVector64)v2, + (ShortMask64)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class Short64Vector extends ShortVector { @Override @ForceInline - public Short64Vector lanewise(Unary op) { - return (Short64Vector) super.lanewiseTemplate(op); // specialize + public ShortVector64 lanewise(Unary op) { + return (ShortVector64) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public Short64Vector lanewise(Unary op, VectorMask m) { - return (Short64Vector) super.lanewiseTemplate(op, Short64Mask.class, (Short64Mask) m); // specialize + public ShortVector64 lanewise(Unary op, VectorMask m) { + return (ShortVector64) super.lanewiseTemplate(op, ShortMask64.class, (ShortMask64) m); // specialize } @Override @ForceInline - public Short64Vector lanewise(Binary op, Vector v) { - return (Short64Vector) super.lanewiseTemplate(op, v); // specialize + public ShortVector64 lanewise(Binary op, Vector v) { + return (ShortVector64) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public Short64Vector lanewise(Binary op, Vector v, VectorMask m) { - return (Short64Vector) super.lanewiseTemplate(op, Short64Mask.class, v, (Short64Mask) m); // specialize + public ShortVector64 lanewise(Binary op, Vector v, VectorMask m) { + return (ShortVector64) super.lanewiseTemplate(op, ShortMask64.class, v, (ShortMask64) m); // specialize } /*package-private*/ @Override - @ForceInline Short64Vector + @ForceInline ShortVector64 lanewiseShift(VectorOperators.Binary op, int e) { - return (Short64Vector) super.lanewiseShiftTemplate(op, e); // specialize + return (ShortVector64) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline Short64Vector + @ForceInline ShortVector64 lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (Short64Vector) super.lanewiseShiftTemplate(op, Short64Mask.class, e, (Short64Mask) m); // specialize + return (ShortVector64) super.lanewiseShiftTemplate(op, ShortMask64.class, e, (ShortMask64) m); // specialize } /*package-private*/ @Override @ForceInline public final - Short64Vector + ShortVector64 lanewise(Ternary op, Vector v1, Vector v2) { - return (Short64Vector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ShortVector64) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - Short64Vector + ShortVector64 lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (Short64Vector) super.lanewiseTemplate(op, Short64Mask.class, v1, v2, (Short64Mask) m); // specialize + return (ShortVector64) super.lanewiseTemplate(op, ShortMask64.class, v1, v2, (ShortMask64) m); // specialize } @Override @ForceInline public final - Short64Vector addIndex(int scale) { - return (Short64Vector) super.addIndexTemplate(scale); // specialize + ShortVector64 addIndex(int scale) { + return (ShortVector64) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class Short64Vector extends ShortVector { @ForceInline public final short reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, Short64Mask.class, (Short64Mask) m); // specialized + return super.reduceLanesTemplate(op, ShortMask64.class, (ShortMask64) m); // specialized } @Override @@ -354,7 +354,7 @@ final class Short64Vector extends ShortVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, Short64Mask.class, (Short64Mask) m); // specialized + return (long) super.reduceLanesTemplate(op, ShortMask64.class, (ShortMask64) m); // specialized } @Override @@ -365,160 +365,160 @@ final class Short64Vector extends ShortVector { @Override @ForceInline - public final Short64Shuffle toShuffle() { - return (Short64Shuffle) toShuffle(vspecies(), false); + public final ShortShuffle64 toShuffle() { + return (ShortShuffle64) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final Short64Mask test(Test op) { - return super.testTemplate(Short64Mask.class, op); // specialize + public final ShortMask64 test(Test op) { + return super.testTemplate(ShortMask64.class, op); // specialize } @Override @ForceInline - public final Short64Mask test(Test op, VectorMask m) { - return super.testTemplate(Short64Mask.class, op, (Short64Mask) m); // specialize + public final ShortMask64 test(Test op, VectorMask m) { + return super.testTemplate(ShortMask64.class, op, (ShortMask64) m); // specialize } // Specialized comparisons @Override @ForceInline - public final Short64Mask compare(Comparison op, Vector v) { - return super.compareTemplate(Short64Mask.class, op, v); // specialize + public final ShortMask64 compare(Comparison op, Vector v) { + return super.compareTemplate(ShortMask64.class, op, v); // specialize } @Override @ForceInline - public final Short64Mask compare(Comparison op, short s) { - return super.compareTemplate(Short64Mask.class, op, s); // specialize + public final ShortMask64 compare(Comparison op, short s) { + return super.compareTemplate(ShortMask64.class, op, s); // specialize } @Override @ForceInline - public final Short64Mask compare(Comparison op, long s) { - return super.compareTemplate(Short64Mask.class, op, s); // specialize + public final ShortMask64 compare(Comparison op, long s) { + return super.compareTemplate(ShortMask64.class, op, s); // specialize } @Override @ForceInline - public final Short64Mask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(Short64Mask.class, op, v, (Short64Mask) m); + public final ShortMask64 compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ShortMask64.class, op, v, (ShortMask64) m); } @Override @ForceInline - public Short64Vector blend(Vector v, VectorMask m) { - return (Short64Vector) - super.blendTemplate(Short64Mask.class, - (Short64Vector) v, - (Short64Mask) m); // specialize + public ShortVector64 blend(Vector v, VectorMask m) { + return (ShortVector64) + super.blendTemplate(ShortMask64.class, + (ShortVector64) v, + (ShortMask64) m); // specialize } @Override @ForceInline - public Short64Vector slice(int origin, Vector v) { - return (Short64Vector) super.sliceTemplate(origin, v); // specialize + public ShortVector64 slice(int origin, Vector v) { + return (ShortVector64) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public Short64Vector slice(int origin) { - return (Short64Vector) super.sliceTemplate(origin); // specialize + public ShortVector64 slice(int origin) { + return (ShortVector64) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public Short64Vector unslice(int origin, Vector w, int part) { - return (Short64Vector) super.unsliceTemplate(origin, w, part); // specialize + public ShortVector64 unslice(int origin, Vector w, int part) { + return (ShortVector64) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public Short64Vector unslice(int origin, Vector w, int part, VectorMask m) { - return (Short64Vector) - super.unsliceTemplate(Short64Mask.class, + public ShortVector64 unslice(int origin, Vector w, int part, VectorMask m) { + return (ShortVector64) + super.unsliceTemplate(ShortMask64.class, origin, w, part, - (Short64Mask) m); // specialize + (ShortMask64) m); // specialize } @Override @ForceInline - public Short64Vector unslice(int origin) { - return (Short64Vector) super.unsliceTemplate(origin); // specialize + public ShortVector64 unslice(int origin) { + return (ShortVector64) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public Short64Vector rearrange(VectorShuffle s) { - return (Short64Vector) - super.rearrangeTemplate(Short64Shuffle.class, - (Short64Shuffle) s); // specialize + public ShortVector64 rearrange(VectorShuffle s) { + return (ShortVector64) + super.rearrangeTemplate(ShortShuffle64.class, + (ShortShuffle64) s); // specialize } @Override @ForceInline - public Short64Vector rearrange(VectorShuffle shuffle, + public ShortVector64 rearrange(VectorShuffle shuffle, VectorMask m) { - return (Short64Vector) - super.rearrangeTemplate(Short64Shuffle.class, - Short64Mask.class, - (Short64Shuffle) shuffle, - (Short64Mask) m); // specialize + return (ShortVector64) + super.rearrangeTemplate(ShortShuffle64.class, + ShortMask64.class, + (ShortShuffle64) shuffle, + (ShortMask64) m); // specialize } @Override @ForceInline - public Short64Vector rearrange(VectorShuffle s, + public ShortVector64 rearrange(VectorShuffle s, Vector v) { - return (Short64Vector) - super.rearrangeTemplate(Short64Shuffle.class, - (Short64Shuffle) s, - (Short64Vector) v); // specialize + return (ShortVector64) + super.rearrangeTemplate(ShortShuffle64.class, + (ShortShuffle64) s, + (ShortVector64) v); // specialize } @Override @ForceInline - public Short64Vector compress(VectorMask m) { - return (Short64Vector) - super.compressTemplate(Short64Mask.class, - (Short64Mask) m); // specialize + public ShortVector64 compress(VectorMask m) { + return (ShortVector64) + super.compressTemplate(ShortMask64.class, + (ShortMask64) m); // specialize } @Override @ForceInline - public Short64Vector expand(VectorMask m) { - return (Short64Vector) - super.expandTemplate(Short64Mask.class, - (Short64Mask) m); // specialize + public ShortVector64 expand(VectorMask m) { + return (ShortVector64) + super.expandTemplate(ShortMask64.class, + (ShortMask64) m); // specialize } @Override @ForceInline - public Short64Vector selectFrom(Vector v) { - return (Short64Vector) - super.selectFromTemplate((Short64Vector) v); // specialize + public ShortVector64 selectFrom(Vector v) { + return (ShortVector64) + super.selectFromTemplate((ShortVector64) v); // specialize } @Override @ForceInline - public Short64Vector selectFrom(Vector v, + public ShortVector64 selectFrom(Vector v, VectorMask m) { - return (Short64Vector) - super.selectFromTemplate((Short64Vector) v, - Short64Mask.class, (Short64Mask) m); // specialize + return (ShortVector64) + super.selectFromTemplate((ShortVector64) v, + ShortMask64.class, (ShortMask64) m); // specialize } @Override @ForceInline - public Short64Vector selectFrom(Vector v1, + public ShortVector64 selectFrom(Vector v1, Vector v2) { - return (Short64Vector) - super.selectFromTemplate((Short64Vector) v1, (Short64Vector) v2); // specialize + return (ShortVector64) + super.selectFromTemplate((ShortVector64) v1, (ShortVector64) v2); // specialize } @ForceInline @@ -546,7 +546,7 @@ final class Short64Vector extends ShortVector { @ForceInline @Override - public Short64Vector withLane(int i, short e) { + public ShortVector64 withLane(int i, short e) { switch (i) { case 0: return withLaneHelper(0, e); case 1: return withLaneHelper(1, e); @@ -557,7 +557,7 @@ final class Short64Vector extends ShortVector { } @ForceInline - public Short64Vector withLaneHelper(int i, short e) { + public ShortVector64 withLaneHelper(int i, short e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -570,19 +570,19 @@ final class Short64Vector extends ShortVector { // Mask - static final class Short64Mask extends AbstractMask { + static final class ShortMask64 extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - Short64Mask(boolean[] bits) { + ShortMask64(boolean[] bits) { this(bits, 0); } - Short64Mask(boolean[] bits, int offset) { + ShortMask64(boolean[] bits, int offset) { super(prepare(bits, offset)); } - Short64Mask(boolean val) { + ShortMask64(boolean val) { super(prepare(val)); } @@ -615,31 +615,31 @@ final class Short64Vector extends ShortVector { } @Override - Short64Mask uOp(MUnOp f) { + ShortMask64 uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new Short64Mask(res); + return new ShortMask64(res); } @Override - Short64Mask bOp(VectorMask m, MBinOp f) { + ShortMask64 bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((Short64Mask)m).getBits(); + boolean[] mbits = ((ShortMask64)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new Short64Mask(res); + return new ShortMask64(res); } @ForceInline @Override public final - Short64Vector toVector() { - return (Short64Vector) super.toVectorTemplate(); // specialize + ShortVector64 toVector() { + return (ShortVector64) super.toVectorTemplate(); // specialize } /** @@ -672,25 +672,25 @@ final class Short64Vector extends ShortVector { @Override @ForceInline /*package-private*/ - Short64Mask indexPartiallyInUpperRange(long offset, long limit) { - return (Short64Mask) VectorSupport.indexPartiallyInUpperRange( - Short64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (Short64Mask) TRUE_MASK.indexPartiallyInRange(o, l)); + ShortMask64 indexPartiallyInUpperRange(long offset, long limit) { + return (ShortMask64) VectorSupport.indexPartiallyInUpperRange( + ShortMask64.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ShortMask64) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public Short64Mask not() { + public ShortMask64 not() { return xor(maskAll(true)); } @Override @ForceInline - public Short64Mask compress() { - return (Short64Mask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - Short64Vector.class, Short64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ShortMask64 compress() { + return (ShortMask64)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ShortVector64.class, ShortMask64.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -699,30 +699,30 @@ final class Short64Vector extends ShortVector { @Override @ForceInline - public Short64Mask and(VectorMask mask) { + public ShortMask64 and(VectorMask mask) { Objects.requireNonNull(mask); - Short64Mask m = (Short64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, Short64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask64 m = (ShortMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ShortMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public Short64Mask or(VectorMask mask) { + public ShortMask64 or(VectorMask mask) { Objects.requireNonNull(mask); - Short64Mask m = (Short64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, Short64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask64 m = (ShortMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ShortMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public Short64Mask xor(VectorMask mask) { + public ShortMask64 xor(VectorMask mask) { Objects.requireNonNull(mask); - Short64Mask m = (Short64Mask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, Short64Mask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMask64 m = (ShortMask64)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ShortMask64.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -732,21 +732,21 @@ final class Short64Vector extends ShortVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, Short64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ShortMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, Short64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ShortMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, Short64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ShortMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -756,7 +756,7 @@ final class Short64Vector extends ShortVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, Short64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ShortMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -766,7 +766,7 @@ final class Short64Vector extends ShortVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(Short64Mask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ShortMask64.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -775,48 +775,48 @@ final class Short64Vector extends ShortVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, Short64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ShortMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((Short64Mask)m).getBits())); + (m, __) -> anyTrueHelper(((ShortMask64)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, Short64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ShortMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((Short64Mask)m).getBits())); + (m, __) -> allTrueHelper(((ShortMask64)m).getBits())); } @ForceInline /*package-private*/ - static Short64Mask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(Short64Mask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ShortMask64 maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ShortMask64.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final Short64Mask TRUE_MASK = new Short64Mask(true); - private static final Short64Mask FALSE_MASK = new Short64Mask(false); + private static final ShortMask64 TRUE_MASK = new ShortMask64(true); + private static final ShortMask64 FALSE_MASK = new ShortMask64(false); } // Shuffle - static final class Short64Shuffle extends AbstractShuffle { + static final class ShortShuffle64 extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - Short64Shuffle(short[] indices) { + ShortShuffle64(short[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - Short64Shuffle(int[] indices, int i) { + ShortShuffle64(int[] indices, int i) { this(prepare(indices, i)); } - Short64Shuffle(IntUnaryOperator fn) { + ShortShuffle64(IntUnaryOperator fn) { this(prepare(fn)); } @@ -836,23 +836,23 @@ final class Short64Vector extends ShortVector { assert(VLENGTH < Short.MAX_VALUE); assert(Short.MIN_VALUE <= -VLENGTH); } - static final Short64Shuffle IOTA = new Short64Shuffle(IDENTITY); + static final ShortShuffle64 IOTA = new ShortShuffle64(IDENTITY); @Override @ForceInline - public Short64Vector toVector() { + public ShortVector64 toVector() { return toBitsVector(); } @Override @ForceInline - Short64Vector toBitsVector() { - return (Short64Vector) super.toBitsVectorTemplate(); + ShortVector64 toBitsVector() { + return (ShortVector64) super.toBitsVectorTemplate(); } @Override - Short64Vector toBitsVector0() { - return ((Short64Vector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ShortVector64 toBitsVector0() { + return ((ShortVector64) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -889,30 +889,30 @@ final class Short64Vector extends ShortVector { @Override @ForceInline - public final Short64Mask laneIsValid() { - return (Short64Mask) toBitsVector().compare(VectorOperators.GE, 0) + public final ShortMask64 laneIsValid() { + return (ShortMask64) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final Short64Shuffle rearrange(VectorShuffle shuffle) { - Short64Shuffle concreteShuffle = (Short64Shuffle) shuffle; - return (Short64Shuffle) toBitsVector().rearrange(concreteShuffle) + public final ShortShuffle64 rearrange(VectorShuffle shuffle) { + ShortShuffle64 concreteShuffle = (ShortShuffle64) shuffle; + return (ShortShuffle64) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final Short64Shuffle wrapIndexes() { - Short64Vector v = toBitsVector(); + public final ShortShuffle64 wrapIndexes() { + ShortVector64 v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (Short64Vector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ShortVector64) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (Short64Vector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ShortVector64) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (Short64Shuffle) v.toShuffle(vspecies(), false); + return (ShortShuffle64) v.toShuffle(vspecies(), false); } private static short[] prepare(int[] indices, int offset) { @@ -963,14 +963,14 @@ final class Short64Vector extends ShortVector { @Override final ShortVector fromArray0(short[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(Short64Mask.class, a, offset, (Short64Mask) m, offsetInRange); // specialize + return super.fromArray0Template(ShortMask64.class, a, offset, (ShortMask64) m, offsetInRange); // specialize } @ForceInline @Override final ShortVector fromArray0(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(Short64Mask.class, a, offset, indexMap, mapOffset, (Short64Mask) m); + return super.fromArray0Template(ShortMask64.class, a, offset, indexMap, mapOffset, (ShortMask64) m); } @ForceInline @@ -984,7 +984,7 @@ final class Short64Vector extends ShortVector { @Override final ShortVector fromCharArray0(char[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromCharArray0Template(Short64Mask.class, a, offset, (Short64Mask) m, offsetInRange); // specialize + return super.fromCharArray0Template(ShortMask64.class, a, offset, (ShortMask64) m, offsetInRange); // specialize } @@ -999,7 +999,7 @@ final class Short64Vector extends ShortVector { @Override final ShortVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(Short64Mask.class, ms, offset, (Short64Mask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ShortMask64.class, ms, offset, (ShortMask64) m, offsetInRange); // specialize } @ForceInline @@ -1013,7 +1013,7 @@ final class Short64Vector extends ShortVector { @Override final void intoArray0(short[] a, int offset, VectorMask m) { - super.intoArray0Template(Short64Mask.class, a, offset, (Short64Mask) m); + super.intoArray0Template(ShortMask64.class, a, offset, (ShortMask64) m); } @@ -1022,14 +1022,14 @@ final class Short64Vector extends ShortVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(Short64Mask.class, ms, offset, (Short64Mask) m); + super.intoMemorySegment0Template(ShortMask64.class, ms, offset, (ShortMask64) m); } @ForceInline @Override final void intoCharArray0(char[] a, int offset, VectorMask m) { - super.intoCharArray0Template(Short64Mask.class, a, offset, (Short64Mask) m); + super.intoCharArray0Template(ShortMask64.class, a, offset, (ShortMask64) m); } // End of specialized low-level memory operations. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortMaxVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVectorMax.java similarity index 66% rename from src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortMaxVector.java rename to src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVectorMax.java index bf9b13c6606..0dfe94c6d61 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortMaxVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVectorMax.java @@ -41,14 +41,14 @@ import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // @SuppressWarnings("cast") // warning: redundant cast -final class ShortMaxVector extends ShortVector { +final class ShortVectorMax extends ShortVector { static final ShortSpecies VSPECIES = (ShortSpecies) ShortVector.SPECIES_MAX; static final VectorShape VSHAPE = VSPECIES.vectorShape(); - static final Class VCLASS = ShortMaxVector.class; + static final Class VCLASS = ShortVectorMax.class; static final int VSIZE = VSPECIES.vectorBitSize(); @@ -56,18 +56,18 @@ final class ShortMaxVector extends ShortVector { static final Class ETYPE = short.class; // used by the JVM - ShortMaxVector(short[] v) { + ShortVectorMax(short[] v) { super(v); } - // For compatibility as ShortMaxVector::new, + // For compatibility as ShortVectorMax::new, // stored into species.vectorFactory. - ShortMaxVector(Object v) { + ShortVectorMax(Object v) { this((short[]) v); } - static final ShortMaxVector ZERO = new ShortMaxVector(new short[VLENGTH]); - static final ShortMaxVector IOTA = new ShortMaxVector(VSPECIES.iotaArray()); + static final ShortVectorMax ZERO = new ShortVectorMax(new short[VLENGTH]); + static final ShortVectorMax IOTA = new ShortVectorMax(VSPECIES.iotaArray()); static { // Warm up a few species caches. @@ -130,51 +130,51 @@ final class ShortMaxVector extends ShortVector { @Override @ForceInline - public final ShortMaxVector broadcast(short e) { - return (ShortMaxVector) super.broadcastTemplate(e); // specialize + public final ShortVectorMax broadcast(short e) { + return (ShortVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - public final ShortMaxVector broadcast(long e) { - return (ShortMaxVector) super.broadcastTemplate(e); // specialize + public final ShortVectorMax broadcast(long e) { + return (ShortVectorMax) super.broadcastTemplate(e); // specialize } @Override @ForceInline - ShortMaxMask maskFromArray(boolean[] bits) { - return new ShortMaxMask(bits); + ShortMaskMax maskFromArray(boolean[] bits) { + return new ShortMaskMax(bits); } @Override @ForceInline - ShortMaxShuffle iotaShuffle() { return ShortMaxShuffle.IOTA; } + ShortShuffleMax iotaShuffle() { return ShortShuffleMax.IOTA; } @Override @ForceInline - ShortMaxShuffle iotaShuffle(int start, int step, boolean wrap) { - return (ShortMaxShuffle) iotaShuffleTemplate((short) start, (short) step, wrap); + ShortShuffleMax iotaShuffle(int start, int step, boolean wrap) { + return (ShortShuffleMax) iotaShuffleTemplate((short) start, (short) step, wrap); } @Override @ForceInline - ShortMaxShuffle shuffleFromArray(int[] indices, int i) { return new ShortMaxShuffle(indices, i); } + ShortShuffleMax shuffleFromArray(int[] indices, int i) { return new ShortShuffleMax(indices, i); } @Override @ForceInline - ShortMaxShuffle shuffleFromOp(IntUnaryOperator fn) { return new ShortMaxShuffle(fn); } + ShortShuffleMax shuffleFromOp(IntUnaryOperator fn) { return new ShortShuffleMax(fn); } // Make a vector of the same species but the given elements: @ForceInline final @Override - ShortMaxVector vectorFactory(short[] vec) { - return new ShortMaxVector(vec); + ShortVectorMax vectorFactory(short[] vec) { + return new ShortVectorMax(vec); } @ForceInline final @Override - ByteMaxVector asByteVectorRaw() { - return (ByteMaxVector) super.asByteVectorRawTemplate(); // specialize + ByteVectorMax asByteVectorRaw() { + return (ByteVectorMax) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -187,31 +187,31 @@ final class ShortMaxVector extends ShortVector { @ForceInline final @Override - ShortMaxVector uOp(FUnOp f) { - return (ShortMaxVector) super.uOpTemplate(f); // specialize + ShortVectorMax uOp(FUnOp f) { + return (ShortVectorMax) super.uOpTemplate(f); // specialize } @ForceInline final @Override - ShortMaxVector uOp(VectorMask m, FUnOp f) { - return (ShortMaxVector) - super.uOpTemplate((ShortMaxMask)m, f); // specialize + ShortVectorMax uOp(VectorMask m, FUnOp f) { + return (ShortVectorMax) + super.uOpTemplate((ShortMaskMax)m, f); // specialize } // Binary operator @ForceInline final @Override - ShortMaxVector bOp(Vector v, FBinOp f) { - return (ShortMaxVector) super.bOpTemplate((ShortMaxVector)v, f); // specialize + ShortVectorMax bOp(Vector v, FBinOp f) { + return (ShortVectorMax) super.bOpTemplate((ShortVectorMax)v, f); // specialize } @ForceInline final @Override - ShortMaxVector bOp(Vector v, + ShortVectorMax bOp(Vector v, VectorMask m, FBinOp f) { - return (ShortMaxVector) - super.bOpTemplate((ShortMaxVector)v, (ShortMaxMask)m, + return (ShortVectorMax) + super.bOpTemplate((ShortVectorMax)v, (ShortMaskMax)m, f); // specialize } @@ -219,19 +219,19 @@ final class ShortMaxVector extends ShortVector { @ForceInline final @Override - ShortMaxVector tOp(Vector v1, Vector v2, FTriOp f) { - return (ShortMaxVector) - super.tOpTemplate((ShortMaxVector)v1, (ShortMaxVector)v2, + ShortVectorMax tOp(Vector v1, Vector v2, FTriOp f) { + return (ShortVectorMax) + super.tOpTemplate((ShortVectorMax)v1, (ShortVectorMax)v2, f); // specialize } @ForceInline final @Override - ShortMaxVector tOp(Vector v1, Vector v2, + ShortVectorMax tOp(Vector v1, Vector v2, VectorMask m, FTriOp f) { - return (ShortMaxVector) - super.tOpTemplate((ShortMaxVector)v1, (ShortMaxVector)v2, - (ShortMaxMask)m, f); // specialize + return (ShortVectorMax) + super.tOpTemplate((ShortVectorMax)v1, (ShortVectorMax)v2, + (ShortMaskMax)m, f); // specialize } @ForceInline @@ -269,64 +269,64 @@ final class ShortMaxVector extends ShortVector { @Override @ForceInline - public ShortMaxVector lanewise(Unary op) { - return (ShortMaxVector) super.lanewiseTemplate(op); // specialize + public ShortVectorMax lanewise(Unary op) { + return (ShortVectorMax) super.lanewiseTemplate(op); // specialize } @Override @ForceInline - public ShortMaxVector lanewise(Unary op, VectorMask m) { - return (ShortMaxVector) super.lanewiseTemplate(op, ShortMaxMask.class, (ShortMaxMask) m); // specialize + public ShortVectorMax lanewise(Unary op, VectorMask m) { + return (ShortVectorMax) super.lanewiseTemplate(op, ShortMaskMax.class, (ShortMaskMax) m); // specialize } @Override @ForceInline - public ShortMaxVector lanewise(Binary op, Vector v) { - return (ShortMaxVector) super.lanewiseTemplate(op, v); // specialize + public ShortVectorMax lanewise(Binary op, Vector v) { + return (ShortVectorMax) super.lanewiseTemplate(op, v); // specialize } @Override @ForceInline - public ShortMaxVector lanewise(Binary op, Vector v, VectorMask m) { - return (ShortMaxVector) super.lanewiseTemplate(op, ShortMaxMask.class, v, (ShortMaxMask) m); // specialize + public ShortVectorMax lanewise(Binary op, Vector v, VectorMask m) { + return (ShortVectorMax) super.lanewiseTemplate(op, ShortMaskMax.class, v, (ShortMaskMax) m); // specialize } /*package-private*/ @Override - @ForceInline ShortMaxVector + @ForceInline ShortVectorMax lanewiseShift(VectorOperators.Binary op, int e) { - return (ShortMaxVector) super.lanewiseShiftTemplate(op, e); // specialize + return (ShortVectorMax) super.lanewiseShiftTemplate(op, e); // specialize } /*package-private*/ @Override - @ForceInline ShortMaxVector + @ForceInline ShortVectorMax lanewiseShift(VectorOperators.Binary op, int e, VectorMask m) { - return (ShortMaxVector) super.lanewiseShiftTemplate(op, ShortMaxMask.class, e, (ShortMaxMask) m); // specialize + return (ShortVectorMax) super.lanewiseShiftTemplate(op, ShortMaskMax.class, e, (ShortMaskMax) m); // specialize } /*package-private*/ @Override @ForceInline public final - ShortMaxVector + ShortVectorMax lanewise(Ternary op, Vector v1, Vector v2) { - return (ShortMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize + return (ShortVectorMax) super.lanewiseTemplate(op, v1, v2); // specialize } @Override @ForceInline public final - ShortMaxVector + ShortVectorMax lanewise(Ternary op, Vector v1, Vector v2, VectorMask m) { - return (ShortMaxVector) super.lanewiseTemplate(op, ShortMaxMask.class, v1, v2, (ShortMaxMask) m); // specialize + return (ShortVectorMax) super.lanewiseTemplate(op, ShortMaskMax.class, v1, v2, (ShortMaskMax) m); // specialize } @Override @ForceInline public final - ShortMaxVector addIndex(int scale) { - return (ShortMaxVector) super.addIndexTemplate(scale); // specialize + ShortVectorMax addIndex(int scale) { + return (ShortVectorMax) super.addIndexTemplate(scale); // specialize } // Type specific horizontal reductions @@ -341,7 +341,7 @@ final class ShortMaxVector extends ShortVector { @ForceInline public final short reduceLanes(VectorOperators.Associative op, VectorMask m) { - return super.reduceLanesTemplate(op, ShortMaxMask.class, (ShortMaxMask) m); // specialized + return super.reduceLanesTemplate(op, ShortMaskMax.class, (ShortMaskMax) m); // specialized } @Override @@ -354,7 +354,7 @@ final class ShortMaxVector extends ShortVector { @ForceInline public final long reduceLanesToLong(VectorOperators.Associative op, VectorMask m) { - return (long) super.reduceLanesTemplate(op, ShortMaxMask.class, (ShortMaxMask) m); // specialized + return (long) super.reduceLanesTemplate(op, ShortMaskMax.class, (ShortMaskMax) m); // specialized } @Override @@ -365,160 +365,160 @@ final class ShortMaxVector extends ShortVector { @Override @ForceInline - public final ShortMaxShuffle toShuffle() { - return (ShortMaxShuffle) toShuffle(vspecies(), false); + public final ShortShuffleMax toShuffle() { + return (ShortShuffleMax) toShuffle(vspecies(), false); } // Specialized unary testing @Override @ForceInline - public final ShortMaxMask test(Test op) { - return super.testTemplate(ShortMaxMask.class, op); // specialize + public final ShortMaskMax test(Test op) { + return super.testTemplate(ShortMaskMax.class, op); // specialize } @Override @ForceInline - public final ShortMaxMask test(Test op, VectorMask m) { - return super.testTemplate(ShortMaxMask.class, op, (ShortMaxMask) m); // specialize + public final ShortMaskMax test(Test op, VectorMask m) { + return super.testTemplate(ShortMaskMax.class, op, (ShortMaskMax) m); // specialize } // Specialized comparisons @Override @ForceInline - public final ShortMaxMask compare(Comparison op, Vector v) { - return super.compareTemplate(ShortMaxMask.class, op, v); // specialize + public final ShortMaskMax compare(Comparison op, Vector v) { + return super.compareTemplate(ShortMaskMax.class, op, v); // specialize } @Override @ForceInline - public final ShortMaxMask compare(Comparison op, short s) { - return super.compareTemplate(ShortMaxMask.class, op, s); // specialize + public final ShortMaskMax compare(Comparison op, short s) { + return super.compareTemplate(ShortMaskMax.class, op, s); // specialize } @Override @ForceInline - public final ShortMaxMask compare(Comparison op, long s) { - return super.compareTemplate(ShortMaxMask.class, op, s); // specialize + public final ShortMaskMax compare(Comparison op, long s) { + return super.compareTemplate(ShortMaskMax.class, op, s); // specialize } @Override @ForceInline - public final ShortMaxMask compare(Comparison op, Vector v, VectorMask m) { - return super.compareTemplate(ShortMaxMask.class, op, v, (ShortMaxMask) m); + public final ShortMaskMax compare(Comparison op, Vector v, VectorMask m) { + return super.compareTemplate(ShortMaskMax.class, op, v, (ShortMaskMax) m); } @Override @ForceInline - public ShortMaxVector blend(Vector v, VectorMask m) { - return (ShortMaxVector) - super.blendTemplate(ShortMaxMask.class, - (ShortMaxVector) v, - (ShortMaxMask) m); // specialize + public ShortVectorMax blend(Vector v, VectorMask m) { + return (ShortVectorMax) + super.blendTemplate(ShortMaskMax.class, + (ShortVectorMax) v, + (ShortMaskMax) m); // specialize } @Override @ForceInline - public ShortMaxVector slice(int origin, Vector v) { - return (ShortMaxVector) super.sliceTemplate(origin, v); // specialize + public ShortVectorMax slice(int origin, Vector v) { + return (ShortVectorMax) super.sliceTemplate(origin, v); // specialize } @Override @ForceInline - public ShortMaxVector slice(int origin) { - return (ShortMaxVector) super.sliceTemplate(origin); // specialize + public ShortVectorMax slice(int origin) { + return (ShortVectorMax) super.sliceTemplate(origin); // specialize } @Override @ForceInline - public ShortMaxVector unslice(int origin, Vector w, int part) { - return (ShortMaxVector) super.unsliceTemplate(origin, w, part); // specialize + public ShortVectorMax unslice(int origin, Vector w, int part) { + return (ShortVectorMax) super.unsliceTemplate(origin, w, part); // specialize } @Override @ForceInline - public ShortMaxVector unslice(int origin, Vector w, int part, VectorMask m) { - return (ShortMaxVector) - super.unsliceTemplate(ShortMaxMask.class, + public ShortVectorMax unslice(int origin, Vector w, int part, VectorMask m) { + return (ShortVectorMax) + super.unsliceTemplate(ShortMaskMax.class, origin, w, part, - (ShortMaxMask) m); // specialize + (ShortMaskMax) m); // specialize } @Override @ForceInline - public ShortMaxVector unslice(int origin) { - return (ShortMaxVector) super.unsliceTemplate(origin); // specialize + public ShortVectorMax unslice(int origin) { + return (ShortVectorMax) super.unsliceTemplate(origin); // specialize } @Override @ForceInline - public ShortMaxVector rearrange(VectorShuffle s) { - return (ShortMaxVector) - super.rearrangeTemplate(ShortMaxShuffle.class, - (ShortMaxShuffle) s); // specialize + public ShortVectorMax rearrange(VectorShuffle s) { + return (ShortVectorMax) + super.rearrangeTemplate(ShortShuffleMax.class, + (ShortShuffleMax) s); // specialize } @Override @ForceInline - public ShortMaxVector rearrange(VectorShuffle shuffle, + public ShortVectorMax rearrange(VectorShuffle shuffle, VectorMask m) { - return (ShortMaxVector) - super.rearrangeTemplate(ShortMaxShuffle.class, - ShortMaxMask.class, - (ShortMaxShuffle) shuffle, - (ShortMaxMask) m); // specialize + return (ShortVectorMax) + super.rearrangeTemplate(ShortShuffleMax.class, + ShortMaskMax.class, + (ShortShuffleMax) shuffle, + (ShortMaskMax) m); // specialize } @Override @ForceInline - public ShortMaxVector rearrange(VectorShuffle s, + public ShortVectorMax rearrange(VectorShuffle s, Vector v) { - return (ShortMaxVector) - super.rearrangeTemplate(ShortMaxShuffle.class, - (ShortMaxShuffle) s, - (ShortMaxVector) v); // specialize + return (ShortVectorMax) + super.rearrangeTemplate(ShortShuffleMax.class, + (ShortShuffleMax) s, + (ShortVectorMax) v); // specialize } @Override @ForceInline - public ShortMaxVector compress(VectorMask m) { - return (ShortMaxVector) - super.compressTemplate(ShortMaxMask.class, - (ShortMaxMask) m); // specialize + public ShortVectorMax compress(VectorMask m) { + return (ShortVectorMax) + super.compressTemplate(ShortMaskMax.class, + (ShortMaskMax) m); // specialize } @Override @ForceInline - public ShortMaxVector expand(VectorMask m) { - return (ShortMaxVector) - super.expandTemplate(ShortMaxMask.class, - (ShortMaxMask) m); // specialize + public ShortVectorMax expand(VectorMask m) { + return (ShortVectorMax) + super.expandTemplate(ShortMaskMax.class, + (ShortMaskMax) m); // specialize } @Override @ForceInline - public ShortMaxVector selectFrom(Vector v) { - return (ShortMaxVector) - super.selectFromTemplate((ShortMaxVector) v); // specialize + public ShortVectorMax selectFrom(Vector v) { + return (ShortVectorMax) + super.selectFromTemplate((ShortVectorMax) v); // specialize } @Override @ForceInline - public ShortMaxVector selectFrom(Vector v, + public ShortVectorMax selectFrom(Vector v, VectorMask m) { - return (ShortMaxVector) - super.selectFromTemplate((ShortMaxVector) v, - ShortMaxMask.class, (ShortMaxMask) m); // specialize + return (ShortVectorMax) + super.selectFromTemplate((ShortVectorMax) v, + ShortMaskMax.class, (ShortMaskMax) m); // specialize } @Override @ForceInline - public ShortMaxVector selectFrom(Vector v1, + public ShortVectorMax selectFrom(Vector v1, Vector v2) { - return (ShortMaxVector) - super.selectFromTemplate((ShortMaxVector) v1, (ShortMaxVector) v2); // specialize + return (ShortVectorMax) + super.selectFromTemplate((ShortVectorMax) v1, (ShortVectorMax) v2); // specialize } @ForceInline @@ -543,7 +543,7 @@ final class ShortMaxVector extends ShortVector { @ForceInline @Override - public ShortMaxVector withLane(int i, short e) { + public ShortVectorMax withLane(int i, short e) { if (i < 0 || i >= VLENGTH) { throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); } @@ -551,7 +551,7 @@ final class ShortMaxVector extends ShortVector { } @ForceInline - public ShortMaxVector withLaneHelper(int i, short e) { + public ShortVectorMax withLaneHelper(int i, short e) { return VectorSupport.insert( VCLASS, LANE_TYPE_ORDINAL, VLENGTH, this, i, (long)e, @@ -564,19 +564,19 @@ final class ShortMaxVector extends ShortVector { // Mask - static final class ShortMaxMask extends AbstractMask { + static final class ShortMaskMax extends AbstractMask { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - ShortMaxMask(boolean[] bits) { + ShortMaskMax(boolean[] bits) { this(bits, 0); } - ShortMaxMask(boolean[] bits, int offset) { + ShortMaskMax(boolean[] bits, int offset) { super(prepare(bits, offset)); } - ShortMaxMask(boolean val) { + ShortMaskMax(boolean val) { super(prepare(val)); } @@ -609,31 +609,31 @@ final class ShortMaxVector extends ShortVector { } @Override - ShortMaxMask uOp(MUnOp f) { + ShortMaskMax uOp(MUnOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i]); } - return new ShortMaxMask(res); + return new ShortMaskMax(res); } @Override - ShortMaxMask bOp(VectorMask m, MBinOp f) { + ShortMaskMax bOp(VectorMask m, MBinOp f) { boolean[] res = new boolean[vspecies().laneCount()]; boolean[] bits = getBits(); - boolean[] mbits = ((ShortMaxMask)m).getBits(); + boolean[] mbits = ((ShortMaskMax)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, bits[i], mbits[i]); } - return new ShortMaxMask(res); + return new ShortMaskMax(res); } @ForceInline @Override public final - ShortMaxVector toVector() { - return (ShortMaxVector) super.toVectorTemplate(); // specialize + ShortVectorMax toVector() { + return (ShortVectorMax) super.toVectorTemplate(); // specialize } /** @@ -666,25 +666,25 @@ final class ShortMaxVector extends ShortVector { @Override @ForceInline /*package-private*/ - ShortMaxMask indexPartiallyInUpperRange(long offset, long limit) { - return (ShortMaxMask) VectorSupport.indexPartiallyInUpperRange( - ShortMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, - (o, l) -> (ShortMaxMask) TRUE_MASK.indexPartiallyInRange(o, l)); + ShortMaskMax indexPartiallyInUpperRange(long offset, long limit) { + return (ShortMaskMax) VectorSupport.indexPartiallyInUpperRange( + ShortMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, offset, limit, + (o, l) -> (ShortMaskMax) TRUE_MASK.indexPartiallyInRange(o, l)); } // Unary operations @Override @ForceInline - public ShortMaxMask not() { + public ShortMaskMax not() { return xor(maskAll(true)); } @Override @ForceInline - public ShortMaxMask compress() { - return (ShortMaxMask)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, - ShortMaxVector.class, ShortMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, + public ShortMaskMax compress() { + return (ShortMaskMax)VectorSupport.compressExpandOp(VectorSupport.VECTOR_OP_MASK_COMPRESS, + ShortVectorMax.class, ShortMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, null, this, (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount())); } @@ -693,30 +693,30 @@ final class ShortMaxVector extends ShortVector { @Override @ForceInline - public ShortMaxMask and(VectorMask mask) { + public ShortMaskMax and(VectorMask mask) { Objects.requireNonNull(mask); - ShortMaxMask m = (ShortMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_AND, ShortMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMaskMax m = (ShortMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_AND, ShortMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b)); } @Override @ForceInline - public ShortMaxMask or(VectorMask mask) { + public ShortMaskMax or(VectorMask mask) { Objects.requireNonNull(mask); - ShortMaxMask m = (ShortMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_OR, ShortMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMaskMax m = (ShortMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_OR, ShortMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b)); } @Override @ForceInline - public ShortMaxMask xor(VectorMask mask) { + public ShortMaskMax xor(VectorMask mask) { Objects.requireNonNull(mask); - ShortMaxMask m = (ShortMaxMask)mask; - return VectorSupport.binaryOp(VECTOR_OP_XOR, ShortMaxMask.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, + ShortMaskMax m = (ShortMaskMax)mask; + return VectorSupport.binaryOp(VECTOR_OP_XOR, ShortMaskMax.class, null, LANEBITS_TYPE_ORDINAL, VLENGTH, this, m, null, (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b)); } @@ -726,21 +726,21 @@ final class ShortMaxVector extends ShortVector { @Override @ForceInline public int trueCount() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ShortMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, ShortMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> trueCountHelper(m.getBits())); } @Override @ForceInline public int firstTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ShortMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, ShortMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> firstTrueHelper(m.getBits())); } @Override @ForceInline public int lastTrue() { - return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ShortMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, ShortMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> lastTrueHelper(m.getBits())); } @@ -750,7 +750,7 @@ final class ShortMaxVector extends ShortVector { if (length() > Long.SIZE) { throw new UnsupportedOperationException("too many lanes for one long"); } - return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ShortMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, + return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, ShortMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, (m) -> toLongHelper(m.getBits())); } @@ -760,7 +760,7 @@ final class ShortMaxVector extends ShortVector { @ForceInline public boolean laneIsSet(int i) { Objects.checkIndex(i, length()); - return VectorSupport.extract(ShortMaxMask.class, LANE_TYPE_ORDINAL, VLENGTH, + return VectorSupport.extract(ShortMaskMax.class, LANE_TYPE_ORDINAL, VLENGTH, this, i, (m, idx) -> (m.getBits()[idx] ? 1L : 0L)) == 1L; } @@ -769,48 +769,48 @@ final class ShortMaxVector extends ShortVector { @Override @ForceInline public boolean anyTrue() { - return VectorSupport.test(BT_ne, ShortMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_ne, ShortMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> anyTrueHelper(((ShortMaxMask)m).getBits())); + (m, __) -> anyTrueHelper(((ShortMaskMax)m).getBits())); } @Override @ForceInline public boolean allTrue() { - return VectorSupport.test(BT_overflow, ShortMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + return VectorSupport.test(BT_overflow, ShortMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, this, vspecies().maskAll(true), - (m, __) -> allTrueHelper(((ShortMaxMask)m).getBits())); + (m, __) -> allTrueHelper(((ShortMaskMax)m).getBits())); } @ForceInline /*package-private*/ - static ShortMaxMask maskAll(boolean bit) { - return VectorSupport.fromBitsCoerced(ShortMaxMask.class, LANEBITS_TYPE_ORDINAL, VLENGTH, + static ShortMaskMax maskAll(boolean bit) { + return VectorSupport.fromBitsCoerced(ShortMaskMax.class, LANEBITS_TYPE_ORDINAL, VLENGTH, (bit ? -1 : 0), MODE_BROADCAST, null, (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK)); } - private static final ShortMaxMask TRUE_MASK = new ShortMaxMask(true); - private static final ShortMaxMask FALSE_MASK = new ShortMaxMask(false); + private static final ShortMaskMax TRUE_MASK = new ShortMaskMax(true); + private static final ShortMaskMax FALSE_MASK = new ShortMaskMax(false); } // Shuffle - static final class ShortMaxShuffle extends AbstractShuffle { + static final class ShortShuffleMax extends AbstractShuffle { static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM static final Class ETYPE = short.class; // used by the JVM - ShortMaxShuffle(short[] indices) { + ShortShuffleMax(short[] indices) { super(indices); assert(VLENGTH == indices.length); assert(indicesInRange(indices)); } - ShortMaxShuffle(int[] indices, int i) { + ShortShuffleMax(int[] indices, int i) { this(prepare(indices, i)); } - ShortMaxShuffle(IntUnaryOperator fn) { + ShortShuffleMax(IntUnaryOperator fn) { this(prepare(fn)); } @@ -830,23 +830,23 @@ final class ShortMaxVector extends ShortVector { assert(VLENGTH < Short.MAX_VALUE); assert(Short.MIN_VALUE <= -VLENGTH); } - static final ShortMaxShuffle IOTA = new ShortMaxShuffle(IDENTITY); + static final ShortShuffleMax IOTA = new ShortShuffleMax(IDENTITY); @Override @ForceInline - public ShortMaxVector toVector() { + public ShortVectorMax toVector() { return toBitsVector(); } @Override @ForceInline - ShortMaxVector toBitsVector() { - return (ShortMaxVector) super.toBitsVectorTemplate(); + ShortVectorMax toBitsVector() { + return (ShortVectorMax) super.toBitsVectorTemplate(); } @Override - ShortMaxVector toBitsVector0() { - return ((ShortMaxVector) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); + ShortVectorMax toBitsVector0() { + return ((ShortVectorMax) vspecies().asIntegral().dummyVector()).vectorFactory(indices()); } @Override @@ -883,30 +883,30 @@ final class ShortMaxVector extends ShortVector { @Override @ForceInline - public final ShortMaxMask laneIsValid() { - return (ShortMaxMask) toBitsVector().compare(VectorOperators.GE, 0) + public final ShortMaskMax laneIsValid() { + return (ShortMaskMax) toBitsVector().compare(VectorOperators.GE, 0) .cast(vspecies()); } @ForceInline @Override - public final ShortMaxShuffle rearrange(VectorShuffle shuffle) { - ShortMaxShuffle concreteShuffle = (ShortMaxShuffle) shuffle; - return (ShortMaxShuffle) toBitsVector().rearrange(concreteShuffle) + public final ShortShuffleMax rearrange(VectorShuffle shuffle) { + ShortShuffleMax concreteShuffle = (ShortShuffleMax) shuffle; + return (ShortShuffleMax) toBitsVector().rearrange(concreteShuffle) .toShuffle(vspecies(), false); } @ForceInline @Override - public final ShortMaxShuffle wrapIndexes() { - ShortMaxVector v = toBitsVector(); + public final ShortShuffleMax wrapIndexes() { + ShortVectorMax v = toBitsVector(); if ((length() & (length() - 1)) == 0) { - v = (ShortMaxVector) v.lanewise(VectorOperators.AND, length() - 1); + v = (ShortVectorMax) v.lanewise(VectorOperators.AND, length() - 1); } else { - v = (ShortMaxVector) v.blend(v.lanewise(VectorOperators.ADD, length()), + v = (ShortVectorMax) v.blend(v.lanewise(VectorOperators.ADD, length()), v.compare(VectorOperators.LT, 0)); } - return (ShortMaxShuffle) v.toShuffle(vspecies(), false); + return (ShortShuffleMax) v.toShuffle(vspecies(), false); } private static short[] prepare(int[] indices, int offset) { @@ -957,14 +957,14 @@ final class ShortMaxVector extends ShortVector { @Override final ShortVector fromArray0(short[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromArray0Template(ShortMaxMask.class, a, offset, (ShortMaxMask) m, offsetInRange); // specialize + return super.fromArray0Template(ShortMaskMax.class, a, offset, (ShortMaskMax) m, offsetInRange); // specialize } @ForceInline @Override final ShortVector fromArray0(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask m) { - return super.fromArray0Template(ShortMaxMask.class, a, offset, indexMap, mapOffset, (ShortMaxMask) m); + return super.fromArray0Template(ShortMaskMax.class, a, offset, indexMap, mapOffset, (ShortMaskMax) m); } @ForceInline @@ -978,7 +978,7 @@ final class ShortMaxVector extends ShortVector { @Override final ShortVector fromCharArray0(char[] a, int offset, VectorMask m, int offsetInRange) { - return super.fromCharArray0Template(ShortMaxMask.class, a, offset, (ShortMaxMask) m, offsetInRange); // specialize + return super.fromCharArray0Template(ShortMaskMax.class, a, offset, (ShortMaskMax) m, offsetInRange); // specialize } @@ -993,7 +993,7 @@ final class ShortMaxVector extends ShortVector { @Override final ShortVector fromMemorySegment0(MemorySegment ms, long offset, VectorMask m, int offsetInRange) { - return super.fromMemorySegment0Template(ShortMaxMask.class, ms, offset, (ShortMaxMask) m, offsetInRange); // specialize + return super.fromMemorySegment0Template(ShortMaskMax.class, ms, offset, (ShortMaskMax) m, offsetInRange); // specialize } @ForceInline @@ -1007,7 +1007,7 @@ final class ShortMaxVector extends ShortVector { @Override final void intoArray0(short[] a, int offset, VectorMask m) { - super.intoArray0Template(ShortMaxMask.class, a, offset, (ShortMaxMask) m); + super.intoArray0Template(ShortMaskMax.class, a, offset, (ShortMaskMax) m); } @@ -1016,14 +1016,14 @@ final class ShortMaxVector extends ShortVector { @Override final void intoMemorySegment0(MemorySegment ms, long offset, VectorMask m) { - super.intoMemorySegment0Template(ShortMaxMask.class, ms, offset, (ShortMaxMask) m); + super.intoMemorySegment0Template(ShortMaskMax.class, ms, offset, (ShortMaskMax) m); } @ForceInline @Override final void intoCharArray0(char[] a, int offset, VectorMask m) { - super.intoCharArray0Template(ShortMaxMask.class, a, offset, (ShortMaxMask) m); + super.intoCharArray0Template(ShortMaskMax.class, a, offset, (ShortMaskMax) m); } // End of specialized low-level memory operations. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/VectorMathLibrary.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/VectorMathLibrary.java index ecd03ab9124..4898cb70884 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/VectorMathLibrary.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/VectorMathLibrary.java @@ -139,8 +139,8 @@ import static jdk.internal.vm.vector.Utils.debug; public String symbolName(Operator op, VectorSpecies vspecies) { String suffix = suffix(vspecies); String elemType = (vspecies.elementType() == float.class ? "f" : ""); - boolean isFloat64Vector = (vspecies.elementType() == float.class) && (vspecies.length() == 2); // Float64Vector or FloatMaxVector - int vlen = (isFloat64Vector ? 4 : vspecies.length()); // reuse 128-bit variant for 64-bit float vectors + boolean isFloatVector64 = (vspecies.elementType() == float.class) && (vspecies.length() == 2); // FloatVector64 or FloatVectorMax + int vlen = (isFloatVector64 ? 4 : vspecies.length()); // reuse 128-bit variant for 64-bit float vectors return String.format("__jsvml_%s%s%d_ha_%s", op.operatorName(), elemType, vlen, suffix); } @@ -211,8 +211,8 @@ import static jdk.internal.vm.vector.Utils.debug; @Override public String symbolName(Operator op, VectorSpecies vspecies) { - boolean isFloat64Vector = (vspecies.elementType() == float.class) && (vspecies.length() == 2); // Float64Vector or FloatMaxVector - int vlen = (isFloat64Vector ? 4 : vspecies.length()); // reuse 128-bit variant for 64-bit float vectors + boolean isFloatVector64 = (vspecies.elementType() == float.class) && (vspecies.length() == 2); // FloatVector64 or FloatVectorMax + int vlen = (isFloatVector64 ? 4 : vspecies.length()); // reuse 128-bit variant for 64-bit float vectors boolean isShapeAgnostic = isRISCV64() || (isAARCH64() && vspecies.vectorBitSize() > 128); return String.format("%s%s%s_%s%s", op.operatorName(), (vspecies.elementType() == float.class ? "f" : "d"), diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template index 48d6ed762be..d6763c2c03a 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template @@ -88,8 +88,8 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { // The various shape-specific subclasses // also specialize them by wrapping // them in a call like this: - // return (Byte128Vector) - // super.bOp((Byte128Vector) o); + // return (ByteVector128) + // super.bOp((ByteVector128) o); // The purpose of that is to forcibly inline // the generic definition from this file // into a sharply-typed and size-specific @@ -3829,7 +3829,7 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { // Index vector: vix[0:n] = k -> offset + indexMap[mapOffset + k] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For $Type$MaxVector, if vector length is non-power-of-two or + // For $Type$VectorMax, if vector length is non-power-of-two or // 2048 bits, indexShape of $Type$ species is S_MAX_BIT. // Assume that vector length is 2048, then the lane count of $Type$ // vector is 32. When converting $Type$ species to int species, @@ -3837,7 +3837,7 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -4455,14 +4455,14 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { // Index vector: vix[0:n] = i -> offset + indexMap[mo + i] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For $Type$MaxVector, if vector length is 2048 bits, indexShape + // For $Type$VectorMax, if vector length is 2048 bits, indexShape // of $Type$ species is S_MAX_BIT. and the lane count of $Type$ // vector is 32. When converting $Type$ species to int species, // indexShape is still S_MAX_BIT, but the lane count of int vector // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -5061,7 +5061,7 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { // Index vector: vix[0:n] = k -> offset + indexMap[mapOffset + k] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For $Type$MaxVector, if vector length is non-power-of-two or + // For $Type$VectorMax, if vector length is non-power-of-two or // 2048 bits, indexShape of $Type$ species is S_MAX_BIT. // Assume that vector length is 2048, then the lane count of $Type$ // vector is 32. When converting $Type$ species to int species, @@ -5069,7 +5069,7 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -5252,14 +5252,14 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { // Index vector: vix[0:n] = i -> offset + indexMap[mo + i] IntVector vix; if (isp.laneCount() != vsp.laneCount()) { - // For $Type$MaxVector, if vector length is 2048 bits, indexShape + // For $Type$VectorMax, if vector length is 2048 bits, indexShape // of $Type$ species is S_MAX_BIT. and the lane count of $Type$ // vector is 32. When converting $Type$ species to int species, // indexShape is still S_MAX_BIT, but the lane count of int vector // is 64. So when loading index vector (IntVector), only lower half // of index data is needed. vix = IntVector - .fromArray(isp, indexMap, mapOffset, IntMaxVector.IntMaxMask.LOWER_HALF_TRUE_MASK) + .fromArray(isp, indexMap, mapOffset, IntVectorMax.IntMaskMax.LOWER_HALF_TRUE_MASK) .add(offset); } else { vix = IntVector @@ -5813,13 +5813,13 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { @Override @ForceInline public final $abstractvectortype$ zero() { - if ((Class) vectorType() == $Type$MaxVector.class) - return $Type$MaxVector.ZERO; + if ((Class) vectorType() == $Type$VectorMax.class) + return $Type$VectorMax.ZERO; switch (vectorBitSize()) { - case 64: return $Type$64Vector.ZERO; - case 128: return $Type$128Vector.ZERO; - case 256: return $Type$256Vector.ZERO; - case 512: return $Type$512Vector.ZERO; + case 64: return $Type$Vector64.ZERO; + case 128: return $Type$Vector128.ZERO; + case 256: return $Type$Vector256.ZERO; + case 512: return $Type$Vector512.ZERO; } throw new AssertionError(); } @@ -5827,13 +5827,13 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { @Override @ForceInline public final $abstractvectortype$ iota() { - if ((Class) vectorType() == $Type$MaxVector.class) - return $Type$MaxVector.IOTA; + if ((Class) vectorType() == $Type$VectorMax.class) + return $Type$VectorMax.IOTA; switch (vectorBitSize()) { - case 64: return $Type$64Vector.IOTA; - case 128: return $Type$128Vector.IOTA; - case 256: return $Type$256Vector.IOTA; - case 512: return $Type$512Vector.IOTA; + case 64: return $Type$Vector64.IOTA; + case 128: return $Type$Vector128.IOTA; + case 256: return $Type$Vector256.IOTA; + case 512: return $Type$Vector512.IOTA; } throw new AssertionError(); } @@ -5842,13 +5842,13 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { @Override @ForceInline public final VectorMask<$Boxtype$> maskAll(boolean bit) { - if ((Class) vectorType() == $Type$MaxVector.class) - return $Type$MaxVector.$Type$MaxMask.maskAll(bit); + if ((Class) vectorType() == $Type$VectorMax.class) + return $Type$VectorMax.$Type$MaskMax.maskAll(bit); switch (vectorBitSize()) { - case 64: return $Type$64Vector.$Type$64Mask.maskAll(bit); - case 128: return $Type$128Vector.$Type$128Mask.maskAll(bit); - case 256: return $Type$256Vector.$Type$256Mask.maskAll(bit); - case 512: return $Type$512Vector.$Type$512Mask.maskAll(bit); + case 64: return $Type$Vector64.$Type$Mask64.maskAll(bit); + case 128: return $Type$Vector128.$Type$Mask128.maskAll(bit); + case 256: return $Type$Vector256.$Type$Mask256.maskAll(bit); + case 512: return $Type$Vector512.$Type$Mask512.maskAll(bit); } throw new AssertionError(); } @@ -5876,42 +5876,42 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ public static final VectorSpecies<$Boxtype$> SPECIES_64 = new $Type$Species(VectorShape.S_64_BIT, - $Type$64Vector.class, - $Type$64Vector.$Type$64Mask.class, - $Type$64Vector.$Type$64Shuffle.class, - $Type$64Vector::new); + $Type$Vector64.class, + $Type$Vector64.$Type$Mask64.class, + $Type$Vector64.$Type$Shuffle64.class, + $Type$Vector64::new); /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ public static final VectorSpecies<$Boxtype$> SPECIES_128 = new $Type$Species(VectorShape.S_128_BIT, - $Type$128Vector.class, - $Type$128Vector.$Type$128Mask.class, - $Type$128Vector.$Type$128Shuffle.class, - $Type$128Vector::new); + $Type$Vector128.class, + $Type$Vector128.$Type$Mask128.class, + $Type$Vector128.$Type$Shuffle128.class, + $Type$Vector128::new); /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ public static final VectorSpecies<$Boxtype$> SPECIES_256 = new $Type$Species(VectorShape.S_256_BIT, - $Type$256Vector.class, - $Type$256Vector.$Type$256Mask.class, - $Type$256Vector.$Type$256Shuffle.class, - $Type$256Vector::new); + $Type$Vector256.class, + $Type$Vector256.$Type$Mask256.class, + $Type$Vector256.$Type$Shuffle256.class, + $Type$Vector256::new); /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ public static final VectorSpecies<$Boxtype$> SPECIES_512 = new $Type$Species(VectorShape.S_512_BIT, - $Type$512Vector.class, - $Type$512Vector.$Type$512Mask.class, - $Type$512Vector.$Type$512Shuffle.class, - $Type$512Vector::new); + $Type$Vector512.class, + $Type$Vector512.$Type$Mask512.class, + $Type$Vector512.$Type$Shuffle512.class, + $Type$Vector512::new); /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ public static final VectorSpecies<$Boxtype$> SPECIES_MAX = new $Type$Species(VectorShape.S_Max_BIT, - $Type$MaxVector.class, - $Type$MaxVector.$Type$MaxMask.class, - $Type$MaxVector.$Type$MaxShuffle.class, - $Type$MaxVector::new); + $Type$VectorMax.class, + $Type$VectorMax.$Type$MaskMax.class, + $Type$VectorMax.$Type$ShuffleMax.class, + $Type$VectorMax::new); /** * Preferred species for {@link $Type$Vector}s. diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorBits.java.template b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorBits.java.template index 61ac02d84f6..7076ed183ea 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorBits.java.template +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-VectorBits.java.template @@ -183,8 +183,8 @@ final class $vectortype$ extends $abstractvectortype$ { @ForceInline final @Override - Byte$bits$Vector asByteVectorRaw() { - return (Byte$bits$Vector) super.asByteVectorRawTemplate(); // specialize + ByteVector$bits$ asByteVectorRaw() { + return (ByteVector$bits$) super.asByteVectorRawTemplate(); // specialize } @ForceInline @@ -1092,7 +1092,7 @@ final class $vectortype$ extends $abstractvectortype$ { #end[intAndMax] #if[intAndMax] - static final IntMaxMask LOWER_HALF_TRUE_MASK = new IntMaxMask(maskLowerHalf()); + static final IntMaskMax LOWER_HALF_TRUE_MASK = new IntMaskMax(maskLowerHalf()); #end[intAndMax] } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/gen-src.sh b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/gen-src.sh index a9f1648eaa7..052a7ff2ddb 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/gen-src.sh +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/gen-src.sh @@ -137,7 +137,7 @@ do args="$args -DsizeInBytes=$sizeInBytes" abstractvectortype=${typeprefix}${Type}Vector - abstractbitsvectortype=${typeprefix}${Bitstype}Vector + abstractbitsvectortype=${typeprefix}Vector${Bitstype} abstractfpvectortype=${typeprefix}${Fptype}Vector args="$args -Dabstractvectortype=$abstractvectortype -Dabstractbitsvectortype=$abstractbitsvectortype -Dabstractfpvectortype=$abstractfpvectortype" case $abstractvectortype in @@ -158,11 +158,11 @@ do old_args="$args" for bits in 64 128 256 512 Max do - vectortype=${typeprefix}${Type}${bits}Vector - masktype=${typeprefix}${Type}${bits}Mask - shuffletype=${typeprefix}${Type}${bits}Shuffle - bitsvectortype=${typeprefix}${Bitstype}${bits}Vector - fpvectortype=${typeprefix}${Fptype}${bits}Vector + vectortype=${typeprefix}${Type}Vector${bits} + masktype=${typeprefix}${Type}Mask${bits} + shuffletype=${typeprefix}${Type}Shuffle${bits} + bitsvectortype=${typeprefix}${Bitstype}Vector${bits} + fpvectortype=${typeprefix}${Fptype}Vector${bits} vectorindexbits=$((bits * 4 / sizeInBytes)) numLanes=$((bits / (sizeInBytes * 8))) @@ -185,7 +185,7 @@ do if [[ "${bits}" == "Max" ]]; then vectorindextype="vix.getClass()" else - vectorindextype="Int${vectorindexbits}Vector.class" + vectorindextype="IntVector${vectorindexbits}.class" fi; BITS=$bits @@ -199,7 +199,7 @@ do Shape=S_${bits}_BIT args="$old_args" args="$args -K$lanes -K$bits" - if [[ "${vectortype}" == "IntMaxVector" ]]; then + if [[ "${vectortype}" == "IntVectorMax" ]]; then args="$args -KintAndMax" fi bitargs="$args -Dbits=$bits -DBITS=$BITS -Dvectortype=$vectortype -Dmasktype=$masktype -Dshuffletype=$shuffletype -Dbitsvectortype=$bitsvectortype -Dfpvectortype=$fpvectortype -Dvectorindextype=$vectorindextype -Dshape=$shape -DShape=$Shape" diff --git a/test/jdk/jdk/incubator/vector/Byte128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ByteVector128LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Byte128VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ByteVector128LoadStoreTests.java index 1a50b5d8945..0fa23ef55e1 100644 --- a/test/jdk/jdk/incubator/vector/Byte128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVector128LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Byte128VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation ByteVector128LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Byte128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ByteVector128LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_128; diff --git a/test/jdk/jdk/incubator/vector/Byte128VectorTests.java b/test/jdk/jdk/incubator/vector/ByteVector128Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Byte128VectorTests.java rename to test/jdk/jdk/incubator/vector/ByteVector128Tests.java index fa801f05a19..91148fd5d66 100644 --- a/test/jdk/jdk/incubator/vector/Byte128VectorTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVector128Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Byte128VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ByteVector128Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Byte128VectorTests extends AbstractVectorTest { +public class ByteVector128Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_128; @@ -1705,7 +1705,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByte128VectorTests(IntFunction fa, IntFunction fb) { + static void ADDByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1718,7 +1718,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::ADD); + assertArraysEquals(r, a, b, ByteVector128Tests::ADD); } static byte add(byte a, byte b) { @@ -1726,7 +1726,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void addByte128VectorTests(IntFunction fa, IntFunction fb) { + static void addByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1737,11 +1737,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte128VectorTests::add); + assertArraysEquals(r, a, b, ByteVector128Tests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1757,11 +1757,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::ADD); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1775,7 +1775,7 @@ public class Byte128VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::add); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::add); } static byte SUB(byte a, byte b) { @@ -1783,7 +1783,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void SUBByte128VectorTests(IntFunction fa, IntFunction fb) { + static void SUBByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1796,7 +1796,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::SUB); + assertArraysEquals(r, a, b, ByteVector128Tests::SUB); } static byte sub(byte a, byte b) { @@ -1804,7 +1804,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void subByte128VectorTests(IntFunction fa, IntFunction fb) { + static void subByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1815,11 +1815,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte128VectorTests::sub); + assertArraysEquals(r, a, b, ByteVector128Tests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void SUBByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1835,11 +1835,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::SUB); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::SUB); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1853,7 +1853,7 @@ public class Byte128VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::sub); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::sub); } static byte MUL(byte a, byte b) { @@ -1861,7 +1861,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MULByte128VectorTests(IntFunction fa, IntFunction fb) { + static void MULByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1874,7 +1874,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::MUL); + assertArraysEquals(r, a, b, ByteVector128Tests::MUL); } static byte mul(byte a, byte b) { @@ -1882,7 +1882,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByte128VectorTests(IntFunction fa, IntFunction fb) { + static void mulByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1893,11 +1893,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte128VectorTests::mul); + assertArraysEquals(r, a, b, ByteVector128Tests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void MULByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1913,11 +1913,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::MUL); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::MUL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1931,7 +1931,7 @@ public class Byte128VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::mul); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::mul); } static byte DIV(byte a, byte b) { @@ -1939,7 +1939,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void DIVByte128VectorTests(IntFunction fa, IntFunction fb) { + static void DIVByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1954,7 +1954,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::DIV); + assertArraysEquals(r, a, b, ByteVector128Tests::DIV); } static byte div(byte a, byte b) { @@ -1962,7 +1962,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void divByte128VectorTests(IntFunction fa, IntFunction fb) { + static void divByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1977,11 +1977,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::div); + assertArraysEquals(r, a, b, ByteVector128Tests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void DIVByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1999,11 +1999,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::DIV); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::DIV); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2021,7 +2021,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::div); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::div); } static byte FIRST_NONZERO(byte a, byte b) { @@ -2029,7 +2029,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void FIRST_NONZEROByte128VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2042,11 +2042,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ByteVector128Tests::FIRST_NONZERO); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void FIRST_NONZEROByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2062,7 +2062,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::FIRST_NONZERO); } static byte AND(byte a, byte b) { @@ -2070,7 +2070,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByte128VectorTests(IntFunction fa, IntFunction fb) { + static void ANDByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2083,7 +2083,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::AND); + assertArraysEquals(r, a, b, ByteVector128Tests::AND); } static byte and(byte a, byte b) { @@ -2091,7 +2091,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void andByte128VectorTests(IntFunction fa, IntFunction fb) { + static void andByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2102,11 +2102,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte128VectorTests::and); + assertArraysEquals(r, a, b, ByteVector128Tests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2122,7 +2122,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::AND); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::AND); } static byte AND_NOT(byte a, byte b) { @@ -2130,7 +2130,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void AND_NOTByte128VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2143,11 +2143,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::AND_NOT); + assertArraysEquals(r, a, b, ByteVector128Tests::AND_NOT); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void AND_NOTByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2163,7 +2163,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::AND_NOT); } static byte OR(byte a, byte b) { @@ -2171,7 +2171,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte128VectorTests(IntFunction fa, IntFunction fb) { + static void ORByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2184,7 +2184,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::OR); + assertArraysEquals(r, a, b, ByteVector128Tests::OR); } static byte or(byte a, byte b) { @@ -2192,7 +2192,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void orByte128VectorTests(IntFunction fa, IntFunction fb) { + static void orByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2203,11 +2203,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte128VectorTests::or); + assertArraysEquals(r, a, b, ByteVector128Tests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2223,7 +2223,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::OR); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::OR); } static byte XOR(byte a, byte b) { @@ -2231,7 +2231,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void XORByte128VectorTests(IntFunction fa, IntFunction fb) { + static void XORByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2244,11 +2244,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::XOR); + assertArraysEquals(r, a, b, ByteVector128Tests::XOR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void XORByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2264,11 +2264,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::XOR); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::XOR); } @Test(dataProvider = "byteBinaryOpProvider") - static void addByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2278,11 +2278,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2295,11 +2295,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector128Tests::add); } @Test(dataProvider = "byteBinaryOpProvider") - static void subByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2309,11 +2309,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2326,11 +2326,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector128Tests::sub); } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2340,11 +2340,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2357,11 +2357,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector128Tests::mul); } @Test(dataProvider = "byteBinaryOpProvider") - static void divByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2373,11 +2373,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2392,11 +2392,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector128Tests::div); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2406,11 +2406,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void orByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2420,11 +2420,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::or); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2437,11 +2437,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte128VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector128Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2451,11 +2451,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void andByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2465,11 +2465,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::and); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2482,11 +2482,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte128VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector128Tests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2496,11 +2496,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Byte128VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ByteVector128Tests::OR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2513,11 +2513,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte128VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector128Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByte128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDByteVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2527,11 +2527,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Byte128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ByteVector128Tests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByte128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDByteVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2544,7 +2544,7 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector128Tests::ADD); } static byte LSHL(byte a, byte b) { @@ -2552,7 +2552,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByte128VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2565,11 +2565,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::LSHL); + assertArraysEquals(r, a, b, ByteVector128Tests::LSHL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2585,7 +2585,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::LSHL); } static byte ASHR(byte a, byte b) { @@ -2593,7 +2593,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByte128VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2606,11 +2606,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::ASHR); + assertArraysEquals(r, a, b, ByteVector128Tests::ASHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2626,7 +2626,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::ASHR); } static byte LSHR(byte a, byte b) { @@ -2634,7 +2634,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByte128VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2647,11 +2647,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::LSHR); + assertArraysEquals(r, a, b, ByteVector128Tests::LSHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2667,7 +2667,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::LSHR); } static byte LSHL_unary(byte a, byte b) { @@ -2675,7 +2675,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByte128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLByteVector128TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2687,11 +2687,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte128VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ByteVector128Tests::LSHL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByte128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2706,7 +2706,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte128VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector128Tests::LSHL_unary); } static byte LSHR_unary(byte a, byte b) { @@ -2714,7 +2714,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByte128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRByteVector128TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2726,11 +2726,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte128VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ByteVector128Tests::LSHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByte128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2745,7 +2745,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte128VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector128Tests::LSHR_unary); } static byte ASHR_unary(byte a, byte b) { @@ -2753,7 +2753,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByte128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRByteVector128TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2765,11 +2765,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte128VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ByteVector128Tests::ASHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByte128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2784,7 +2784,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte128VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector128Tests::ASHR_unary); } static byte ROR(byte a, byte b) { @@ -2792,7 +2792,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByte128VectorTests(IntFunction fa, IntFunction fb) { + static void RORByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2805,11 +2805,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::ROR); + assertArraysEquals(r, a, b, ByteVector128Tests::ROR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2825,7 +2825,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::ROR); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::ROR); } static byte ROL(byte a, byte b) { @@ -2833,7 +2833,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByte128VectorTests(IntFunction fa, IntFunction fb) { + static void ROLByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2846,11 +2846,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::ROL); + assertArraysEquals(r, a, b, ByteVector128Tests::ROL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2866,7 +2866,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::ROL); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::ROL); } static byte ROR_unary(byte a, byte b) { @@ -2874,7 +2874,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByte128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORByteVector128TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2886,11 +2886,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte128VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ByteVector128Tests::ROR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByte128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORByteVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2905,7 +2905,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte128VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector128Tests::ROR_unary); } static byte ROL_unary(byte a, byte b) { @@ -2913,7 +2913,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByte128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLByteVector128TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2925,11 +2925,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte128VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ByteVector128Tests::ROL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByte128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLByteVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2944,14 +2944,14 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte128VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector128Tests::ROL_unary); } static byte LSHR_binary_const(byte a) { return (byte)(((a & 0xFF) >>> CONST_SHIFT)); } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHRByte128VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRByteVector128TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2962,11 +2962,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte128VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ByteVector128Tests::LSHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHRByte128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRByteVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2980,7 +2980,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte128VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector128Tests::LSHR_binary_const); } static byte LSHL_binary_const(byte a) { @@ -2988,7 +2988,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHLByte128VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLByteVector128TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2999,11 +2999,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte128VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ByteVector128Tests::LSHL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHLByte128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLByteVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3017,7 +3017,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte128VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector128Tests::LSHL_binary_const); } static byte ASHR_binary_const(byte a) { @@ -3025,7 +3025,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ASHRByte128VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRByteVector128TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3036,11 +3036,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte128VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ByteVector128Tests::ASHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ASHRByte128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRByteVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3054,7 +3054,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte128VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector128Tests::ASHR_binary_const); } static byte ROR_binary_const(byte a) { @@ -3062,7 +3062,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void RORByte128VectorTestsScalarShiftConst(IntFunction fa) { + static void RORByteVector128TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3073,11 +3073,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte128VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ByteVector128Tests::ROR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void RORByte128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORByteVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3091,7 +3091,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte128VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector128Tests::ROR_binary_const); } static byte ROL_binary_const(byte a) { @@ -3099,7 +3099,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ROLByte128VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLByteVector128TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3110,11 +3110,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte128VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ByteVector128Tests::ROL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ROLByte128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLByteVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3128,14 +3128,14 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte128VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector128Tests::ROL_binary_const); } static ByteVector bv_MIN = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MINByte128VectorTestsWithMemOp(IntFunction fa) { + static void MINByteVector128TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3146,13 +3146,13 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte128VectorTests::MIN); + assertArraysEquals(r, a, (byte)10, ByteVector128Tests::MIN); } static ByteVector bv_min = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void minByte128VectorTestsWithMemOp(IntFunction fa) { + static void minByteVector128TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3163,13 +3163,13 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte128VectorTests::min); + assertArraysEquals(r, a, (byte)10, ByteVector128Tests::min); } static ByteVector bv_MIN_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINByte128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINByteVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3182,13 +3182,13 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, Byte128VectorTests::MIN); + assertArraysEquals(r, a, (byte)10, mask, ByteVector128Tests::MIN); } static ByteVector bv_MAX = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MAXByte128VectorTestsWithMemOp(IntFunction fa) { + static void MAXByteVector128TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3199,13 +3199,13 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte128VectorTests::MAX); + assertArraysEquals(r, a, (byte)10, ByteVector128Tests::MAX); } static ByteVector bv_max = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void maxByte128VectorTestsWithMemOp(IntFunction fa) { + static void maxByteVector128TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3216,13 +3216,13 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte128VectorTests::max); + assertArraysEquals(r, a, (byte)10, ByteVector128Tests::max); } static ByteVector bv_MAX_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXByte128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXByteVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3235,7 +3235,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, Byte128VectorTests::MAX); + assertArraysEquals(r, a, (byte)10, mask, ByteVector128Tests::MAX); } static byte MIN(byte a, byte b) { @@ -3243,7 +3243,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByte128VectorTests(IntFunction fa, IntFunction fb) { + static void MINByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3256,7 +3256,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::MIN); + assertArraysEquals(r, a, b, ByteVector128Tests::MIN); } static byte min(byte a, byte b) { @@ -3264,7 +3264,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void minByte128VectorTests(IntFunction fa, IntFunction fb) { + static void minByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3275,7 +3275,7 @@ public class Byte128VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte128VectorTests::min); + assertArraysEquals(r, a, b, ByteVector128Tests::min); } static byte MAX(byte a, byte b) { @@ -3283,7 +3283,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByte128VectorTests(IntFunction fa, IntFunction fb) { + static void MAXByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3296,7 +3296,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::MAX); + assertArraysEquals(r, a, b, ByteVector128Tests::MAX); } static byte max(byte a, byte b) { @@ -3304,7 +3304,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByte128VectorTests(IntFunction fa, IntFunction fb) { + static void maxByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3315,7 +3315,7 @@ public class Byte128VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte128VectorTests::max); + assertArraysEquals(r, a, b, ByteVector128Tests::max); } static byte UMIN(byte a, byte b) { @@ -3323,7 +3323,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMINByte128VectorTests(IntFunction fa, IntFunction fb) { + static void UMINByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3336,11 +3336,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::UMIN); + assertArraysEquals(r, a, b, ByteVector128Tests::UMIN); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMINByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3356,7 +3356,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::UMIN); } static byte UMAX(byte a, byte b) { @@ -3364,7 +3364,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMAXByte128VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3377,11 +3377,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::UMAX); + assertArraysEquals(r, a, b, ByteVector128Tests::UMAX); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMAXByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3397,7 +3397,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::UMAX); } static byte SADD(byte a, byte b) { @@ -3405,7 +3405,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SADDByte128VectorTests(IntFunction fa, IntFunction fb) { + static void SADDByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3418,11 +3418,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::SADD); + assertArraysEquals(r, a, b, ByteVector128Tests::SADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SADDByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3438,7 +3438,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::SADD); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::SADD); } static byte SSUB(byte a, byte b) { @@ -3446,7 +3446,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SSUBByte128VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3459,11 +3459,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::SSUB); + assertArraysEquals(r, a, b, ByteVector128Tests::SSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SSUBByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3479,7 +3479,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::SSUB); } static byte SUADD(byte a, byte b) { @@ -3487,7 +3487,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUADDByte128VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3500,11 +3500,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::SUADD); + assertArraysEquals(r, a, b, ByteVector128Tests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUADDByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3520,7 +3520,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::SUADD); } static byte SUSUB(byte a, byte b) { @@ -3528,7 +3528,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUSUBByte128VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3541,11 +3541,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::SUSUB); + assertArraysEquals(r, a, b, ByteVector128Tests::SUSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUSUBByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3561,11 +3561,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::SUSUB); } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3575,11 +3575,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::MIN); } @Test(dataProvider = "byteBinaryOpProvider") - static void minByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3589,11 +3589,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::min); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::min); } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3603,11 +3603,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::MAX); } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3617,10 +3617,10 @@ public class Byte128VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte128VectorTests::max); + assertBroadcastArraysEquals(r, a, b, ByteVector128Tests::max); } @Test(dataProvider = "byteSaturatingBinaryOpAssocProvider") - static void SUADDAssocByte128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocByteVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -3637,11 +3637,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Byte128VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ByteVector128Tests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3662,7 +3662,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Byte128VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ByteVector128Tests::SUADD); } static byte ANDReduce(byte[] a, int idx) { @@ -3684,7 +3684,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ANDReduceByte128VectorTests(IntFunction fa) { + static void ANDReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3700,7 +3700,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::ANDReduce, Byte128VectorTests::ANDReduceAll); + ByteVector128Tests::ANDReduce, ByteVector128Tests::ANDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3746,7 +3746,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ANDReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3764,7 +3764,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::ANDReduceMasked, Byte128VectorTests::ANDReduceAllMasked); + ByteVector128Tests::ANDReduceMasked, ByteVector128Tests::ANDReduceAllMasked); } static byte ORReduce(byte[] a, int idx) { @@ -3786,7 +3786,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ORReduceByte128VectorTests(IntFunction fa) { + static void ORReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3802,7 +3802,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::ORReduce, Byte128VectorTests::ORReduceAll); + ByteVector128Tests::ORReduce, ByteVector128Tests::ORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3848,7 +3848,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ORReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3866,7 +3866,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::ORReduceMasked, Byte128VectorTests::ORReduceAllMasked); + ByteVector128Tests::ORReduceMasked, ByteVector128Tests::ORReduceAllMasked); } static byte XORReduce(byte[] a, int idx) { @@ -3888,7 +3888,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void XORReduceByte128VectorTests(IntFunction fa) { + static void XORReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3904,7 +3904,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::XORReduce, Byte128VectorTests::XORReduceAll); + ByteVector128Tests::XORReduce, ByteVector128Tests::XORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3950,7 +3950,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void XORReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3968,7 +3968,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::XORReduceMasked, Byte128VectorTests::XORReduceAllMasked); + ByteVector128Tests::XORReduceMasked, ByteVector128Tests::XORReduceAllMasked); } static byte ADDReduce(byte[] a, int idx) { @@ -3990,7 +3990,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceByte128VectorTests(IntFunction fa) { + static void ADDReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4006,7 +4006,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::ADDReduce, Byte128VectorTests::ADDReduceAll); + ByteVector128Tests::ADDReduce, ByteVector128Tests::ADDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4052,7 +4052,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4070,7 +4070,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::ADDReduceMasked, Byte128VectorTests::ADDReduceAllMasked); + ByteVector128Tests::ADDReduceMasked, ByteVector128Tests::ADDReduceAllMasked); } static byte MULReduce(byte[] a, int idx) { @@ -4092,7 +4092,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MULReduceByte128VectorTests(IntFunction fa) { + static void MULReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4108,7 +4108,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::MULReduce, Byte128VectorTests::MULReduceAll); + ByteVector128Tests::MULReduce, ByteVector128Tests::MULReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4154,7 +4154,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MULReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4172,7 +4172,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::MULReduceMasked, Byte128VectorTests::MULReduceAllMasked); + ByteVector128Tests::MULReduceMasked, ByteVector128Tests::MULReduceAllMasked); } static byte MINReduce(byte[] a, int idx) { @@ -4194,7 +4194,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MINReduceByte128VectorTests(IntFunction fa) { + static void MINReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4210,7 +4210,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::MINReduce, Byte128VectorTests::MINReduceAll); + ByteVector128Tests::MINReduce, ByteVector128Tests::MINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4256,7 +4256,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4274,7 +4274,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::MINReduceMasked, Byte128VectorTests::MINReduceAllMasked); + ByteVector128Tests::MINReduceMasked, ByteVector128Tests::MINReduceAllMasked); } static byte MAXReduce(byte[] a, int idx) { @@ -4296,7 +4296,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MAXReduceByte128VectorTests(IntFunction fa) { + static void MAXReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4312,7 +4312,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::MAXReduce, Byte128VectorTests::MAXReduceAll); + ByteVector128Tests::MAXReduce, ByteVector128Tests::MAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4358,7 +4358,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4376,7 +4376,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::MAXReduceMasked, Byte128VectorTests::MAXReduceAllMasked); + ByteVector128Tests::MAXReduceMasked, ByteVector128Tests::MAXReduceAllMasked); } static byte UMINReduce(byte[] a, int idx) { @@ -4398,7 +4398,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMINReduceByte128VectorTests(IntFunction fa) { + static void UMINReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4414,7 +4414,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::UMINReduce, Byte128VectorTests::UMINReduceAll); + ByteVector128Tests::UMINReduce, ByteVector128Tests::UMINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4460,7 +4460,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMINReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4478,7 +4478,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::UMINReduceMasked, Byte128VectorTests::UMINReduceAllMasked); + ByteVector128Tests::UMINReduceMasked, ByteVector128Tests::UMINReduceAllMasked); } static byte UMAXReduce(byte[] a, int idx) { @@ -4500,7 +4500,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMAXReduceByte128VectorTests(IntFunction fa) { + static void UMAXReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4516,7 +4516,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::UMAXReduce, Byte128VectorTests::UMAXReduceAll); + ByteVector128Tests::UMAXReduce, ByteVector128Tests::UMAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4562,7 +4562,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMAXReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4580,7 +4580,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::UMAXReduceMasked, Byte128VectorTests::UMAXReduceAllMasked); + ByteVector128Tests::UMAXReduceMasked, ByteVector128Tests::UMAXReduceAllMasked); } static byte FIRST_NONZEROReduce(byte[] a, int idx) { @@ -4602,7 +4602,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void FIRST_NONZEROReduceByte128VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4618,7 +4618,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::FIRST_NONZEROReduce, Byte128VectorTests::FIRST_NONZEROReduceAll); + ByteVector128Tests::FIRST_NONZEROReduce, ByteVector128Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4664,7 +4664,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void FIRST_NONZEROReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4682,7 +4682,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::FIRST_NONZEROReduceMasked, Byte128VectorTests::FIRST_NONZEROReduceAllMasked); + ByteVector128Tests::FIRST_NONZEROReduceMasked, ByteVector128Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4695,7 +4695,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueByte128VectorTests(IntFunction fm) { + static void anyTrueByteVector128Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4706,7 +4706,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Byte128VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ByteVector128Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4719,7 +4719,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueByte128VectorTests(IntFunction fm) { + static void allTrueByteVector128Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4730,7 +4730,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Byte128VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ByteVector128Tests::allTrue); } static byte SUADDReduce(byte[] a, int idx) { @@ -4752,7 +4752,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingUnaryOpProvider") - static void SUADDReduceByte128VectorTests(IntFunction fa) { + static void SUADDReduceByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4768,7 +4768,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte128VectorTests::SUADDReduce, Byte128VectorTests::SUADDReduceAll); + ByteVector128Tests::SUADDReduce, ByteVector128Tests::SUADDReduceAll); } @Test(dataProvider = "byteSaturatingUnaryOpProvider") @@ -4813,7 +4813,7 @@ public class Byte128VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "byteSaturatingUnaryOpMaskProvider") - static void SUADDReduceByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4831,11 +4831,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::SUADDReduceMasked, Byte128VectorTests::SUADDReduceAllMasked); + ByteVector128Tests::SUADDReduceMasked, ByteVector128Tests::SUADDReduceAllMasked); } @Test(dataProvider = "byteBinaryOpProvider") - static void withByte128VectorTests(IntFunction fa, IntFunction fb) { + static void withByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -4858,7 +4858,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_DEFAULTByte128VectorTests(IntFunction fa) { + static void IS_DEFAULTByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4875,7 +4875,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_DEFAULTMaskedByte128VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4899,7 +4899,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_NEGATIVEByte128VectorTests(IntFunction fa) { + static void IS_NEGATIVEByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4916,7 +4916,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_NEGATIVEMaskedByte128VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4936,7 +4936,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte128VectorTests(IntFunction fa, IntFunction fb) { + static void LTByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4955,7 +4955,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByte128VectorTests(IntFunction fa, IntFunction fb) { + static void ltByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4974,7 +4974,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4997,7 +4997,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GTByte128VectorTests(IntFunction fa, IntFunction fb) { + static void GTByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5016,7 +5016,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GTByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5039,7 +5039,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte128VectorTests(IntFunction fa, IntFunction fb) { + static void EQByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5058,7 +5058,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByte128VectorTests(IntFunction fa, IntFunction fb) { + static void eqByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5077,7 +5077,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5100,7 +5100,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void NEByte128VectorTests(IntFunction fa, IntFunction fb) { + static void NEByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5119,7 +5119,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void NEByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5142,7 +5142,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LEByte128VectorTests(IntFunction fa, IntFunction fb) { + static void LEByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5161,7 +5161,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LEByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5184,7 +5184,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GEByte128VectorTests(IntFunction fa, IntFunction fb) { + static void GEByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5203,7 +5203,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GEByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5226,7 +5226,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULTByte128VectorTests(IntFunction fa, IntFunction fb) { + static void ULTByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5245,7 +5245,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULTByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5268,7 +5268,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGTByte128VectorTests(IntFunction fa, IntFunction fb) { + static void UGTByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5287,7 +5287,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGTByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5310,7 +5310,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULEByte128VectorTests(IntFunction fa, IntFunction fb) { + static void ULEByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5329,7 +5329,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULEByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5352,7 +5352,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGEByte128VectorTests(IntFunction fa, IntFunction fb) { + static void UGEByteVector128Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5371,7 +5371,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGEByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5394,7 +5394,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5410,7 +5410,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5430,7 +5430,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5446,7 +5446,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTByteVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5466,7 +5466,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5482,7 +5482,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5502,7 +5502,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5518,7 +5518,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQByteVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5542,7 +5542,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByte128VectorTests(IntFunction fa, IntFunction fb, + static void blendByteVector128Tests(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5558,11 +5558,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte128VectorTests::blend); + assertArraysEquals(r, a, b, mask, ByteVector128Tests::blend); } @Test(dataProvider = "byteUnaryOpShuffleProvider") - static void RearrangeByte128VectorTests(IntFunction fa, + static void RearrangeByteVector128Tests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5579,7 +5579,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpShuffleMaskProvider") - static void RearrangeByte128VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeByteVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -5597,7 +5597,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void compressByte128VectorTests(IntFunction fa, + static void compressByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5615,7 +5615,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void expandByte128VectorTests(IntFunction fa, + static void expandByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5633,7 +5633,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void getByte128VectorTests(IntFunction fa) { + static void getByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5789,7 +5789,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastByte128VectorTests(IntFunction fa) { + static void BroadcastByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5803,7 +5803,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZeroByte128VectorTests(IntFunction fa) { + static void ZeroByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5828,7 +5828,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void sliceUnaryByte128VectorTests(IntFunction fa) { + static void sliceUnaryByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5839,7 +5839,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Byte128VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ByteVector128Tests::sliceUnary); } static byte[] sliceBinary(byte[] a, byte[] b, int origin, int idx) { @@ -5856,7 +5856,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void sliceBinaryByte128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryByteVector128TestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5869,7 +5869,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Byte128VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ByteVector128Tests::sliceBinary); } static byte[] slice(byte[] a, byte[] b, int origin, boolean[] mask, int idx) { @@ -5886,7 +5886,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void sliceByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5903,7 +5903,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Byte128VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ByteVector128Tests::slice); } static byte[] unsliceUnary(byte[] a, int origin, int idx) { @@ -5920,7 +5920,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void unsliceUnaryByte128VectorTests(IntFunction fa) { + static void unsliceUnaryByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5931,7 +5931,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Byte128VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ByteVector128Tests::unsliceUnary); } static byte[] unsliceBinary(byte[] a, byte[] b, int origin, int part, int idx) { @@ -5957,7 +5957,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void unsliceBinaryByte128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryByteVector128TestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5971,7 +5971,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Byte128VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ByteVector128Tests::unsliceBinary); } static byte[] unslice(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx) { @@ -6011,7 +6011,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void unsliceByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6028,7 +6028,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Byte128VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ByteVector128Tests::unslice); } static byte BITWISE_BLEND(byte a, byte b, byte c) { @@ -6040,7 +6040,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6055,11 +6055,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Byte128VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ByteVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6072,11 +6072,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Byte128VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ByteVector128Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6094,11 +6094,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Byte128VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ByteVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6109,11 +6109,11 @@ public class Byte128VectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Byte128VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ByteVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6124,11 +6124,11 @@ public class Byte128VectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Byte128VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6139,11 +6139,11 @@ public class Byte128VectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Byte128VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ByteVector128Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6154,11 +6154,11 @@ public class Byte128VectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Byte128VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVector128Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6173,11 +6173,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Byte128VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ByteVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte128VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector128TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6192,11 +6192,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Byte128VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ByteVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6207,11 +6207,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Byte128VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6222,11 +6222,11 @@ public class Byte128VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Byte128VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVector128Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte128VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector128TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6240,7 +6240,7 @@ public class Byte128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Byte128VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ByteVector128Tests::BITWISE_BLEND); } static byte NEG(byte a) { @@ -6252,7 +6252,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NEGByte128VectorTests(IntFunction fa) { + static void NEGByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6263,11 +6263,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::NEG); + assertArraysEquals(r, a, ByteVector128Tests::NEG); } @Test(dataProvider = "byteUnaryOpProvider") - static void negByte128VectorTests(IntFunction fa) { + static void negByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6278,11 +6278,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::neg); + assertArraysEquals(r, a, ByteVector128Tests::neg); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NEGMaskedByte128VectorTests(IntFunction fa, + static void NEGMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6296,7 +6296,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::NEG); + assertArraysEquals(r, a, mask, ByteVector128Tests::NEG); } static byte ABS(byte a) { @@ -6308,7 +6308,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ABSByte128VectorTests(IntFunction fa) { + static void ABSByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6319,11 +6319,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::ABS); + assertArraysEquals(r, a, ByteVector128Tests::ABS); } @Test(dataProvider = "byteUnaryOpProvider") - static void absByte128VectorTests(IntFunction fa) { + static void absByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6334,11 +6334,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::abs); + assertArraysEquals(r, a, ByteVector128Tests::abs); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ABSMaskedByte128VectorTests(IntFunction fa, + static void ABSMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6352,7 +6352,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::ABS); + assertArraysEquals(r, a, mask, ByteVector128Tests::ABS); } static byte NOT(byte a) { @@ -6364,7 +6364,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NOTByte128VectorTests(IntFunction fa) { + static void NOTByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6375,11 +6375,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::NOT); + assertArraysEquals(r, a, ByteVector128Tests::NOT); } @Test(dataProvider = "byteUnaryOpProvider") - static void notByte128VectorTests(IntFunction fa) { + static void notByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6390,11 +6390,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::not); + assertArraysEquals(r, a, ByteVector128Tests::not); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NOTMaskedByte128VectorTests(IntFunction fa, + static void NOTMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6408,7 +6408,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::NOT); + assertArraysEquals(r, a, mask, ByteVector128Tests::NOT); } static byte ZOMO(byte a) { @@ -6416,7 +6416,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZOMOByte128VectorTests(IntFunction fa) { + static void ZOMOByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6427,11 +6427,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::ZOMO); + assertArraysEquals(r, a, ByteVector128Tests::ZOMO); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ZOMOMaskedByte128VectorTests(IntFunction fa, + static void ZOMOMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6445,7 +6445,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::ZOMO); + assertArraysEquals(r, a, mask, ByteVector128Tests::ZOMO); } static byte BIT_COUNT(byte a) { @@ -6453,7 +6453,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BIT_COUNTByte128VectorTests(IntFunction fa) { + static void BIT_COUNTByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6464,11 +6464,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::BIT_COUNT); + assertArraysEquals(r, a, ByteVector128Tests::BIT_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void BIT_COUNTMaskedByte128VectorTests(IntFunction fa, + static void BIT_COUNTMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6482,7 +6482,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ByteVector128Tests::BIT_COUNT); } static byte TRAILING_ZEROS_COUNT(byte a) { @@ -6490,7 +6490,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void TRAILING_ZEROS_COUNTByte128VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6501,11 +6501,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVector128Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedByte128VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6519,7 +6519,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVector128Tests::TRAILING_ZEROS_COUNT); } static byte LEADING_ZEROS_COUNT(byte a) { @@ -6527,7 +6527,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LEADING_ZEROS_COUNTByte128VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6538,11 +6538,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVector128Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedByte128VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6556,7 +6556,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVector128Tests::LEADING_ZEROS_COUNT); } static byte REVERSE(byte a) { @@ -6564,7 +6564,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSEByte128VectorTests(IntFunction fa) { + static void REVERSEByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6575,11 +6575,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::REVERSE); + assertArraysEquals(r, a, ByteVector128Tests::REVERSE); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSEMaskedByte128VectorTests(IntFunction fa, + static void REVERSEMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6593,7 +6593,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::REVERSE); + assertArraysEquals(r, a, mask, ByteVector128Tests::REVERSE); } static byte REVERSE_BYTES(byte a) { @@ -6601,7 +6601,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSE_BYTESByte128VectorTests(IntFunction fa) { + static void REVERSE_BYTESByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6612,11 +6612,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ByteVector128Tests::REVERSE_BYTES); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedByte128VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedByteVector128Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6630,7 +6630,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte128VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ByteVector128Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6638,7 +6638,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandByte128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandByteVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6651,7 +6651,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::band); + assertArraysEquals(r, a, b, ByteVector128Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6659,7 +6659,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorByte128VectorTests(IntFunction fa, IntFunction fb) { + static void maskorByteVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6672,7 +6672,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::bor); + assertArraysEquals(r, a, b, ByteVector128Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6680,7 +6680,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorByte128VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorByteVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6693,7 +6693,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::bxor); + assertArraysEquals(r, a, b, ByteVector128Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6701,7 +6701,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotByte128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotByteVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6714,7 +6714,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::bandNot); + assertArraysEquals(r, a, b, ByteVector128Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6722,7 +6722,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqByte128VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqByteVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6735,7 +6735,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte128VectorTests::beq); + assertArraysEquals(r, a, b, ByteVector128Tests::beq); } static boolean unot(boolean a) { @@ -6743,7 +6743,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotByte128VectorTests(IntFunction fa) { + static void masknotByteVector128Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6754,7 +6754,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte128VectorTests::unot); + assertArraysEquals(r, a, ByteVector128Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6771,7 +6771,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongByte128VectorTests(IntFunction fa) { + static void maskFromToLongByteVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6785,7 +6785,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByte128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltByteVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6801,7 +6801,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByte128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqByteVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6817,7 +6817,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toIntArrayByte128VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayByteVector128TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6828,7 +6828,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toLongArrayByte128VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayByteVector128TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6839,7 +6839,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toDoubleArrayByte128VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayByteVector128TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6850,7 +6850,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toStringByte128VectorTestsSmokeTest(IntFunction fa) { + static void toStringByteVector128TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6863,7 +6863,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void hashCodeByte128VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeByteVector128TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6877,7 +6877,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void reinterpretAsBytesByte128VectorTestsSmokeTest(IntFunction fa) { + static void reinterpretAsBytesByteVector128TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6907,7 +6907,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceLongByte128VectorTests(IntFunction fa) { + static void ADDReduceLongByteVector128Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6923,7 +6923,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Byte128VectorTests::ADDReduceLong, Byte128VectorTests::ADDReduceAllLong); + ByteVector128Tests::ADDReduceLong, ByteVector128Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(byte[] a, int idx, boolean[] mask) { @@ -6946,7 +6946,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceLongByte128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongByteVector128TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6964,11 +6964,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Byte128VectorTests::ADDReduceLongMasked, Byte128VectorTests::ADDReduceAllLongMasked); + ByteVector128Tests::ADDReduceLongMasked, ByteVector128Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastLongByte128VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongByteVector128TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6979,7 +6979,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByte128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendByteVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6993,12 +6993,12 @@ public class Byte128VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte128VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector128Tests::blend); } @Test(dataProvider = "byteUnaryOpSelectFromProvider") - static void SelectFromByte128VectorTests(IntFunction fa, + static void SelectFromByteVector128Tests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); byte[] order = fs.apply(a.length, SPECIES.length()); @@ -7014,7 +7014,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorByte128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorByteVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] idx = fc.apply(SPECIES.length()); @@ -7032,7 +7032,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpSelectFromMaskProvider") - static void SelectFromByte128VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromByteVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -7051,7 +7051,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousByte128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousByteVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7067,7 +7067,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringByte128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringByteVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7081,7 +7081,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsByte128VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsByteVector128TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7095,7 +7095,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsByte128VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsByteVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7111,7 +7111,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeByte128VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeByteVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7133,7 +7133,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountByte128VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountByteVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7144,7 +7144,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte128VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ByteVector128Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7158,7 +7158,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueByte128VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueByteVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7169,7 +7169,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte128VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ByteVector128Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7183,7 +7183,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueByte128VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueByteVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7194,11 +7194,11 @@ public class Byte128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte128VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ByteVector128Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressByte128VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressByteVector128TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7226,7 +7226,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeByte128VectorTestsSmokeTest(int offset) { + static void indexInRangeByteVector128TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7240,7 +7240,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongByte128VectorTestsSmokeTest(int offset) { + static void indexInRangeLongByteVector128TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7267,14 +7267,14 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundByte128VectorTestsSmokeTest(int length) { + static void loopBoundByteVector128TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongByte128VectorTestsSmokeTest(int _length) { + static void loopBoundLongByteVector128TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7282,21 +7282,21 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeByte128VectorTestsSmokeTest() { + static void ElementSizeByteVector128TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Byte.SIZE); } @Test - static void VectorShapeByte128VectorTestsSmokeTest() { + static void VectorShapeByteVector128TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_128_BIT)); } @Test - static void ShapeWithLanesByte128VectorTestsSmokeTest() { + static void ShapeWithLanesByteVector128TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(byte.class); @@ -7304,32 +7304,32 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeByte128VectorTestsSmokeTest() { + static void ElementTypeByteVector128TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementType() == byte.class); } @Test - static void SpeciesElementSizeByte128VectorTestsSmokeTest() { + static void SpeciesElementSizeByteVector128TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementSize() == Byte.SIZE); } @Test - static void VectorTypeByte128VectorTestsSmokeTest() { + static void VectorTypeByteVector128TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesByte128VectorTestsSmokeTest() { + static void WithLanesByteVector128TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(byte.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeByte128VectorTestsSmokeTest() { + static void WithShapeByteVector128TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7337,7 +7337,7 @@ public class Byte128VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueByte128VectorTestsSmokeTest() { + static void MaskAllTrueByteVector128TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Byte256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ByteVector256LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Byte256VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ByteVector256LoadStoreTests.java index 1b1f6c0ed36..f57bc3e65b9 100644 --- a/test/jdk/jdk/incubator/vector/Byte256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVector256LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Byte256VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation ByteVector256LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Byte256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ByteVector256LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_256; diff --git a/test/jdk/jdk/incubator/vector/Byte256VectorTests.java b/test/jdk/jdk/incubator/vector/ByteVector256Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Byte256VectorTests.java rename to test/jdk/jdk/incubator/vector/ByteVector256Tests.java index ec8958e0605..1173a4b7783 100644 --- a/test/jdk/jdk/incubator/vector/Byte256VectorTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVector256Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Byte256VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ByteVector256Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Byte256VectorTests extends AbstractVectorTest { +public class ByteVector256Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_256; @@ -1705,7 +1705,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByte256VectorTests(IntFunction fa, IntFunction fb) { + static void ADDByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1718,7 +1718,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::ADD); + assertArraysEquals(r, a, b, ByteVector256Tests::ADD); } static byte add(byte a, byte b) { @@ -1726,7 +1726,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void addByte256VectorTests(IntFunction fa, IntFunction fb) { + static void addByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1737,11 +1737,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte256VectorTests::add); + assertArraysEquals(r, a, b, ByteVector256Tests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1757,11 +1757,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::ADD); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1775,7 +1775,7 @@ public class Byte256VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::add); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::add); } static byte SUB(byte a, byte b) { @@ -1783,7 +1783,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void SUBByte256VectorTests(IntFunction fa, IntFunction fb) { + static void SUBByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1796,7 +1796,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::SUB); + assertArraysEquals(r, a, b, ByteVector256Tests::SUB); } static byte sub(byte a, byte b) { @@ -1804,7 +1804,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void subByte256VectorTests(IntFunction fa, IntFunction fb) { + static void subByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1815,11 +1815,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte256VectorTests::sub); + assertArraysEquals(r, a, b, ByteVector256Tests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void SUBByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1835,11 +1835,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::SUB); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::SUB); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1853,7 +1853,7 @@ public class Byte256VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::sub); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::sub); } static byte MUL(byte a, byte b) { @@ -1861,7 +1861,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MULByte256VectorTests(IntFunction fa, IntFunction fb) { + static void MULByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1874,7 +1874,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::MUL); + assertArraysEquals(r, a, b, ByteVector256Tests::MUL); } static byte mul(byte a, byte b) { @@ -1882,7 +1882,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByte256VectorTests(IntFunction fa, IntFunction fb) { + static void mulByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1893,11 +1893,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte256VectorTests::mul); + assertArraysEquals(r, a, b, ByteVector256Tests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void MULByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1913,11 +1913,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::MUL); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::MUL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1931,7 +1931,7 @@ public class Byte256VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::mul); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::mul); } static byte DIV(byte a, byte b) { @@ -1939,7 +1939,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void DIVByte256VectorTests(IntFunction fa, IntFunction fb) { + static void DIVByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1954,7 +1954,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::DIV); + assertArraysEquals(r, a, b, ByteVector256Tests::DIV); } static byte div(byte a, byte b) { @@ -1962,7 +1962,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void divByte256VectorTests(IntFunction fa, IntFunction fb) { + static void divByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1977,11 +1977,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::div); + assertArraysEquals(r, a, b, ByteVector256Tests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void DIVByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1999,11 +1999,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::DIV); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::DIV); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2021,7 +2021,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::div); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::div); } static byte FIRST_NONZERO(byte a, byte b) { @@ -2029,7 +2029,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void FIRST_NONZEROByte256VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2042,11 +2042,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ByteVector256Tests::FIRST_NONZERO); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void FIRST_NONZEROByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2062,7 +2062,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::FIRST_NONZERO); } static byte AND(byte a, byte b) { @@ -2070,7 +2070,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByte256VectorTests(IntFunction fa, IntFunction fb) { + static void ANDByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2083,7 +2083,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::AND); + assertArraysEquals(r, a, b, ByteVector256Tests::AND); } static byte and(byte a, byte b) { @@ -2091,7 +2091,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void andByte256VectorTests(IntFunction fa, IntFunction fb) { + static void andByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2102,11 +2102,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte256VectorTests::and); + assertArraysEquals(r, a, b, ByteVector256Tests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2122,7 +2122,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::AND); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::AND); } static byte AND_NOT(byte a, byte b) { @@ -2130,7 +2130,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void AND_NOTByte256VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2143,11 +2143,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::AND_NOT); + assertArraysEquals(r, a, b, ByteVector256Tests::AND_NOT); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void AND_NOTByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2163,7 +2163,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::AND_NOT); } static byte OR(byte a, byte b) { @@ -2171,7 +2171,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte256VectorTests(IntFunction fa, IntFunction fb) { + static void ORByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2184,7 +2184,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::OR); + assertArraysEquals(r, a, b, ByteVector256Tests::OR); } static byte or(byte a, byte b) { @@ -2192,7 +2192,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void orByte256VectorTests(IntFunction fa, IntFunction fb) { + static void orByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2203,11 +2203,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte256VectorTests::or); + assertArraysEquals(r, a, b, ByteVector256Tests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2223,7 +2223,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::OR); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::OR); } static byte XOR(byte a, byte b) { @@ -2231,7 +2231,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void XORByte256VectorTests(IntFunction fa, IntFunction fb) { + static void XORByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2244,11 +2244,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::XOR); + assertArraysEquals(r, a, b, ByteVector256Tests::XOR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void XORByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2264,11 +2264,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::XOR); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::XOR); } @Test(dataProvider = "byteBinaryOpProvider") - static void addByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2278,11 +2278,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2295,11 +2295,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector256Tests::add); } @Test(dataProvider = "byteBinaryOpProvider") - static void subByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2309,11 +2309,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2326,11 +2326,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector256Tests::sub); } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2340,11 +2340,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2357,11 +2357,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector256Tests::mul); } @Test(dataProvider = "byteBinaryOpProvider") - static void divByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2373,11 +2373,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2392,11 +2392,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector256Tests::div); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2406,11 +2406,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void orByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2420,11 +2420,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::or); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2437,11 +2437,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector256Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2451,11 +2451,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void andByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2465,11 +2465,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::and); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2482,11 +2482,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector256Tests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2496,11 +2496,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Byte256VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ByteVector256Tests::OR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2513,11 +2513,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte256VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector256Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByte256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDByteVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2527,11 +2527,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Byte256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ByteVector256Tests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByte256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDByteVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2544,7 +2544,7 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector256Tests::ADD); } static byte LSHL(byte a, byte b) { @@ -2552,7 +2552,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByte256VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2565,11 +2565,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::LSHL); + assertArraysEquals(r, a, b, ByteVector256Tests::LSHL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2585,7 +2585,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::LSHL); } static byte ASHR(byte a, byte b) { @@ -2593,7 +2593,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByte256VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2606,11 +2606,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::ASHR); + assertArraysEquals(r, a, b, ByteVector256Tests::ASHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2626,7 +2626,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::ASHR); } static byte LSHR(byte a, byte b) { @@ -2634,7 +2634,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByte256VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2647,11 +2647,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::LSHR); + assertArraysEquals(r, a, b, ByteVector256Tests::LSHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2667,7 +2667,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::LSHR); } static byte LSHL_unary(byte a, byte b) { @@ -2675,7 +2675,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByte256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLByteVector256TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2687,11 +2687,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte256VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ByteVector256Tests::LSHL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByte256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2706,7 +2706,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte256VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector256Tests::LSHL_unary); } static byte LSHR_unary(byte a, byte b) { @@ -2714,7 +2714,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByte256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRByteVector256TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2726,11 +2726,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte256VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ByteVector256Tests::LSHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByte256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2745,7 +2745,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte256VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector256Tests::LSHR_unary); } static byte ASHR_unary(byte a, byte b) { @@ -2753,7 +2753,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByte256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRByteVector256TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2765,11 +2765,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte256VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ByteVector256Tests::ASHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByte256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2784,7 +2784,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte256VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector256Tests::ASHR_unary); } static byte ROR(byte a, byte b) { @@ -2792,7 +2792,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByte256VectorTests(IntFunction fa, IntFunction fb) { + static void RORByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2805,11 +2805,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::ROR); + assertArraysEquals(r, a, b, ByteVector256Tests::ROR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2825,7 +2825,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::ROR); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::ROR); } static byte ROL(byte a, byte b) { @@ -2833,7 +2833,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByte256VectorTests(IntFunction fa, IntFunction fb) { + static void ROLByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2846,11 +2846,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::ROL); + assertArraysEquals(r, a, b, ByteVector256Tests::ROL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2866,7 +2866,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::ROL); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::ROL); } static byte ROR_unary(byte a, byte b) { @@ -2874,7 +2874,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByte256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORByteVector256TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2886,11 +2886,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte256VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ByteVector256Tests::ROR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByte256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORByteVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2905,7 +2905,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte256VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector256Tests::ROR_unary); } static byte ROL_unary(byte a, byte b) { @@ -2913,7 +2913,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByte256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLByteVector256TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2925,11 +2925,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte256VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ByteVector256Tests::ROL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByte256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLByteVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2944,14 +2944,14 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte256VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector256Tests::ROL_unary); } static byte LSHR_binary_const(byte a) { return (byte)(((a & 0xFF) >>> CONST_SHIFT)); } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHRByte256VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRByteVector256TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2962,11 +2962,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte256VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ByteVector256Tests::LSHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHRByte256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRByteVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2980,7 +2980,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte256VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector256Tests::LSHR_binary_const); } static byte LSHL_binary_const(byte a) { @@ -2988,7 +2988,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHLByte256VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLByteVector256TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2999,11 +2999,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte256VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ByteVector256Tests::LSHL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHLByte256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLByteVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3017,7 +3017,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte256VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector256Tests::LSHL_binary_const); } static byte ASHR_binary_const(byte a) { @@ -3025,7 +3025,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ASHRByte256VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRByteVector256TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3036,11 +3036,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte256VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ByteVector256Tests::ASHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ASHRByte256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRByteVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3054,7 +3054,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte256VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector256Tests::ASHR_binary_const); } static byte ROR_binary_const(byte a) { @@ -3062,7 +3062,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void RORByte256VectorTestsScalarShiftConst(IntFunction fa) { + static void RORByteVector256TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3073,11 +3073,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte256VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ByteVector256Tests::ROR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void RORByte256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORByteVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3091,7 +3091,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte256VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector256Tests::ROR_binary_const); } static byte ROL_binary_const(byte a) { @@ -3099,7 +3099,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ROLByte256VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLByteVector256TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3110,11 +3110,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte256VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ByteVector256Tests::ROL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ROLByte256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLByteVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3128,14 +3128,14 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte256VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector256Tests::ROL_binary_const); } static ByteVector bv_MIN = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MINByte256VectorTestsWithMemOp(IntFunction fa) { + static void MINByteVector256TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3146,13 +3146,13 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte256VectorTests::MIN); + assertArraysEquals(r, a, (byte)10, ByteVector256Tests::MIN); } static ByteVector bv_min = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void minByte256VectorTestsWithMemOp(IntFunction fa) { + static void minByteVector256TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3163,13 +3163,13 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte256VectorTests::min); + assertArraysEquals(r, a, (byte)10, ByteVector256Tests::min); } static ByteVector bv_MIN_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINByte256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINByteVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3182,13 +3182,13 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, Byte256VectorTests::MIN); + assertArraysEquals(r, a, (byte)10, mask, ByteVector256Tests::MIN); } static ByteVector bv_MAX = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MAXByte256VectorTestsWithMemOp(IntFunction fa) { + static void MAXByteVector256TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3199,13 +3199,13 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte256VectorTests::MAX); + assertArraysEquals(r, a, (byte)10, ByteVector256Tests::MAX); } static ByteVector bv_max = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void maxByte256VectorTestsWithMemOp(IntFunction fa) { + static void maxByteVector256TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3216,13 +3216,13 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte256VectorTests::max); + assertArraysEquals(r, a, (byte)10, ByteVector256Tests::max); } static ByteVector bv_MAX_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXByte256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXByteVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3235,7 +3235,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, Byte256VectorTests::MAX); + assertArraysEquals(r, a, (byte)10, mask, ByteVector256Tests::MAX); } static byte MIN(byte a, byte b) { @@ -3243,7 +3243,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByte256VectorTests(IntFunction fa, IntFunction fb) { + static void MINByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3256,7 +3256,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::MIN); + assertArraysEquals(r, a, b, ByteVector256Tests::MIN); } static byte min(byte a, byte b) { @@ -3264,7 +3264,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void minByte256VectorTests(IntFunction fa, IntFunction fb) { + static void minByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3275,7 +3275,7 @@ public class Byte256VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte256VectorTests::min); + assertArraysEquals(r, a, b, ByteVector256Tests::min); } static byte MAX(byte a, byte b) { @@ -3283,7 +3283,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByte256VectorTests(IntFunction fa, IntFunction fb) { + static void MAXByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3296,7 +3296,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::MAX); + assertArraysEquals(r, a, b, ByteVector256Tests::MAX); } static byte max(byte a, byte b) { @@ -3304,7 +3304,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByte256VectorTests(IntFunction fa, IntFunction fb) { + static void maxByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3315,7 +3315,7 @@ public class Byte256VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte256VectorTests::max); + assertArraysEquals(r, a, b, ByteVector256Tests::max); } static byte UMIN(byte a, byte b) { @@ -3323,7 +3323,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMINByte256VectorTests(IntFunction fa, IntFunction fb) { + static void UMINByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3336,11 +3336,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::UMIN); + assertArraysEquals(r, a, b, ByteVector256Tests::UMIN); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMINByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3356,7 +3356,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::UMIN); } static byte UMAX(byte a, byte b) { @@ -3364,7 +3364,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMAXByte256VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3377,11 +3377,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::UMAX); + assertArraysEquals(r, a, b, ByteVector256Tests::UMAX); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMAXByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3397,7 +3397,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::UMAX); } static byte SADD(byte a, byte b) { @@ -3405,7 +3405,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SADDByte256VectorTests(IntFunction fa, IntFunction fb) { + static void SADDByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3418,11 +3418,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::SADD); + assertArraysEquals(r, a, b, ByteVector256Tests::SADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SADDByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3438,7 +3438,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::SADD); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::SADD); } static byte SSUB(byte a, byte b) { @@ -3446,7 +3446,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SSUBByte256VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3459,11 +3459,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::SSUB); + assertArraysEquals(r, a, b, ByteVector256Tests::SSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SSUBByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3479,7 +3479,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::SSUB); } static byte SUADD(byte a, byte b) { @@ -3487,7 +3487,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUADDByte256VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3500,11 +3500,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::SUADD); + assertArraysEquals(r, a, b, ByteVector256Tests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUADDByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3520,7 +3520,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::SUADD); } static byte SUSUB(byte a, byte b) { @@ -3528,7 +3528,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUSUBByte256VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3541,11 +3541,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::SUSUB); + assertArraysEquals(r, a, b, ByteVector256Tests::SUSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUSUBByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3561,11 +3561,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::SUSUB); } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3575,11 +3575,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::MIN); } @Test(dataProvider = "byteBinaryOpProvider") - static void minByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3589,11 +3589,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::min); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::min); } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3603,11 +3603,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::MAX); } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3617,10 +3617,10 @@ public class Byte256VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::max); + assertBroadcastArraysEquals(r, a, b, ByteVector256Tests::max); } @Test(dataProvider = "byteSaturatingBinaryOpAssocProvider") - static void SUADDAssocByte256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocByteVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -3637,11 +3637,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Byte256VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ByteVector256Tests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3662,7 +3662,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Byte256VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ByteVector256Tests::SUADD); } static byte ANDReduce(byte[] a, int idx) { @@ -3684,7 +3684,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ANDReduceByte256VectorTests(IntFunction fa) { + static void ANDReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3700,7 +3700,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::ANDReduce, Byte256VectorTests::ANDReduceAll); + ByteVector256Tests::ANDReduce, ByteVector256Tests::ANDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3746,7 +3746,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ANDReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3764,7 +3764,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::ANDReduceMasked, Byte256VectorTests::ANDReduceAllMasked); + ByteVector256Tests::ANDReduceMasked, ByteVector256Tests::ANDReduceAllMasked); } static byte ORReduce(byte[] a, int idx) { @@ -3786,7 +3786,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ORReduceByte256VectorTests(IntFunction fa) { + static void ORReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3802,7 +3802,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::ORReduce, Byte256VectorTests::ORReduceAll); + ByteVector256Tests::ORReduce, ByteVector256Tests::ORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3848,7 +3848,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ORReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3866,7 +3866,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::ORReduceMasked, Byte256VectorTests::ORReduceAllMasked); + ByteVector256Tests::ORReduceMasked, ByteVector256Tests::ORReduceAllMasked); } static byte XORReduce(byte[] a, int idx) { @@ -3888,7 +3888,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void XORReduceByte256VectorTests(IntFunction fa) { + static void XORReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3904,7 +3904,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::XORReduce, Byte256VectorTests::XORReduceAll); + ByteVector256Tests::XORReduce, ByteVector256Tests::XORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3950,7 +3950,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void XORReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3968,7 +3968,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::XORReduceMasked, Byte256VectorTests::XORReduceAllMasked); + ByteVector256Tests::XORReduceMasked, ByteVector256Tests::XORReduceAllMasked); } static byte ADDReduce(byte[] a, int idx) { @@ -3990,7 +3990,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceByte256VectorTests(IntFunction fa) { + static void ADDReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4006,7 +4006,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::ADDReduce, Byte256VectorTests::ADDReduceAll); + ByteVector256Tests::ADDReduce, ByteVector256Tests::ADDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4052,7 +4052,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4070,7 +4070,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::ADDReduceMasked, Byte256VectorTests::ADDReduceAllMasked); + ByteVector256Tests::ADDReduceMasked, ByteVector256Tests::ADDReduceAllMasked); } static byte MULReduce(byte[] a, int idx) { @@ -4092,7 +4092,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MULReduceByte256VectorTests(IntFunction fa) { + static void MULReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4108,7 +4108,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::MULReduce, Byte256VectorTests::MULReduceAll); + ByteVector256Tests::MULReduce, ByteVector256Tests::MULReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4154,7 +4154,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MULReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4172,7 +4172,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::MULReduceMasked, Byte256VectorTests::MULReduceAllMasked); + ByteVector256Tests::MULReduceMasked, ByteVector256Tests::MULReduceAllMasked); } static byte MINReduce(byte[] a, int idx) { @@ -4194,7 +4194,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MINReduceByte256VectorTests(IntFunction fa) { + static void MINReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4210,7 +4210,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::MINReduce, Byte256VectorTests::MINReduceAll); + ByteVector256Tests::MINReduce, ByteVector256Tests::MINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4256,7 +4256,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4274,7 +4274,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::MINReduceMasked, Byte256VectorTests::MINReduceAllMasked); + ByteVector256Tests::MINReduceMasked, ByteVector256Tests::MINReduceAllMasked); } static byte MAXReduce(byte[] a, int idx) { @@ -4296,7 +4296,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MAXReduceByte256VectorTests(IntFunction fa) { + static void MAXReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4312,7 +4312,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::MAXReduce, Byte256VectorTests::MAXReduceAll); + ByteVector256Tests::MAXReduce, ByteVector256Tests::MAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4358,7 +4358,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4376,7 +4376,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::MAXReduceMasked, Byte256VectorTests::MAXReduceAllMasked); + ByteVector256Tests::MAXReduceMasked, ByteVector256Tests::MAXReduceAllMasked); } static byte UMINReduce(byte[] a, int idx) { @@ -4398,7 +4398,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMINReduceByte256VectorTests(IntFunction fa) { + static void UMINReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4414,7 +4414,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::UMINReduce, Byte256VectorTests::UMINReduceAll); + ByteVector256Tests::UMINReduce, ByteVector256Tests::UMINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4460,7 +4460,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMINReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4478,7 +4478,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::UMINReduceMasked, Byte256VectorTests::UMINReduceAllMasked); + ByteVector256Tests::UMINReduceMasked, ByteVector256Tests::UMINReduceAllMasked); } static byte UMAXReduce(byte[] a, int idx) { @@ -4500,7 +4500,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMAXReduceByte256VectorTests(IntFunction fa) { + static void UMAXReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4516,7 +4516,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::UMAXReduce, Byte256VectorTests::UMAXReduceAll); + ByteVector256Tests::UMAXReduce, ByteVector256Tests::UMAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4562,7 +4562,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMAXReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4580,7 +4580,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::UMAXReduceMasked, Byte256VectorTests::UMAXReduceAllMasked); + ByteVector256Tests::UMAXReduceMasked, ByteVector256Tests::UMAXReduceAllMasked); } static byte FIRST_NONZEROReduce(byte[] a, int idx) { @@ -4602,7 +4602,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void FIRST_NONZEROReduceByte256VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4618,7 +4618,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::FIRST_NONZEROReduce, Byte256VectorTests::FIRST_NONZEROReduceAll); + ByteVector256Tests::FIRST_NONZEROReduce, ByteVector256Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4664,7 +4664,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void FIRST_NONZEROReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4682,7 +4682,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::FIRST_NONZEROReduceMasked, Byte256VectorTests::FIRST_NONZEROReduceAllMasked); + ByteVector256Tests::FIRST_NONZEROReduceMasked, ByteVector256Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4695,7 +4695,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueByte256VectorTests(IntFunction fm) { + static void anyTrueByteVector256Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4706,7 +4706,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Byte256VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ByteVector256Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4719,7 +4719,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueByte256VectorTests(IntFunction fm) { + static void allTrueByteVector256Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4730,7 +4730,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Byte256VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ByteVector256Tests::allTrue); } static byte SUADDReduce(byte[] a, int idx) { @@ -4752,7 +4752,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingUnaryOpProvider") - static void SUADDReduceByte256VectorTests(IntFunction fa) { + static void SUADDReduceByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4768,7 +4768,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte256VectorTests::SUADDReduce, Byte256VectorTests::SUADDReduceAll); + ByteVector256Tests::SUADDReduce, ByteVector256Tests::SUADDReduceAll); } @Test(dataProvider = "byteSaturatingUnaryOpProvider") @@ -4813,7 +4813,7 @@ public class Byte256VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "byteSaturatingUnaryOpMaskProvider") - static void SUADDReduceByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4831,11 +4831,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::SUADDReduceMasked, Byte256VectorTests::SUADDReduceAllMasked); + ByteVector256Tests::SUADDReduceMasked, ByteVector256Tests::SUADDReduceAllMasked); } @Test(dataProvider = "byteBinaryOpProvider") - static void withByte256VectorTests(IntFunction fa, IntFunction fb) { + static void withByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -4858,7 +4858,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_DEFAULTByte256VectorTests(IntFunction fa) { + static void IS_DEFAULTByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4875,7 +4875,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_DEFAULTMaskedByte256VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4899,7 +4899,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_NEGATIVEByte256VectorTests(IntFunction fa) { + static void IS_NEGATIVEByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4916,7 +4916,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_NEGATIVEMaskedByte256VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4936,7 +4936,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte256VectorTests(IntFunction fa, IntFunction fb) { + static void LTByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4955,7 +4955,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByte256VectorTests(IntFunction fa, IntFunction fb) { + static void ltByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4974,7 +4974,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4997,7 +4997,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GTByte256VectorTests(IntFunction fa, IntFunction fb) { + static void GTByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5016,7 +5016,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GTByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5039,7 +5039,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte256VectorTests(IntFunction fa, IntFunction fb) { + static void EQByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5058,7 +5058,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByte256VectorTests(IntFunction fa, IntFunction fb) { + static void eqByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5077,7 +5077,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5100,7 +5100,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void NEByte256VectorTests(IntFunction fa, IntFunction fb) { + static void NEByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5119,7 +5119,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void NEByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5142,7 +5142,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LEByte256VectorTests(IntFunction fa, IntFunction fb) { + static void LEByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5161,7 +5161,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LEByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5184,7 +5184,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GEByte256VectorTests(IntFunction fa, IntFunction fb) { + static void GEByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5203,7 +5203,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GEByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5226,7 +5226,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULTByte256VectorTests(IntFunction fa, IntFunction fb) { + static void ULTByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5245,7 +5245,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULTByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5268,7 +5268,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGTByte256VectorTests(IntFunction fa, IntFunction fb) { + static void UGTByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5287,7 +5287,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGTByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5310,7 +5310,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULEByte256VectorTests(IntFunction fa, IntFunction fb) { + static void ULEByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5329,7 +5329,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULEByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5352,7 +5352,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGEByte256VectorTests(IntFunction fa, IntFunction fb) { + static void UGEByteVector256Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5371,7 +5371,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGEByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5394,7 +5394,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5410,7 +5410,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5430,7 +5430,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5446,7 +5446,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTByteVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5466,7 +5466,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5482,7 +5482,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5502,7 +5502,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5518,7 +5518,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQByteVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5542,7 +5542,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByte256VectorTests(IntFunction fa, IntFunction fb, + static void blendByteVector256Tests(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5558,11 +5558,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte256VectorTests::blend); + assertArraysEquals(r, a, b, mask, ByteVector256Tests::blend); } @Test(dataProvider = "byteUnaryOpShuffleProvider") - static void RearrangeByte256VectorTests(IntFunction fa, + static void RearrangeByteVector256Tests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5579,7 +5579,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpShuffleMaskProvider") - static void RearrangeByte256VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeByteVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -5597,7 +5597,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void compressByte256VectorTests(IntFunction fa, + static void compressByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5615,7 +5615,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void expandByte256VectorTests(IntFunction fa, + static void expandByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5633,7 +5633,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void getByte256VectorTests(IntFunction fa) { + static void getByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5789,7 +5789,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastByte256VectorTests(IntFunction fa) { + static void BroadcastByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5803,7 +5803,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZeroByte256VectorTests(IntFunction fa) { + static void ZeroByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5828,7 +5828,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void sliceUnaryByte256VectorTests(IntFunction fa) { + static void sliceUnaryByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5839,7 +5839,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Byte256VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ByteVector256Tests::sliceUnary); } static byte[] sliceBinary(byte[] a, byte[] b, int origin, int idx) { @@ -5856,7 +5856,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void sliceBinaryByte256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryByteVector256TestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5869,7 +5869,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Byte256VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ByteVector256Tests::sliceBinary); } static byte[] slice(byte[] a, byte[] b, int origin, boolean[] mask, int idx) { @@ -5886,7 +5886,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void sliceByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5903,7 +5903,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Byte256VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ByteVector256Tests::slice); } static byte[] unsliceUnary(byte[] a, int origin, int idx) { @@ -5920,7 +5920,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void unsliceUnaryByte256VectorTests(IntFunction fa) { + static void unsliceUnaryByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5931,7 +5931,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Byte256VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ByteVector256Tests::unsliceUnary); } static byte[] unsliceBinary(byte[] a, byte[] b, int origin, int part, int idx) { @@ -5957,7 +5957,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void unsliceBinaryByte256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryByteVector256TestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5971,7 +5971,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Byte256VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ByteVector256Tests::unsliceBinary); } static byte[] unslice(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx) { @@ -6011,7 +6011,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void unsliceByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6028,7 +6028,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Byte256VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ByteVector256Tests::unslice); } static byte BITWISE_BLEND(byte a, byte b, byte c) { @@ -6040,7 +6040,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6055,11 +6055,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Byte256VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ByteVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6072,11 +6072,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Byte256VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ByteVector256Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6094,11 +6094,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Byte256VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ByteVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6109,11 +6109,11 @@ public class Byte256VectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ByteVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6124,11 +6124,11 @@ public class Byte256VectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6139,11 +6139,11 @@ public class Byte256VectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ByteVector256Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6154,11 +6154,11 @@ public class Byte256VectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVector256Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6173,11 +6173,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Byte256VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ByteVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector256TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6192,11 +6192,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Byte256VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ByteVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6207,11 +6207,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6222,11 +6222,11 @@ public class Byte256VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVector256Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector256TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6240,7 +6240,7 @@ public class Byte256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Byte256VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ByteVector256Tests::BITWISE_BLEND); } static byte NEG(byte a) { @@ -6252,7 +6252,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NEGByte256VectorTests(IntFunction fa) { + static void NEGByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6263,11 +6263,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::NEG); + assertArraysEquals(r, a, ByteVector256Tests::NEG); } @Test(dataProvider = "byteUnaryOpProvider") - static void negByte256VectorTests(IntFunction fa) { + static void negByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6278,11 +6278,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::neg); + assertArraysEquals(r, a, ByteVector256Tests::neg); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NEGMaskedByte256VectorTests(IntFunction fa, + static void NEGMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6296,7 +6296,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::NEG); + assertArraysEquals(r, a, mask, ByteVector256Tests::NEG); } static byte ABS(byte a) { @@ -6308,7 +6308,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ABSByte256VectorTests(IntFunction fa) { + static void ABSByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6319,11 +6319,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::ABS); + assertArraysEquals(r, a, ByteVector256Tests::ABS); } @Test(dataProvider = "byteUnaryOpProvider") - static void absByte256VectorTests(IntFunction fa) { + static void absByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6334,11 +6334,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::abs); + assertArraysEquals(r, a, ByteVector256Tests::abs); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ABSMaskedByte256VectorTests(IntFunction fa, + static void ABSMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6352,7 +6352,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::ABS); + assertArraysEquals(r, a, mask, ByteVector256Tests::ABS); } static byte NOT(byte a) { @@ -6364,7 +6364,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NOTByte256VectorTests(IntFunction fa) { + static void NOTByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6375,11 +6375,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::NOT); + assertArraysEquals(r, a, ByteVector256Tests::NOT); } @Test(dataProvider = "byteUnaryOpProvider") - static void notByte256VectorTests(IntFunction fa) { + static void notByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6390,11 +6390,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::not); + assertArraysEquals(r, a, ByteVector256Tests::not); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NOTMaskedByte256VectorTests(IntFunction fa, + static void NOTMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6408,7 +6408,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::NOT); + assertArraysEquals(r, a, mask, ByteVector256Tests::NOT); } static byte ZOMO(byte a) { @@ -6416,7 +6416,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZOMOByte256VectorTests(IntFunction fa) { + static void ZOMOByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6427,11 +6427,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::ZOMO); + assertArraysEquals(r, a, ByteVector256Tests::ZOMO); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ZOMOMaskedByte256VectorTests(IntFunction fa, + static void ZOMOMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6445,7 +6445,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::ZOMO); + assertArraysEquals(r, a, mask, ByteVector256Tests::ZOMO); } static byte BIT_COUNT(byte a) { @@ -6453,7 +6453,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BIT_COUNTByte256VectorTests(IntFunction fa) { + static void BIT_COUNTByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6464,11 +6464,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::BIT_COUNT); + assertArraysEquals(r, a, ByteVector256Tests::BIT_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void BIT_COUNTMaskedByte256VectorTests(IntFunction fa, + static void BIT_COUNTMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6482,7 +6482,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ByteVector256Tests::BIT_COUNT); } static byte TRAILING_ZEROS_COUNT(byte a) { @@ -6490,7 +6490,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void TRAILING_ZEROS_COUNTByte256VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6501,11 +6501,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVector256Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedByte256VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6519,7 +6519,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVector256Tests::TRAILING_ZEROS_COUNT); } static byte LEADING_ZEROS_COUNT(byte a) { @@ -6527,7 +6527,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LEADING_ZEROS_COUNTByte256VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6538,11 +6538,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVector256Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedByte256VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6556,7 +6556,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVector256Tests::LEADING_ZEROS_COUNT); } static byte REVERSE(byte a) { @@ -6564,7 +6564,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSEByte256VectorTests(IntFunction fa) { + static void REVERSEByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6575,11 +6575,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::REVERSE); + assertArraysEquals(r, a, ByteVector256Tests::REVERSE); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSEMaskedByte256VectorTests(IntFunction fa, + static void REVERSEMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6593,7 +6593,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::REVERSE); + assertArraysEquals(r, a, mask, ByteVector256Tests::REVERSE); } static byte REVERSE_BYTES(byte a) { @@ -6601,7 +6601,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSE_BYTESByte256VectorTests(IntFunction fa) { + static void REVERSE_BYTESByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6612,11 +6612,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ByteVector256Tests::REVERSE_BYTES); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedByte256VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedByteVector256Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6630,7 +6630,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte256VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ByteVector256Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6638,7 +6638,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandByte256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandByteVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6651,7 +6651,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::band); + assertArraysEquals(r, a, b, ByteVector256Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6659,7 +6659,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorByte256VectorTests(IntFunction fa, IntFunction fb) { + static void maskorByteVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6672,7 +6672,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::bor); + assertArraysEquals(r, a, b, ByteVector256Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6680,7 +6680,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorByte256VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorByteVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6693,7 +6693,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::bxor); + assertArraysEquals(r, a, b, ByteVector256Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6701,7 +6701,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotByte256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotByteVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6714,7 +6714,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::bandNot); + assertArraysEquals(r, a, b, ByteVector256Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6722,7 +6722,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqByte256VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqByteVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6735,7 +6735,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte256VectorTests::beq); + assertArraysEquals(r, a, b, ByteVector256Tests::beq); } static boolean unot(boolean a) { @@ -6743,7 +6743,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotByte256VectorTests(IntFunction fa) { + static void masknotByteVector256Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6754,7 +6754,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte256VectorTests::unot); + assertArraysEquals(r, a, ByteVector256Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6771,7 +6771,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongByte256VectorTests(IntFunction fa) { + static void maskFromToLongByteVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6785,7 +6785,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByte256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltByteVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6801,7 +6801,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqByteVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6817,7 +6817,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toIntArrayByte256VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayByteVector256TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6828,7 +6828,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toLongArrayByte256VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayByteVector256TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6839,7 +6839,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toDoubleArrayByte256VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayByteVector256TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6850,7 +6850,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toStringByte256VectorTestsSmokeTest(IntFunction fa) { + static void toStringByteVector256TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6863,7 +6863,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void hashCodeByte256VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeByteVector256TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6877,7 +6877,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void reinterpretAsBytesByte256VectorTestsSmokeTest(IntFunction fa) { + static void reinterpretAsBytesByteVector256TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6907,7 +6907,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceLongByte256VectorTests(IntFunction fa) { + static void ADDReduceLongByteVector256Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6923,7 +6923,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Byte256VectorTests::ADDReduceLong, Byte256VectorTests::ADDReduceAllLong); + ByteVector256Tests::ADDReduceLong, ByteVector256Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(byte[] a, int idx, boolean[] mask) { @@ -6946,7 +6946,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceLongByte256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongByteVector256TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6964,11 +6964,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Byte256VectorTests::ADDReduceLongMasked, Byte256VectorTests::ADDReduceAllLongMasked); + ByteVector256Tests::ADDReduceLongMasked, ByteVector256Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastLongByte256VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongByteVector256TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6979,7 +6979,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByte256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendByteVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6993,12 +6993,12 @@ public class Byte256VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte256VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector256Tests::blend); } @Test(dataProvider = "byteUnaryOpSelectFromProvider") - static void SelectFromByte256VectorTests(IntFunction fa, + static void SelectFromByteVector256Tests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); byte[] order = fs.apply(a.length, SPECIES.length()); @@ -7014,7 +7014,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorByte256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorByteVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] idx = fc.apply(SPECIES.length()); @@ -7032,7 +7032,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpSelectFromMaskProvider") - static void SelectFromByte256VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromByteVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -7051,7 +7051,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousByte256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousByteVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7067,7 +7067,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringByte256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringByteVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7081,7 +7081,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsByte256VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsByteVector256TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7095,7 +7095,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsByte256VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsByteVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7111,7 +7111,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeByte256VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeByteVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7133,7 +7133,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountByte256VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountByteVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7144,7 +7144,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte256VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ByteVector256Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7158,7 +7158,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueByte256VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueByteVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7169,7 +7169,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte256VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ByteVector256Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7183,7 +7183,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueByte256VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueByteVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7194,11 +7194,11 @@ public class Byte256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte256VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ByteVector256Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressByte256VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressByteVector256TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7226,7 +7226,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeByte256VectorTestsSmokeTest(int offset) { + static void indexInRangeByteVector256TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7240,7 +7240,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongByte256VectorTestsSmokeTest(int offset) { + static void indexInRangeLongByteVector256TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7267,14 +7267,14 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundByte256VectorTestsSmokeTest(int length) { + static void loopBoundByteVector256TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongByte256VectorTestsSmokeTest(int _length) { + static void loopBoundLongByteVector256TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7282,21 +7282,21 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeByte256VectorTestsSmokeTest() { + static void ElementSizeByteVector256TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Byte.SIZE); } @Test - static void VectorShapeByte256VectorTestsSmokeTest() { + static void VectorShapeByteVector256TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_256_BIT)); } @Test - static void ShapeWithLanesByte256VectorTestsSmokeTest() { + static void ShapeWithLanesByteVector256TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(byte.class); @@ -7304,32 +7304,32 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeByte256VectorTestsSmokeTest() { + static void ElementTypeByteVector256TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementType() == byte.class); } @Test - static void SpeciesElementSizeByte256VectorTestsSmokeTest() { + static void SpeciesElementSizeByteVector256TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementSize() == Byte.SIZE); } @Test - static void VectorTypeByte256VectorTestsSmokeTest() { + static void VectorTypeByteVector256TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesByte256VectorTestsSmokeTest() { + static void WithLanesByteVector256TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(byte.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeByte256VectorTestsSmokeTest() { + static void WithShapeByteVector256TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7337,7 +7337,7 @@ public class Byte256VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueByte256VectorTestsSmokeTest() { + static void MaskAllTrueByteVector256TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Byte512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ByteVector512LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Byte512VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ByteVector512LoadStoreTests.java index 61168532de0..0a9189927b1 100644 --- a/test/jdk/jdk/incubator/vector/Byte512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVector512LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Byte512VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation ByteVector512LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Byte512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ByteVector512LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_512; diff --git a/test/jdk/jdk/incubator/vector/Byte512VectorTests.java b/test/jdk/jdk/incubator/vector/ByteVector512Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Byte512VectorTests.java rename to test/jdk/jdk/incubator/vector/ByteVector512Tests.java index 711cff6bca3..02da1889dc8 100644 --- a/test/jdk/jdk/incubator/vector/Byte512VectorTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVector512Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Byte512VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ByteVector512Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Byte512VectorTests extends AbstractVectorTest { +public class ByteVector512Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_512; @@ -1705,7 +1705,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByte512VectorTests(IntFunction fa, IntFunction fb) { + static void ADDByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1718,7 +1718,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::ADD); + assertArraysEquals(r, a, b, ByteVector512Tests::ADD); } static byte add(byte a, byte b) { @@ -1726,7 +1726,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void addByte512VectorTests(IntFunction fa, IntFunction fb) { + static void addByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1737,11 +1737,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte512VectorTests::add); + assertArraysEquals(r, a, b, ByteVector512Tests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1757,11 +1757,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::ADD); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1775,7 +1775,7 @@ public class Byte512VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::add); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::add); } static byte SUB(byte a, byte b) { @@ -1783,7 +1783,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void SUBByte512VectorTests(IntFunction fa, IntFunction fb) { + static void SUBByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1796,7 +1796,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::SUB); + assertArraysEquals(r, a, b, ByteVector512Tests::SUB); } static byte sub(byte a, byte b) { @@ -1804,7 +1804,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void subByte512VectorTests(IntFunction fa, IntFunction fb) { + static void subByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1815,11 +1815,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte512VectorTests::sub); + assertArraysEquals(r, a, b, ByteVector512Tests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void SUBByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1835,11 +1835,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::SUB); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::SUB); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1853,7 +1853,7 @@ public class Byte512VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::sub); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::sub); } static byte MUL(byte a, byte b) { @@ -1861,7 +1861,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MULByte512VectorTests(IntFunction fa, IntFunction fb) { + static void MULByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1874,7 +1874,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::MUL); + assertArraysEquals(r, a, b, ByteVector512Tests::MUL); } static byte mul(byte a, byte b) { @@ -1882,7 +1882,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByte512VectorTests(IntFunction fa, IntFunction fb) { + static void mulByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1893,11 +1893,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte512VectorTests::mul); + assertArraysEquals(r, a, b, ByteVector512Tests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void MULByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1913,11 +1913,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::MUL); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::MUL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1931,7 +1931,7 @@ public class Byte512VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::mul); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::mul); } static byte DIV(byte a, byte b) { @@ -1939,7 +1939,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void DIVByte512VectorTests(IntFunction fa, IntFunction fb) { + static void DIVByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1954,7 +1954,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::DIV); + assertArraysEquals(r, a, b, ByteVector512Tests::DIV); } static byte div(byte a, byte b) { @@ -1962,7 +1962,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void divByte512VectorTests(IntFunction fa, IntFunction fb) { + static void divByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1977,11 +1977,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::div); + assertArraysEquals(r, a, b, ByteVector512Tests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void DIVByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1999,11 +1999,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::DIV); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::DIV); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2021,7 +2021,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::div); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::div); } static byte FIRST_NONZERO(byte a, byte b) { @@ -2029,7 +2029,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void FIRST_NONZEROByte512VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2042,11 +2042,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ByteVector512Tests::FIRST_NONZERO); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void FIRST_NONZEROByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2062,7 +2062,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::FIRST_NONZERO); } static byte AND(byte a, byte b) { @@ -2070,7 +2070,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByte512VectorTests(IntFunction fa, IntFunction fb) { + static void ANDByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2083,7 +2083,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::AND); + assertArraysEquals(r, a, b, ByteVector512Tests::AND); } static byte and(byte a, byte b) { @@ -2091,7 +2091,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void andByte512VectorTests(IntFunction fa, IntFunction fb) { + static void andByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2102,11 +2102,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte512VectorTests::and); + assertArraysEquals(r, a, b, ByteVector512Tests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2122,7 +2122,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::AND); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::AND); } static byte AND_NOT(byte a, byte b) { @@ -2130,7 +2130,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void AND_NOTByte512VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2143,11 +2143,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::AND_NOT); + assertArraysEquals(r, a, b, ByteVector512Tests::AND_NOT); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void AND_NOTByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2163,7 +2163,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::AND_NOT); } static byte OR(byte a, byte b) { @@ -2171,7 +2171,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte512VectorTests(IntFunction fa, IntFunction fb) { + static void ORByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2184,7 +2184,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::OR); + assertArraysEquals(r, a, b, ByteVector512Tests::OR); } static byte or(byte a, byte b) { @@ -2192,7 +2192,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void orByte512VectorTests(IntFunction fa, IntFunction fb) { + static void orByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2203,11 +2203,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte512VectorTests::or); + assertArraysEquals(r, a, b, ByteVector512Tests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2223,7 +2223,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::OR); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::OR); } static byte XOR(byte a, byte b) { @@ -2231,7 +2231,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void XORByte512VectorTests(IntFunction fa, IntFunction fb) { + static void XORByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2244,11 +2244,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::XOR); + assertArraysEquals(r, a, b, ByteVector512Tests::XOR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void XORByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2264,11 +2264,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::XOR); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::XOR); } @Test(dataProvider = "byteBinaryOpProvider") - static void addByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2278,11 +2278,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2295,11 +2295,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector512Tests::add); } @Test(dataProvider = "byteBinaryOpProvider") - static void subByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2309,11 +2309,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2326,11 +2326,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector512Tests::sub); } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2340,11 +2340,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2357,11 +2357,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector512Tests::mul); } @Test(dataProvider = "byteBinaryOpProvider") - static void divByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2373,11 +2373,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2392,11 +2392,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector512Tests::div); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2406,11 +2406,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void orByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2420,11 +2420,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::or); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2437,11 +2437,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte512VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector512Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2451,11 +2451,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void andByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2465,11 +2465,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::and); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2482,11 +2482,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte512VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector512Tests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2496,11 +2496,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Byte512VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ByteVector512Tests::OR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2513,11 +2513,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte512VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector512Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByte512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDByteVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2527,11 +2527,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Byte512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ByteVector512Tests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByte512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDByteVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2544,7 +2544,7 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector512Tests::ADD); } static byte LSHL(byte a, byte b) { @@ -2552,7 +2552,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByte512VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2565,11 +2565,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::LSHL); + assertArraysEquals(r, a, b, ByteVector512Tests::LSHL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2585,7 +2585,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::LSHL); } static byte ASHR(byte a, byte b) { @@ -2593,7 +2593,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByte512VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2606,11 +2606,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::ASHR); + assertArraysEquals(r, a, b, ByteVector512Tests::ASHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2626,7 +2626,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::ASHR); } static byte LSHR(byte a, byte b) { @@ -2634,7 +2634,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByte512VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2647,11 +2647,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::LSHR); + assertArraysEquals(r, a, b, ByteVector512Tests::LSHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2667,7 +2667,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::LSHR); } static byte LSHL_unary(byte a, byte b) { @@ -2675,7 +2675,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByte512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLByteVector512TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2687,11 +2687,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte512VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ByteVector512Tests::LSHL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByte512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2706,7 +2706,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte512VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector512Tests::LSHL_unary); } static byte LSHR_unary(byte a, byte b) { @@ -2714,7 +2714,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByte512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRByteVector512TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2726,11 +2726,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte512VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ByteVector512Tests::LSHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByte512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2745,7 +2745,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte512VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector512Tests::LSHR_unary); } static byte ASHR_unary(byte a, byte b) { @@ -2753,7 +2753,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByte512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRByteVector512TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2765,11 +2765,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte512VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ByteVector512Tests::ASHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByte512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2784,7 +2784,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte512VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector512Tests::ASHR_unary); } static byte ROR(byte a, byte b) { @@ -2792,7 +2792,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByte512VectorTests(IntFunction fa, IntFunction fb) { + static void RORByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2805,11 +2805,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::ROR); + assertArraysEquals(r, a, b, ByteVector512Tests::ROR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2825,7 +2825,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::ROR); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::ROR); } static byte ROL(byte a, byte b) { @@ -2833,7 +2833,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByte512VectorTests(IntFunction fa, IntFunction fb) { + static void ROLByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2846,11 +2846,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::ROL); + assertArraysEquals(r, a, b, ByteVector512Tests::ROL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2866,7 +2866,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::ROL); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::ROL); } static byte ROR_unary(byte a, byte b) { @@ -2874,7 +2874,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByte512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORByteVector512TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2886,11 +2886,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte512VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ByteVector512Tests::ROR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByte512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORByteVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2905,7 +2905,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte512VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector512Tests::ROR_unary); } static byte ROL_unary(byte a, byte b) { @@ -2913,7 +2913,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByte512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLByteVector512TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2925,11 +2925,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte512VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ByteVector512Tests::ROL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByte512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLByteVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2944,14 +2944,14 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte512VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector512Tests::ROL_unary); } static byte LSHR_binary_const(byte a) { return (byte)(((a & 0xFF) >>> CONST_SHIFT)); } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHRByte512VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRByteVector512TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2962,11 +2962,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte512VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ByteVector512Tests::LSHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHRByte512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRByteVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2980,7 +2980,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte512VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector512Tests::LSHR_binary_const); } static byte LSHL_binary_const(byte a) { @@ -2988,7 +2988,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHLByte512VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLByteVector512TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2999,11 +2999,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte512VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ByteVector512Tests::LSHL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHLByte512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLByteVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3017,7 +3017,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte512VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector512Tests::LSHL_binary_const); } static byte ASHR_binary_const(byte a) { @@ -3025,7 +3025,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ASHRByte512VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRByteVector512TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3036,11 +3036,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte512VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ByteVector512Tests::ASHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ASHRByte512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRByteVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3054,7 +3054,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte512VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector512Tests::ASHR_binary_const); } static byte ROR_binary_const(byte a) { @@ -3062,7 +3062,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void RORByte512VectorTestsScalarShiftConst(IntFunction fa) { + static void RORByteVector512TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3073,11 +3073,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte512VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ByteVector512Tests::ROR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void RORByte512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORByteVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3091,7 +3091,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte512VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector512Tests::ROR_binary_const); } static byte ROL_binary_const(byte a) { @@ -3099,7 +3099,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ROLByte512VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLByteVector512TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3110,11 +3110,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte512VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ByteVector512Tests::ROL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ROLByte512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLByteVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3128,14 +3128,14 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte512VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector512Tests::ROL_binary_const); } static ByteVector bv_MIN = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MINByte512VectorTestsWithMemOp(IntFunction fa) { + static void MINByteVector512TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3146,13 +3146,13 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte512VectorTests::MIN); + assertArraysEquals(r, a, (byte)10, ByteVector512Tests::MIN); } static ByteVector bv_min = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void minByte512VectorTestsWithMemOp(IntFunction fa) { + static void minByteVector512TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3163,13 +3163,13 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte512VectorTests::min); + assertArraysEquals(r, a, (byte)10, ByteVector512Tests::min); } static ByteVector bv_MIN_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINByte512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINByteVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3182,13 +3182,13 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, Byte512VectorTests::MIN); + assertArraysEquals(r, a, (byte)10, mask, ByteVector512Tests::MIN); } static ByteVector bv_MAX = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MAXByte512VectorTestsWithMemOp(IntFunction fa) { + static void MAXByteVector512TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3199,13 +3199,13 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte512VectorTests::MAX); + assertArraysEquals(r, a, (byte)10, ByteVector512Tests::MAX); } static ByteVector bv_max = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void maxByte512VectorTestsWithMemOp(IntFunction fa) { + static void maxByteVector512TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3216,13 +3216,13 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte512VectorTests::max); + assertArraysEquals(r, a, (byte)10, ByteVector512Tests::max); } static ByteVector bv_MAX_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXByte512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXByteVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3235,7 +3235,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, Byte512VectorTests::MAX); + assertArraysEquals(r, a, (byte)10, mask, ByteVector512Tests::MAX); } static byte MIN(byte a, byte b) { @@ -3243,7 +3243,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByte512VectorTests(IntFunction fa, IntFunction fb) { + static void MINByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3256,7 +3256,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::MIN); + assertArraysEquals(r, a, b, ByteVector512Tests::MIN); } static byte min(byte a, byte b) { @@ -3264,7 +3264,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void minByte512VectorTests(IntFunction fa, IntFunction fb) { + static void minByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3275,7 +3275,7 @@ public class Byte512VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte512VectorTests::min); + assertArraysEquals(r, a, b, ByteVector512Tests::min); } static byte MAX(byte a, byte b) { @@ -3283,7 +3283,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByte512VectorTests(IntFunction fa, IntFunction fb) { + static void MAXByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3296,7 +3296,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::MAX); + assertArraysEquals(r, a, b, ByteVector512Tests::MAX); } static byte max(byte a, byte b) { @@ -3304,7 +3304,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByte512VectorTests(IntFunction fa, IntFunction fb) { + static void maxByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3315,7 +3315,7 @@ public class Byte512VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte512VectorTests::max); + assertArraysEquals(r, a, b, ByteVector512Tests::max); } static byte UMIN(byte a, byte b) { @@ -3323,7 +3323,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMINByte512VectorTests(IntFunction fa, IntFunction fb) { + static void UMINByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3336,11 +3336,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::UMIN); + assertArraysEquals(r, a, b, ByteVector512Tests::UMIN); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMINByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3356,7 +3356,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::UMIN); } static byte UMAX(byte a, byte b) { @@ -3364,7 +3364,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMAXByte512VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3377,11 +3377,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::UMAX); + assertArraysEquals(r, a, b, ByteVector512Tests::UMAX); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMAXByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3397,7 +3397,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::UMAX); } static byte SADD(byte a, byte b) { @@ -3405,7 +3405,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SADDByte512VectorTests(IntFunction fa, IntFunction fb) { + static void SADDByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3418,11 +3418,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::SADD); + assertArraysEquals(r, a, b, ByteVector512Tests::SADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SADDByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3438,7 +3438,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::SADD); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::SADD); } static byte SSUB(byte a, byte b) { @@ -3446,7 +3446,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SSUBByte512VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3459,11 +3459,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::SSUB); + assertArraysEquals(r, a, b, ByteVector512Tests::SSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SSUBByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3479,7 +3479,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::SSUB); } static byte SUADD(byte a, byte b) { @@ -3487,7 +3487,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUADDByte512VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3500,11 +3500,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::SUADD); + assertArraysEquals(r, a, b, ByteVector512Tests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUADDByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3520,7 +3520,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::SUADD); } static byte SUSUB(byte a, byte b) { @@ -3528,7 +3528,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUSUBByte512VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3541,11 +3541,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::SUSUB); + assertArraysEquals(r, a, b, ByteVector512Tests::SUSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUSUBByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3561,11 +3561,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::SUSUB); } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3575,11 +3575,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::MIN); } @Test(dataProvider = "byteBinaryOpProvider") - static void minByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3589,11 +3589,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::min); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::min); } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3603,11 +3603,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::MAX); } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3617,10 +3617,10 @@ public class Byte512VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte512VectorTests::max); + assertBroadcastArraysEquals(r, a, b, ByteVector512Tests::max); } @Test(dataProvider = "byteSaturatingBinaryOpAssocProvider") - static void SUADDAssocByte512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocByteVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -3637,11 +3637,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Byte512VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ByteVector512Tests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3662,7 +3662,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Byte512VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ByteVector512Tests::SUADD); } static byte ANDReduce(byte[] a, int idx) { @@ -3684,7 +3684,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ANDReduceByte512VectorTests(IntFunction fa) { + static void ANDReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3700,7 +3700,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::ANDReduce, Byte512VectorTests::ANDReduceAll); + ByteVector512Tests::ANDReduce, ByteVector512Tests::ANDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3746,7 +3746,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ANDReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3764,7 +3764,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::ANDReduceMasked, Byte512VectorTests::ANDReduceAllMasked); + ByteVector512Tests::ANDReduceMasked, ByteVector512Tests::ANDReduceAllMasked); } static byte ORReduce(byte[] a, int idx) { @@ -3786,7 +3786,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ORReduceByte512VectorTests(IntFunction fa) { + static void ORReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3802,7 +3802,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::ORReduce, Byte512VectorTests::ORReduceAll); + ByteVector512Tests::ORReduce, ByteVector512Tests::ORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3848,7 +3848,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ORReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3866,7 +3866,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::ORReduceMasked, Byte512VectorTests::ORReduceAllMasked); + ByteVector512Tests::ORReduceMasked, ByteVector512Tests::ORReduceAllMasked); } static byte XORReduce(byte[] a, int idx) { @@ -3888,7 +3888,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void XORReduceByte512VectorTests(IntFunction fa) { + static void XORReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3904,7 +3904,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::XORReduce, Byte512VectorTests::XORReduceAll); + ByteVector512Tests::XORReduce, ByteVector512Tests::XORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3950,7 +3950,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void XORReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3968,7 +3968,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::XORReduceMasked, Byte512VectorTests::XORReduceAllMasked); + ByteVector512Tests::XORReduceMasked, ByteVector512Tests::XORReduceAllMasked); } static byte ADDReduce(byte[] a, int idx) { @@ -3990,7 +3990,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceByte512VectorTests(IntFunction fa) { + static void ADDReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4006,7 +4006,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::ADDReduce, Byte512VectorTests::ADDReduceAll); + ByteVector512Tests::ADDReduce, ByteVector512Tests::ADDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4052,7 +4052,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4070,7 +4070,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::ADDReduceMasked, Byte512VectorTests::ADDReduceAllMasked); + ByteVector512Tests::ADDReduceMasked, ByteVector512Tests::ADDReduceAllMasked); } static byte MULReduce(byte[] a, int idx) { @@ -4092,7 +4092,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MULReduceByte512VectorTests(IntFunction fa) { + static void MULReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4108,7 +4108,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::MULReduce, Byte512VectorTests::MULReduceAll); + ByteVector512Tests::MULReduce, ByteVector512Tests::MULReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4154,7 +4154,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MULReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4172,7 +4172,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::MULReduceMasked, Byte512VectorTests::MULReduceAllMasked); + ByteVector512Tests::MULReduceMasked, ByteVector512Tests::MULReduceAllMasked); } static byte MINReduce(byte[] a, int idx) { @@ -4194,7 +4194,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MINReduceByte512VectorTests(IntFunction fa) { + static void MINReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4210,7 +4210,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::MINReduce, Byte512VectorTests::MINReduceAll); + ByteVector512Tests::MINReduce, ByteVector512Tests::MINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4256,7 +4256,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4274,7 +4274,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::MINReduceMasked, Byte512VectorTests::MINReduceAllMasked); + ByteVector512Tests::MINReduceMasked, ByteVector512Tests::MINReduceAllMasked); } static byte MAXReduce(byte[] a, int idx) { @@ -4296,7 +4296,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MAXReduceByte512VectorTests(IntFunction fa) { + static void MAXReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4312,7 +4312,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::MAXReduce, Byte512VectorTests::MAXReduceAll); + ByteVector512Tests::MAXReduce, ByteVector512Tests::MAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4358,7 +4358,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4376,7 +4376,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::MAXReduceMasked, Byte512VectorTests::MAXReduceAllMasked); + ByteVector512Tests::MAXReduceMasked, ByteVector512Tests::MAXReduceAllMasked); } static byte UMINReduce(byte[] a, int idx) { @@ -4398,7 +4398,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMINReduceByte512VectorTests(IntFunction fa) { + static void UMINReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4414,7 +4414,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::UMINReduce, Byte512VectorTests::UMINReduceAll); + ByteVector512Tests::UMINReduce, ByteVector512Tests::UMINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4460,7 +4460,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMINReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4478,7 +4478,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::UMINReduceMasked, Byte512VectorTests::UMINReduceAllMasked); + ByteVector512Tests::UMINReduceMasked, ByteVector512Tests::UMINReduceAllMasked); } static byte UMAXReduce(byte[] a, int idx) { @@ -4500,7 +4500,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMAXReduceByte512VectorTests(IntFunction fa) { + static void UMAXReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4516,7 +4516,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::UMAXReduce, Byte512VectorTests::UMAXReduceAll); + ByteVector512Tests::UMAXReduce, ByteVector512Tests::UMAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4562,7 +4562,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMAXReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4580,7 +4580,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::UMAXReduceMasked, Byte512VectorTests::UMAXReduceAllMasked); + ByteVector512Tests::UMAXReduceMasked, ByteVector512Tests::UMAXReduceAllMasked); } static byte FIRST_NONZEROReduce(byte[] a, int idx) { @@ -4602,7 +4602,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void FIRST_NONZEROReduceByte512VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4618,7 +4618,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::FIRST_NONZEROReduce, Byte512VectorTests::FIRST_NONZEROReduceAll); + ByteVector512Tests::FIRST_NONZEROReduce, ByteVector512Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4664,7 +4664,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void FIRST_NONZEROReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4682,7 +4682,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::FIRST_NONZEROReduceMasked, Byte512VectorTests::FIRST_NONZEROReduceAllMasked); + ByteVector512Tests::FIRST_NONZEROReduceMasked, ByteVector512Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4695,7 +4695,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueByte512VectorTests(IntFunction fm) { + static void anyTrueByteVector512Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4706,7 +4706,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Byte512VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ByteVector512Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4719,7 +4719,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueByte512VectorTests(IntFunction fm) { + static void allTrueByteVector512Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4730,7 +4730,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Byte512VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ByteVector512Tests::allTrue); } static byte SUADDReduce(byte[] a, int idx) { @@ -4752,7 +4752,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingUnaryOpProvider") - static void SUADDReduceByte512VectorTests(IntFunction fa) { + static void SUADDReduceByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4768,7 +4768,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte512VectorTests::SUADDReduce, Byte512VectorTests::SUADDReduceAll); + ByteVector512Tests::SUADDReduce, ByteVector512Tests::SUADDReduceAll); } @Test(dataProvider = "byteSaturatingUnaryOpProvider") @@ -4813,7 +4813,7 @@ public class Byte512VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "byteSaturatingUnaryOpMaskProvider") - static void SUADDReduceByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4831,11 +4831,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::SUADDReduceMasked, Byte512VectorTests::SUADDReduceAllMasked); + ByteVector512Tests::SUADDReduceMasked, ByteVector512Tests::SUADDReduceAllMasked); } @Test(dataProvider = "byteBinaryOpProvider") - static void withByte512VectorTests(IntFunction fa, IntFunction fb) { + static void withByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -4858,7 +4858,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_DEFAULTByte512VectorTests(IntFunction fa) { + static void IS_DEFAULTByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4875,7 +4875,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_DEFAULTMaskedByte512VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4899,7 +4899,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_NEGATIVEByte512VectorTests(IntFunction fa) { + static void IS_NEGATIVEByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4916,7 +4916,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_NEGATIVEMaskedByte512VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4936,7 +4936,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte512VectorTests(IntFunction fa, IntFunction fb) { + static void LTByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4955,7 +4955,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByte512VectorTests(IntFunction fa, IntFunction fb) { + static void ltByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4974,7 +4974,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4997,7 +4997,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GTByte512VectorTests(IntFunction fa, IntFunction fb) { + static void GTByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5016,7 +5016,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GTByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5039,7 +5039,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte512VectorTests(IntFunction fa, IntFunction fb) { + static void EQByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5058,7 +5058,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByte512VectorTests(IntFunction fa, IntFunction fb) { + static void eqByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5077,7 +5077,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5100,7 +5100,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void NEByte512VectorTests(IntFunction fa, IntFunction fb) { + static void NEByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5119,7 +5119,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void NEByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5142,7 +5142,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LEByte512VectorTests(IntFunction fa, IntFunction fb) { + static void LEByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5161,7 +5161,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LEByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5184,7 +5184,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GEByte512VectorTests(IntFunction fa, IntFunction fb) { + static void GEByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5203,7 +5203,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GEByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5226,7 +5226,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULTByte512VectorTests(IntFunction fa, IntFunction fb) { + static void ULTByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5245,7 +5245,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULTByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5268,7 +5268,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGTByte512VectorTests(IntFunction fa, IntFunction fb) { + static void UGTByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5287,7 +5287,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGTByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5310,7 +5310,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULEByte512VectorTests(IntFunction fa, IntFunction fb) { + static void ULEByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5329,7 +5329,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULEByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5352,7 +5352,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGEByte512VectorTests(IntFunction fa, IntFunction fb) { + static void UGEByteVector512Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5371,7 +5371,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGEByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5394,7 +5394,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5410,7 +5410,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5430,7 +5430,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5446,7 +5446,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTByteVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5466,7 +5466,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5482,7 +5482,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5502,7 +5502,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5518,7 +5518,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQByteVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5542,7 +5542,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByte512VectorTests(IntFunction fa, IntFunction fb, + static void blendByteVector512Tests(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5558,11 +5558,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte512VectorTests::blend); + assertArraysEquals(r, a, b, mask, ByteVector512Tests::blend); } @Test(dataProvider = "byteUnaryOpShuffleProvider") - static void RearrangeByte512VectorTests(IntFunction fa, + static void RearrangeByteVector512Tests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5579,7 +5579,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpShuffleMaskProvider") - static void RearrangeByte512VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeByteVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -5597,7 +5597,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void compressByte512VectorTests(IntFunction fa, + static void compressByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5615,7 +5615,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void expandByte512VectorTests(IntFunction fa, + static void expandByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5633,7 +5633,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void getByte512VectorTests(IntFunction fa) { + static void getByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5789,7 +5789,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastByte512VectorTests(IntFunction fa) { + static void BroadcastByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5803,7 +5803,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZeroByte512VectorTests(IntFunction fa) { + static void ZeroByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5828,7 +5828,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void sliceUnaryByte512VectorTests(IntFunction fa) { + static void sliceUnaryByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5839,7 +5839,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Byte512VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ByteVector512Tests::sliceUnary); } static byte[] sliceBinary(byte[] a, byte[] b, int origin, int idx) { @@ -5856,7 +5856,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void sliceBinaryByte512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryByteVector512TestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5869,7 +5869,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Byte512VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ByteVector512Tests::sliceBinary); } static byte[] slice(byte[] a, byte[] b, int origin, boolean[] mask, int idx) { @@ -5886,7 +5886,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void sliceByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5903,7 +5903,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Byte512VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ByteVector512Tests::slice); } static byte[] unsliceUnary(byte[] a, int origin, int idx) { @@ -5920,7 +5920,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void unsliceUnaryByte512VectorTests(IntFunction fa) { + static void unsliceUnaryByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5931,7 +5931,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Byte512VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ByteVector512Tests::unsliceUnary); } static byte[] unsliceBinary(byte[] a, byte[] b, int origin, int part, int idx) { @@ -5957,7 +5957,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void unsliceBinaryByte512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryByteVector512TestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5971,7 +5971,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Byte512VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ByteVector512Tests::unsliceBinary); } static byte[] unslice(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx) { @@ -6011,7 +6011,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void unsliceByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6028,7 +6028,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Byte512VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ByteVector512Tests::unslice); } static byte BITWISE_BLEND(byte a, byte b, byte c) { @@ -6040,7 +6040,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6055,11 +6055,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Byte512VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ByteVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6072,11 +6072,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Byte512VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ByteVector512Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6094,11 +6094,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Byte512VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ByteVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6109,11 +6109,11 @@ public class Byte512VectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Byte512VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ByteVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6124,11 +6124,11 @@ public class Byte512VectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Byte512VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6139,11 +6139,11 @@ public class Byte512VectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Byte512VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ByteVector512Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6154,11 +6154,11 @@ public class Byte512VectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Byte512VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVector512Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6173,11 +6173,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Byte512VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ByteVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte512VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector512TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6192,11 +6192,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Byte512VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ByteVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6207,11 +6207,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Byte512VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6222,11 +6222,11 @@ public class Byte512VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Byte512VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVector512Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte512VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector512TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6240,7 +6240,7 @@ public class Byte512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Byte512VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ByteVector512Tests::BITWISE_BLEND); } static byte NEG(byte a) { @@ -6252,7 +6252,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NEGByte512VectorTests(IntFunction fa) { + static void NEGByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6263,11 +6263,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::NEG); + assertArraysEquals(r, a, ByteVector512Tests::NEG); } @Test(dataProvider = "byteUnaryOpProvider") - static void negByte512VectorTests(IntFunction fa) { + static void negByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6278,11 +6278,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::neg); + assertArraysEquals(r, a, ByteVector512Tests::neg); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NEGMaskedByte512VectorTests(IntFunction fa, + static void NEGMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6296,7 +6296,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::NEG); + assertArraysEquals(r, a, mask, ByteVector512Tests::NEG); } static byte ABS(byte a) { @@ -6308,7 +6308,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ABSByte512VectorTests(IntFunction fa) { + static void ABSByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6319,11 +6319,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::ABS); + assertArraysEquals(r, a, ByteVector512Tests::ABS); } @Test(dataProvider = "byteUnaryOpProvider") - static void absByte512VectorTests(IntFunction fa) { + static void absByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6334,11 +6334,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::abs); + assertArraysEquals(r, a, ByteVector512Tests::abs); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ABSMaskedByte512VectorTests(IntFunction fa, + static void ABSMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6352,7 +6352,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::ABS); + assertArraysEquals(r, a, mask, ByteVector512Tests::ABS); } static byte NOT(byte a) { @@ -6364,7 +6364,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NOTByte512VectorTests(IntFunction fa) { + static void NOTByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6375,11 +6375,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::NOT); + assertArraysEquals(r, a, ByteVector512Tests::NOT); } @Test(dataProvider = "byteUnaryOpProvider") - static void notByte512VectorTests(IntFunction fa) { + static void notByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6390,11 +6390,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::not); + assertArraysEquals(r, a, ByteVector512Tests::not); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NOTMaskedByte512VectorTests(IntFunction fa, + static void NOTMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6408,7 +6408,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::NOT); + assertArraysEquals(r, a, mask, ByteVector512Tests::NOT); } static byte ZOMO(byte a) { @@ -6416,7 +6416,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZOMOByte512VectorTests(IntFunction fa) { + static void ZOMOByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6427,11 +6427,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::ZOMO); + assertArraysEquals(r, a, ByteVector512Tests::ZOMO); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ZOMOMaskedByte512VectorTests(IntFunction fa, + static void ZOMOMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6445,7 +6445,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::ZOMO); + assertArraysEquals(r, a, mask, ByteVector512Tests::ZOMO); } static byte BIT_COUNT(byte a) { @@ -6453,7 +6453,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BIT_COUNTByte512VectorTests(IntFunction fa) { + static void BIT_COUNTByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6464,11 +6464,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::BIT_COUNT); + assertArraysEquals(r, a, ByteVector512Tests::BIT_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void BIT_COUNTMaskedByte512VectorTests(IntFunction fa, + static void BIT_COUNTMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6482,7 +6482,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ByteVector512Tests::BIT_COUNT); } static byte TRAILING_ZEROS_COUNT(byte a) { @@ -6490,7 +6490,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void TRAILING_ZEROS_COUNTByte512VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6501,11 +6501,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVector512Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedByte512VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6519,7 +6519,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVector512Tests::TRAILING_ZEROS_COUNT); } static byte LEADING_ZEROS_COUNT(byte a) { @@ -6527,7 +6527,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LEADING_ZEROS_COUNTByte512VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6538,11 +6538,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVector512Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedByte512VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6556,7 +6556,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVector512Tests::LEADING_ZEROS_COUNT); } static byte REVERSE(byte a) { @@ -6564,7 +6564,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSEByte512VectorTests(IntFunction fa) { + static void REVERSEByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6575,11 +6575,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::REVERSE); + assertArraysEquals(r, a, ByteVector512Tests::REVERSE); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSEMaskedByte512VectorTests(IntFunction fa, + static void REVERSEMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6593,7 +6593,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::REVERSE); + assertArraysEquals(r, a, mask, ByteVector512Tests::REVERSE); } static byte REVERSE_BYTES(byte a) { @@ -6601,7 +6601,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSE_BYTESByte512VectorTests(IntFunction fa) { + static void REVERSE_BYTESByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6612,11 +6612,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ByteVector512Tests::REVERSE_BYTES); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedByte512VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedByteVector512Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6630,7 +6630,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte512VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ByteVector512Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6638,7 +6638,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandByte512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandByteVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6651,7 +6651,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::band); + assertArraysEquals(r, a, b, ByteVector512Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6659,7 +6659,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorByte512VectorTests(IntFunction fa, IntFunction fb) { + static void maskorByteVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6672,7 +6672,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::bor); + assertArraysEquals(r, a, b, ByteVector512Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6680,7 +6680,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorByte512VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorByteVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6693,7 +6693,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::bxor); + assertArraysEquals(r, a, b, ByteVector512Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6701,7 +6701,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotByte512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotByteVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6714,7 +6714,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::bandNot); + assertArraysEquals(r, a, b, ByteVector512Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6722,7 +6722,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqByte512VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqByteVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6735,7 +6735,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte512VectorTests::beq); + assertArraysEquals(r, a, b, ByteVector512Tests::beq); } static boolean unot(boolean a) { @@ -6743,7 +6743,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotByte512VectorTests(IntFunction fa) { + static void masknotByteVector512Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6754,7 +6754,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte512VectorTests::unot); + assertArraysEquals(r, a, ByteVector512Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6771,7 +6771,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongByte512VectorTests(IntFunction fa) { + static void maskFromToLongByteVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6785,7 +6785,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByte512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltByteVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6801,7 +6801,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByte512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqByteVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6817,7 +6817,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toIntArrayByte512VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayByteVector512TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6828,7 +6828,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toLongArrayByte512VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayByteVector512TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6839,7 +6839,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toDoubleArrayByte512VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayByteVector512TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6850,7 +6850,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toStringByte512VectorTestsSmokeTest(IntFunction fa) { + static void toStringByteVector512TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6863,7 +6863,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void hashCodeByte512VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeByteVector512TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6877,7 +6877,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void reinterpretAsBytesByte512VectorTestsSmokeTest(IntFunction fa) { + static void reinterpretAsBytesByteVector512TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6907,7 +6907,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceLongByte512VectorTests(IntFunction fa) { + static void ADDReduceLongByteVector512Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6923,7 +6923,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Byte512VectorTests::ADDReduceLong, Byte512VectorTests::ADDReduceAllLong); + ByteVector512Tests::ADDReduceLong, ByteVector512Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(byte[] a, int idx, boolean[] mask) { @@ -6946,7 +6946,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceLongByte512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongByteVector512TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6964,11 +6964,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Byte512VectorTests::ADDReduceLongMasked, Byte512VectorTests::ADDReduceAllLongMasked); + ByteVector512Tests::ADDReduceLongMasked, ByteVector512Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastLongByte512VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongByteVector512TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6979,7 +6979,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByte512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendByteVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6993,12 +6993,12 @@ public class Byte512VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte512VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector512Tests::blend); } @Test(dataProvider = "byteUnaryOpSelectFromProvider") - static void SelectFromByte512VectorTests(IntFunction fa, + static void SelectFromByteVector512Tests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); byte[] order = fs.apply(a.length, SPECIES.length()); @@ -7014,7 +7014,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorByte512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorByteVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] idx = fc.apply(SPECIES.length()); @@ -7032,7 +7032,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpSelectFromMaskProvider") - static void SelectFromByte512VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromByteVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -7051,7 +7051,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousByte512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousByteVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7067,7 +7067,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringByte512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringByteVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7081,7 +7081,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsByte512VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsByteVector512TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7095,7 +7095,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsByte512VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsByteVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7111,7 +7111,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeByte512VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeByteVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7133,7 +7133,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountByte512VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountByteVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7144,7 +7144,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte512VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ByteVector512Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7158,7 +7158,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueByte512VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueByteVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7169,7 +7169,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte512VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ByteVector512Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7183,7 +7183,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueByte512VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueByteVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7194,11 +7194,11 @@ public class Byte512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte512VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ByteVector512Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressByte512VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressByteVector512TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7226,7 +7226,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeByte512VectorTestsSmokeTest(int offset) { + static void indexInRangeByteVector512TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7240,7 +7240,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongByte512VectorTestsSmokeTest(int offset) { + static void indexInRangeLongByteVector512TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7267,14 +7267,14 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundByte512VectorTestsSmokeTest(int length) { + static void loopBoundByteVector512TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongByte512VectorTestsSmokeTest(int _length) { + static void loopBoundLongByteVector512TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7282,21 +7282,21 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeByte512VectorTestsSmokeTest() { + static void ElementSizeByteVector512TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Byte.SIZE); } @Test - static void VectorShapeByte512VectorTestsSmokeTest() { + static void VectorShapeByteVector512TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_512_BIT)); } @Test - static void ShapeWithLanesByte512VectorTestsSmokeTest() { + static void ShapeWithLanesByteVector512TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(byte.class); @@ -7304,32 +7304,32 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeByte512VectorTestsSmokeTest() { + static void ElementTypeByteVector512TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementType() == byte.class); } @Test - static void SpeciesElementSizeByte512VectorTestsSmokeTest() { + static void SpeciesElementSizeByteVector512TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementSize() == Byte.SIZE); } @Test - static void VectorTypeByte512VectorTestsSmokeTest() { + static void VectorTypeByteVector512TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesByte512VectorTestsSmokeTest() { + static void WithLanesByteVector512TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(byte.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeByte512VectorTestsSmokeTest() { + static void WithShapeByteVector512TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7337,7 +7337,7 @@ public class Byte512VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueByte512VectorTestsSmokeTest() { + static void MaskAllTrueByteVector512TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Byte64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ByteVector64LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Byte64VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ByteVector64LoadStoreTests.java index 9b0687c73f2..2b9637d28dc 100644 --- a/test/jdk/jdk/incubator/vector/Byte64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVector64LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Byte64VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation ByteVector64LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Byte64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ByteVector64LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_64; diff --git a/test/jdk/jdk/incubator/vector/Byte64VectorTests.java b/test/jdk/jdk/incubator/vector/ByteVector64Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Byte64VectorTests.java rename to test/jdk/jdk/incubator/vector/ByteVector64Tests.java index b71d642d447..ce671440d2e 100644 --- a/test/jdk/jdk/incubator/vector/Byte64VectorTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVector64Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Byte64VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ByteVector64Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Byte64VectorTests extends AbstractVectorTest { +public class ByteVector64Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_64; @@ -1705,7 +1705,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByte64VectorTests(IntFunction fa, IntFunction fb) { + static void ADDByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1718,7 +1718,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::ADD); + assertArraysEquals(r, a, b, ByteVector64Tests::ADD); } static byte add(byte a, byte b) { @@ -1726,7 +1726,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void addByte64VectorTests(IntFunction fa, IntFunction fb) { + static void addByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1737,11 +1737,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte64VectorTests::add); + assertArraysEquals(r, a, b, ByteVector64Tests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1757,11 +1757,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::ADD); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1775,7 +1775,7 @@ public class Byte64VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::add); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::add); } static byte SUB(byte a, byte b) { @@ -1783,7 +1783,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void SUBByte64VectorTests(IntFunction fa, IntFunction fb) { + static void SUBByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1796,7 +1796,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::SUB); + assertArraysEquals(r, a, b, ByteVector64Tests::SUB); } static byte sub(byte a, byte b) { @@ -1804,7 +1804,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void subByte64VectorTests(IntFunction fa, IntFunction fb) { + static void subByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1815,11 +1815,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte64VectorTests::sub); + assertArraysEquals(r, a, b, ByteVector64Tests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void SUBByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1835,11 +1835,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::SUB); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::SUB); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1853,7 +1853,7 @@ public class Byte64VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::sub); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::sub); } static byte MUL(byte a, byte b) { @@ -1861,7 +1861,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MULByte64VectorTests(IntFunction fa, IntFunction fb) { + static void MULByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1874,7 +1874,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::MUL); + assertArraysEquals(r, a, b, ByteVector64Tests::MUL); } static byte mul(byte a, byte b) { @@ -1882,7 +1882,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByte64VectorTests(IntFunction fa, IntFunction fb) { + static void mulByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1893,11 +1893,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte64VectorTests::mul); + assertArraysEquals(r, a, b, ByteVector64Tests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void MULByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1913,11 +1913,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::MUL); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::MUL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1931,7 +1931,7 @@ public class Byte64VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::mul); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::mul); } static byte DIV(byte a, byte b) { @@ -1939,7 +1939,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void DIVByte64VectorTests(IntFunction fa, IntFunction fb) { + static void DIVByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1954,7 +1954,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::DIV); + assertArraysEquals(r, a, b, ByteVector64Tests::DIV); } static byte div(byte a, byte b) { @@ -1962,7 +1962,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void divByte64VectorTests(IntFunction fa, IntFunction fb) { + static void divByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1977,11 +1977,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::div); + assertArraysEquals(r, a, b, ByteVector64Tests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void DIVByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1999,11 +1999,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::DIV); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::DIV); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2021,7 +2021,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::div); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::div); } static byte FIRST_NONZERO(byte a, byte b) { @@ -2029,7 +2029,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void FIRST_NONZEROByte64VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2042,11 +2042,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ByteVector64Tests::FIRST_NONZERO); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void FIRST_NONZEROByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2062,7 +2062,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::FIRST_NONZERO); } static byte AND(byte a, byte b) { @@ -2070,7 +2070,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByte64VectorTests(IntFunction fa, IntFunction fb) { + static void ANDByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2083,7 +2083,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::AND); + assertArraysEquals(r, a, b, ByteVector64Tests::AND); } static byte and(byte a, byte b) { @@ -2091,7 +2091,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void andByte64VectorTests(IntFunction fa, IntFunction fb) { + static void andByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2102,11 +2102,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte64VectorTests::and); + assertArraysEquals(r, a, b, ByteVector64Tests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2122,7 +2122,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::AND); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::AND); } static byte AND_NOT(byte a, byte b) { @@ -2130,7 +2130,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void AND_NOTByte64VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2143,11 +2143,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::AND_NOT); + assertArraysEquals(r, a, b, ByteVector64Tests::AND_NOT); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void AND_NOTByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2163,7 +2163,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::AND_NOT); } static byte OR(byte a, byte b) { @@ -2171,7 +2171,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte64VectorTests(IntFunction fa, IntFunction fb) { + static void ORByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2184,7 +2184,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::OR); + assertArraysEquals(r, a, b, ByteVector64Tests::OR); } static byte or(byte a, byte b) { @@ -2192,7 +2192,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void orByte64VectorTests(IntFunction fa, IntFunction fb) { + static void orByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2203,11 +2203,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte64VectorTests::or); + assertArraysEquals(r, a, b, ByteVector64Tests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2223,7 +2223,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::OR); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::OR); } static byte XOR(byte a, byte b) { @@ -2231,7 +2231,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void XORByte64VectorTests(IntFunction fa, IntFunction fb) { + static void XORByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2244,11 +2244,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::XOR); + assertArraysEquals(r, a, b, ByteVector64Tests::XOR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void XORByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2264,11 +2264,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::XOR); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::XOR); } @Test(dataProvider = "byteBinaryOpProvider") - static void addByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2278,11 +2278,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2295,11 +2295,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector64Tests::add); } @Test(dataProvider = "byteBinaryOpProvider") - static void subByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2309,11 +2309,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2326,11 +2326,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector64Tests::sub); } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2340,11 +2340,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2357,11 +2357,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector64Tests::mul); } @Test(dataProvider = "byteBinaryOpProvider") - static void divByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2373,11 +2373,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2392,11 +2392,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector64Tests::div); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2406,11 +2406,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void orByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2420,11 +2420,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::or); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2437,11 +2437,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte64VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector64Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2451,11 +2451,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void andByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2465,11 +2465,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::and); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2482,11 +2482,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Byte64VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ByteVector64Tests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByte64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2496,11 +2496,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Byte64VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ByteVector64Tests::OR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByte64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2513,11 +2513,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte64VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector64Tests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByte64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDByteVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2527,11 +2527,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Byte64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ByteVector64Tests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByte64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDByteVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2544,7 +2544,7 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector64Tests::ADD); } static byte LSHL(byte a, byte b) { @@ -2552,7 +2552,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByte64VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2565,11 +2565,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::LSHL); + assertArraysEquals(r, a, b, ByteVector64Tests::LSHL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2585,7 +2585,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::LSHL); } static byte ASHR(byte a, byte b) { @@ -2593,7 +2593,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByte64VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2606,11 +2606,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::ASHR); + assertArraysEquals(r, a, b, ByteVector64Tests::ASHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2626,7 +2626,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::ASHR); } static byte LSHR(byte a, byte b) { @@ -2634,7 +2634,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByte64VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2647,11 +2647,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::LSHR); + assertArraysEquals(r, a, b, ByteVector64Tests::LSHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2667,7 +2667,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::LSHR); } static byte LSHL_unary(byte a, byte b) { @@ -2675,7 +2675,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByte64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLByteVector64TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2687,11 +2687,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte64VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ByteVector64Tests::LSHL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByte64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2706,7 +2706,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte64VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector64Tests::LSHL_unary); } static byte LSHR_unary(byte a, byte b) { @@ -2714,7 +2714,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByte64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRByteVector64TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2726,11 +2726,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte64VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ByteVector64Tests::LSHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByte64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2745,7 +2745,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte64VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector64Tests::LSHR_unary); } static byte ASHR_unary(byte a, byte b) { @@ -2753,7 +2753,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByte64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRByteVector64TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2765,11 +2765,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte64VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ByteVector64Tests::ASHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByte64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2784,7 +2784,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte64VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector64Tests::ASHR_unary); } static byte ROR(byte a, byte b) { @@ -2792,7 +2792,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByte64VectorTests(IntFunction fa, IntFunction fb) { + static void RORByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2805,11 +2805,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::ROR); + assertArraysEquals(r, a, b, ByteVector64Tests::ROR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2825,7 +2825,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::ROR); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::ROR); } static byte ROL(byte a, byte b) { @@ -2833,7 +2833,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByte64VectorTests(IntFunction fa, IntFunction fb) { + static void ROLByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2846,11 +2846,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::ROL); + assertArraysEquals(r, a, b, ByteVector64Tests::ROL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2866,7 +2866,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::ROL); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::ROL); } static byte ROR_unary(byte a, byte b) { @@ -2874,7 +2874,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByte64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORByteVector64TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2886,11 +2886,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte64VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ByteVector64Tests::ROR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByte64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORByteVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2905,7 +2905,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte64VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector64Tests::ROR_unary); } static byte ROL_unary(byte a, byte b) { @@ -2913,7 +2913,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByte64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLByteVector64TestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2925,11 +2925,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Byte64VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ByteVector64Tests::ROL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByte64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLByteVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2944,14 +2944,14 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Byte64VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVector64Tests::ROL_unary); } static byte LSHR_binary_const(byte a) { return (byte)(((a & 0xFF) >>> CONST_SHIFT)); } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHRByte64VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRByteVector64TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2962,11 +2962,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte64VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ByteVector64Tests::LSHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHRByte64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRByteVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2980,7 +2980,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte64VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector64Tests::LSHR_binary_const); } static byte LSHL_binary_const(byte a) { @@ -2988,7 +2988,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHLByte64VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLByteVector64TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2999,11 +2999,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte64VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ByteVector64Tests::LSHL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHLByte64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLByteVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3017,7 +3017,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte64VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector64Tests::LSHL_binary_const); } static byte ASHR_binary_const(byte a) { @@ -3025,7 +3025,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ASHRByte64VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRByteVector64TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3036,11 +3036,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte64VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ByteVector64Tests::ASHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ASHRByte64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRByteVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3054,7 +3054,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte64VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector64Tests::ASHR_binary_const); } static byte ROR_binary_const(byte a) { @@ -3062,7 +3062,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void RORByte64VectorTestsScalarShiftConst(IntFunction fa) { + static void RORByteVector64TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3073,11 +3073,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte64VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ByteVector64Tests::ROR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void RORByte64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORByteVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3091,7 +3091,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte64VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector64Tests::ROR_binary_const); } static byte ROL_binary_const(byte a) { @@ -3099,7 +3099,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ROLByte64VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLByteVector64TestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3110,11 +3110,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Byte64VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ByteVector64Tests::ROL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ROLByte64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLByteVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3128,14 +3128,14 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Byte64VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVector64Tests::ROL_binary_const); } static ByteVector bv_MIN = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MINByte64VectorTestsWithMemOp(IntFunction fa) { + static void MINByteVector64TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3146,13 +3146,13 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte64VectorTests::MIN); + assertArraysEquals(r, a, (byte)10, ByteVector64Tests::MIN); } static ByteVector bv_min = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void minByte64VectorTestsWithMemOp(IntFunction fa) { + static void minByteVector64TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3163,13 +3163,13 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte64VectorTests::min); + assertArraysEquals(r, a, (byte)10, ByteVector64Tests::min); } static ByteVector bv_MIN_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINByte64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINByteVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3182,13 +3182,13 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, Byte64VectorTests::MIN); + assertArraysEquals(r, a, (byte)10, mask, ByteVector64Tests::MIN); } static ByteVector bv_MAX = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MAXByte64VectorTestsWithMemOp(IntFunction fa) { + static void MAXByteVector64TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3199,13 +3199,13 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte64VectorTests::MAX); + assertArraysEquals(r, a, (byte)10, ByteVector64Tests::MAX); } static ByteVector bv_max = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void maxByte64VectorTestsWithMemOp(IntFunction fa) { + static void maxByteVector64TestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3216,13 +3216,13 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, Byte64VectorTests::max); + assertArraysEquals(r, a, (byte)10, ByteVector64Tests::max); } static ByteVector bv_MAX_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXByte64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXByteVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3235,7 +3235,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, Byte64VectorTests::MAX); + assertArraysEquals(r, a, (byte)10, mask, ByteVector64Tests::MAX); } static byte MIN(byte a, byte b) { @@ -3243,7 +3243,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByte64VectorTests(IntFunction fa, IntFunction fb) { + static void MINByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3256,7 +3256,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::MIN); + assertArraysEquals(r, a, b, ByteVector64Tests::MIN); } static byte min(byte a, byte b) { @@ -3264,7 +3264,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void minByte64VectorTests(IntFunction fa, IntFunction fb) { + static void minByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3275,7 +3275,7 @@ public class Byte64VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte64VectorTests::min); + assertArraysEquals(r, a, b, ByteVector64Tests::min); } static byte MAX(byte a, byte b) { @@ -3283,7 +3283,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByte64VectorTests(IntFunction fa, IntFunction fb) { + static void MAXByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3296,7 +3296,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::MAX); + assertArraysEquals(r, a, b, ByteVector64Tests::MAX); } static byte max(byte a, byte b) { @@ -3304,7 +3304,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByte64VectorTests(IntFunction fa, IntFunction fb) { + static void maxByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3315,7 +3315,7 @@ public class Byte64VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Byte64VectorTests::max); + assertArraysEquals(r, a, b, ByteVector64Tests::max); } static byte UMIN(byte a, byte b) { @@ -3323,7 +3323,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMINByte64VectorTests(IntFunction fa, IntFunction fb) { + static void UMINByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3336,11 +3336,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::UMIN); + assertArraysEquals(r, a, b, ByteVector64Tests::UMIN); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMINByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3356,7 +3356,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::UMIN); } static byte UMAX(byte a, byte b) { @@ -3364,7 +3364,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMAXByte64VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3377,11 +3377,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::UMAX); + assertArraysEquals(r, a, b, ByteVector64Tests::UMAX); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMAXByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3397,7 +3397,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::UMAX); } static byte SADD(byte a, byte b) { @@ -3405,7 +3405,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SADDByte64VectorTests(IntFunction fa, IntFunction fb) { + static void SADDByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3418,11 +3418,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::SADD); + assertArraysEquals(r, a, b, ByteVector64Tests::SADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SADDByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3438,7 +3438,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::SADD); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::SADD); } static byte SSUB(byte a, byte b) { @@ -3446,7 +3446,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SSUBByte64VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3459,11 +3459,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::SSUB); + assertArraysEquals(r, a, b, ByteVector64Tests::SSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SSUBByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3479,7 +3479,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::SSUB); } static byte SUADD(byte a, byte b) { @@ -3487,7 +3487,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUADDByte64VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3500,11 +3500,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::SUADD); + assertArraysEquals(r, a, b, ByteVector64Tests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUADDByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3520,7 +3520,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::SUADD); } static byte SUSUB(byte a, byte b) { @@ -3528,7 +3528,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUSUBByte64VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3541,11 +3541,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::SUSUB); + assertArraysEquals(r, a, b, ByteVector64Tests::SUSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUSUBByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3561,11 +3561,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::SUSUB); } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3575,11 +3575,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::MIN); } @Test(dataProvider = "byteBinaryOpProvider") - static void minByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3589,11 +3589,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::min); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::min); } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3603,11 +3603,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::MAX); } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3617,10 +3617,10 @@ public class Byte64VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Byte64VectorTests::max); + assertBroadcastArraysEquals(r, a, b, ByteVector64Tests::max); } @Test(dataProvider = "byteSaturatingBinaryOpAssocProvider") - static void SUADDAssocByte64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocByteVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -3637,11 +3637,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Byte64VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ByteVector64Tests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3662,7 +3662,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Byte64VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ByteVector64Tests::SUADD); } static byte ANDReduce(byte[] a, int idx) { @@ -3684,7 +3684,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ANDReduceByte64VectorTests(IntFunction fa) { + static void ANDReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3700,7 +3700,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::ANDReduce, Byte64VectorTests::ANDReduceAll); + ByteVector64Tests::ANDReduce, ByteVector64Tests::ANDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3746,7 +3746,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ANDReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3764,7 +3764,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::ANDReduceMasked, Byte64VectorTests::ANDReduceAllMasked); + ByteVector64Tests::ANDReduceMasked, ByteVector64Tests::ANDReduceAllMasked); } static byte ORReduce(byte[] a, int idx) { @@ -3786,7 +3786,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ORReduceByte64VectorTests(IntFunction fa) { + static void ORReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3802,7 +3802,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::ORReduce, Byte64VectorTests::ORReduceAll); + ByteVector64Tests::ORReduce, ByteVector64Tests::ORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3848,7 +3848,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ORReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3866,7 +3866,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::ORReduceMasked, Byte64VectorTests::ORReduceAllMasked); + ByteVector64Tests::ORReduceMasked, ByteVector64Tests::ORReduceAllMasked); } static byte XORReduce(byte[] a, int idx) { @@ -3888,7 +3888,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void XORReduceByte64VectorTests(IntFunction fa) { + static void XORReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3904,7 +3904,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::XORReduce, Byte64VectorTests::XORReduceAll); + ByteVector64Tests::XORReduce, ByteVector64Tests::XORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3950,7 +3950,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void XORReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3968,7 +3968,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::XORReduceMasked, Byte64VectorTests::XORReduceAllMasked); + ByteVector64Tests::XORReduceMasked, ByteVector64Tests::XORReduceAllMasked); } static byte ADDReduce(byte[] a, int idx) { @@ -3990,7 +3990,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceByte64VectorTests(IntFunction fa) { + static void ADDReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4006,7 +4006,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::ADDReduce, Byte64VectorTests::ADDReduceAll); + ByteVector64Tests::ADDReduce, ByteVector64Tests::ADDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4052,7 +4052,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4070,7 +4070,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::ADDReduceMasked, Byte64VectorTests::ADDReduceAllMasked); + ByteVector64Tests::ADDReduceMasked, ByteVector64Tests::ADDReduceAllMasked); } static byte MULReduce(byte[] a, int idx) { @@ -4092,7 +4092,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MULReduceByte64VectorTests(IntFunction fa) { + static void MULReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4108,7 +4108,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::MULReduce, Byte64VectorTests::MULReduceAll); + ByteVector64Tests::MULReduce, ByteVector64Tests::MULReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4154,7 +4154,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MULReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4172,7 +4172,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::MULReduceMasked, Byte64VectorTests::MULReduceAllMasked); + ByteVector64Tests::MULReduceMasked, ByteVector64Tests::MULReduceAllMasked); } static byte MINReduce(byte[] a, int idx) { @@ -4194,7 +4194,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MINReduceByte64VectorTests(IntFunction fa) { + static void MINReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4210,7 +4210,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::MINReduce, Byte64VectorTests::MINReduceAll); + ByteVector64Tests::MINReduce, ByteVector64Tests::MINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4256,7 +4256,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4274,7 +4274,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::MINReduceMasked, Byte64VectorTests::MINReduceAllMasked); + ByteVector64Tests::MINReduceMasked, ByteVector64Tests::MINReduceAllMasked); } static byte MAXReduce(byte[] a, int idx) { @@ -4296,7 +4296,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MAXReduceByte64VectorTests(IntFunction fa) { + static void MAXReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4312,7 +4312,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::MAXReduce, Byte64VectorTests::MAXReduceAll); + ByteVector64Tests::MAXReduce, ByteVector64Tests::MAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4358,7 +4358,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4376,7 +4376,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::MAXReduceMasked, Byte64VectorTests::MAXReduceAllMasked); + ByteVector64Tests::MAXReduceMasked, ByteVector64Tests::MAXReduceAllMasked); } static byte UMINReduce(byte[] a, int idx) { @@ -4398,7 +4398,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMINReduceByte64VectorTests(IntFunction fa) { + static void UMINReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4414,7 +4414,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::UMINReduce, Byte64VectorTests::UMINReduceAll); + ByteVector64Tests::UMINReduce, ByteVector64Tests::UMINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4460,7 +4460,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMINReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4478,7 +4478,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::UMINReduceMasked, Byte64VectorTests::UMINReduceAllMasked); + ByteVector64Tests::UMINReduceMasked, ByteVector64Tests::UMINReduceAllMasked); } static byte UMAXReduce(byte[] a, int idx) { @@ -4500,7 +4500,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMAXReduceByte64VectorTests(IntFunction fa) { + static void UMAXReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4516,7 +4516,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::UMAXReduce, Byte64VectorTests::UMAXReduceAll); + ByteVector64Tests::UMAXReduce, ByteVector64Tests::UMAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4562,7 +4562,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMAXReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4580,7 +4580,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::UMAXReduceMasked, Byte64VectorTests::UMAXReduceAllMasked); + ByteVector64Tests::UMAXReduceMasked, ByteVector64Tests::UMAXReduceAllMasked); } static byte FIRST_NONZEROReduce(byte[] a, int idx) { @@ -4602,7 +4602,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void FIRST_NONZEROReduceByte64VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4618,7 +4618,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::FIRST_NONZEROReduce, Byte64VectorTests::FIRST_NONZEROReduceAll); + ByteVector64Tests::FIRST_NONZEROReduce, ByteVector64Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4664,7 +4664,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void FIRST_NONZEROReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4682,7 +4682,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::FIRST_NONZEROReduceMasked, Byte64VectorTests::FIRST_NONZEROReduceAllMasked); + ByteVector64Tests::FIRST_NONZEROReduceMasked, ByteVector64Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4695,7 +4695,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueByte64VectorTests(IntFunction fm) { + static void anyTrueByteVector64Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4706,7 +4706,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Byte64VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ByteVector64Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4719,7 +4719,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueByte64VectorTests(IntFunction fm) { + static void allTrueByteVector64Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4730,7 +4730,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Byte64VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ByteVector64Tests::allTrue); } static byte SUADDReduce(byte[] a, int idx) { @@ -4752,7 +4752,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingUnaryOpProvider") - static void SUADDReduceByte64VectorTests(IntFunction fa) { + static void SUADDReduceByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4768,7 +4768,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Byte64VectorTests::SUADDReduce, Byte64VectorTests::SUADDReduceAll); + ByteVector64Tests::SUADDReduce, ByteVector64Tests::SUADDReduceAll); } @Test(dataProvider = "byteSaturatingUnaryOpProvider") @@ -4813,7 +4813,7 @@ public class Byte64VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "byteSaturatingUnaryOpMaskProvider") - static void SUADDReduceByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4831,11 +4831,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::SUADDReduceMasked, Byte64VectorTests::SUADDReduceAllMasked); + ByteVector64Tests::SUADDReduceMasked, ByteVector64Tests::SUADDReduceAllMasked); } @Test(dataProvider = "byteBinaryOpProvider") - static void withByte64VectorTests(IntFunction fa, IntFunction fb) { + static void withByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -4858,7 +4858,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_DEFAULTByte64VectorTests(IntFunction fa) { + static void IS_DEFAULTByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4875,7 +4875,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_DEFAULTMaskedByte64VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4899,7 +4899,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_NEGATIVEByte64VectorTests(IntFunction fa) { + static void IS_NEGATIVEByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4916,7 +4916,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_NEGATIVEMaskedByte64VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4936,7 +4936,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte64VectorTests(IntFunction fa, IntFunction fb) { + static void LTByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4955,7 +4955,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByte64VectorTests(IntFunction fa, IntFunction fb) { + static void ltByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4974,7 +4974,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4997,7 +4997,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GTByte64VectorTests(IntFunction fa, IntFunction fb) { + static void GTByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5016,7 +5016,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GTByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5039,7 +5039,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte64VectorTests(IntFunction fa, IntFunction fb) { + static void EQByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5058,7 +5058,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByte64VectorTests(IntFunction fa, IntFunction fb) { + static void eqByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5077,7 +5077,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5100,7 +5100,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void NEByte64VectorTests(IntFunction fa, IntFunction fb) { + static void NEByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5119,7 +5119,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void NEByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5142,7 +5142,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LEByte64VectorTests(IntFunction fa, IntFunction fb) { + static void LEByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5161,7 +5161,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LEByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5184,7 +5184,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GEByte64VectorTests(IntFunction fa, IntFunction fb) { + static void GEByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5203,7 +5203,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GEByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5226,7 +5226,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULTByte64VectorTests(IntFunction fa, IntFunction fb) { + static void ULTByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5245,7 +5245,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULTByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5268,7 +5268,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGTByte64VectorTests(IntFunction fa, IntFunction fb) { + static void UGTByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5287,7 +5287,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGTByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5310,7 +5310,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULEByte64VectorTests(IntFunction fa, IntFunction fb) { + static void ULEByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5329,7 +5329,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULEByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5352,7 +5352,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGEByte64VectorTests(IntFunction fa, IntFunction fb) { + static void UGEByteVector64Tests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5371,7 +5371,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGEByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5394,7 +5394,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5410,7 +5410,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5430,7 +5430,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByte64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5446,7 +5446,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByte64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTByteVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5466,7 +5466,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5482,7 +5482,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5502,7 +5502,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByte64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5518,7 +5518,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByte64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQByteVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5542,7 +5542,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByte64VectorTests(IntFunction fa, IntFunction fb, + static void blendByteVector64Tests(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5558,11 +5558,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Byte64VectorTests::blend); + assertArraysEquals(r, a, b, mask, ByteVector64Tests::blend); } @Test(dataProvider = "byteUnaryOpShuffleProvider") - static void RearrangeByte64VectorTests(IntFunction fa, + static void RearrangeByteVector64Tests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5579,7 +5579,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpShuffleMaskProvider") - static void RearrangeByte64VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeByteVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -5597,7 +5597,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void compressByte64VectorTests(IntFunction fa, + static void compressByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5615,7 +5615,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void expandByte64VectorTests(IntFunction fa, + static void expandByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5633,7 +5633,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void getByte64VectorTests(IntFunction fa) { + static void getByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5789,7 +5789,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastByte64VectorTests(IntFunction fa) { + static void BroadcastByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5803,7 +5803,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZeroByte64VectorTests(IntFunction fa) { + static void ZeroByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5828,7 +5828,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void sliceUnaryByte64VectorTests(IntFunction fa) { + static void sliceUnaryByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5839,7 +5839,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Byte64VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ByteVector64Tests::sliceUnary); } static byte[] sliceBinary(byte[] a, byte[] b, int origin, int idx) { @@ -5856,7 +5856,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void sliceBinaryByte64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryByteVector64TestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5869,7 +5869,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Byte64VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ByteVector64Tests::sliceBinary); } static byte[] slice(byte[] a, byte[] b, int origin, boolean[] mask, int idx) { @@ -5886,7 +5886,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void sliceByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5903,7 +5903,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Byte64VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ByteVector64Tests::slice); } static byte[] unsliceUnary(byte[] a, int origin, int idx) { @@ -5920,7 +5920,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void unsliceUnaryByte64VectorTests(IntFunction fa) { + static void unsliceUnaryByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5931,7 +5931,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Byte64VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ByteVector64Tests::unsliceUnary); } static byte[] unsliceBinary(byte[] a, byte[] b, int origin, int part, int idx) { @@ -5957,7 +5957,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void unsliceBinaryByte64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryByteVector64TestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5971,7 +5971,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Byte64VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ByteVector64Tests::unsliceBinary); } static byte[] unslice(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx) { @@ -6011,7 +6011,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void unsliceByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6028,7 +6028,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Byte64VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ByteVector64Tests::unslice); } static byte BITWISE_BLEND(byte a, byte b, byte c) { @@ -6040,7 +6040,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6055,11 +6055,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Byte64VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ByteVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6072,11 +6072,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Byte64VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ByteVector64Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6094,11 +6094,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Byte64VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ByteVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6109,11 +6109,11 @@ public class Byte64VectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Byte64VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ByteVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6124,11 +6124,11 @@ public class Byte64VectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Byte64VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6139,11 +6139,11 @@ public class Byte64VectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Byte64VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ByteVector64Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6154,11 +6154,11 @@ public class Byte64VectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Byte64VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVector64Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6173,11 +6173,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Byte64VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ByteVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte64VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector64TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6192,11 +6192,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Byte64VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ByteVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByte64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6207,11 +6207,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Byte64VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByte64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6222,11 +6222,11 @@ public class Byte64VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Byte64VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVector64Tests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByte64VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVector64TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6240,7 +6240,7 @@ public class Byte64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Byte64VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ByteVector64Tests::BITWISE_BLEND); } static byte NEG(byte a) { @@ -6252,7 +6252,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NEGByte64VectorTests(IntFunction fa) { + static void NEGByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6263,11 +6263,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::NEG); + assertArraysEquals(r, a, ByteVector64Tests::NEG); } @Test(dataProvider = "byteUnaryOpProvider") - static void negByte64VectorTests(IntFunction fa) { + static void negByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6278,11 +6278,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::neg); + assertArraysEquals(r, a, ByteVector64Tests::neg); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NEGMaskedByte64VectorTests(IntFunction fa, + static void NEGMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6296,7 +6296,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::NEG); + assertArraysEquals(r, a, mask, ByteVector64Tests::NEG); } static byte ABS(byte a) { @@ -6308,7 +6308,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ABSByte64VectorTests(IntFunction fa) { + static void ABSByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6319,11 +6319,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::ABS); + assertArraysEquals(r, a, ByteVector64Tests::ABS); } @Test(dataProvider = "byteUnaryOpProvider") - static void absByte64VectorTests(IntFunction fa) { + static void absByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6334,11 +6334,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::abs); + assertArraysEquals(r, a, ByteVector64Tests::abs); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ABSMaskedByte64VectorTests(IntFunction fa, + static void ABSMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6352,7 +6352,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::ABS); + assertArraysEquals(r, a, mask, ByteVector64Tests::ABS); } static byte NOT(byte a) { @@ -6364,7 +6364,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NOTByte64VectorTests(IntFunction fa) { + static void NOTByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6375,11 +6375,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::NOT); + assertArraysEquals(r, a, ByteVector64Tests::NOT); } @Test(dataProvider = "byteUnaryOpProvider") - static void notByte64VectorTests(IntFunction fa) { + static void notByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6390,11 +6390,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::not); + assertArraysEquals(r, a, ByteVector64Tests::not); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NOTMaskedByte64VectorTests(IntFunction fa, + static void NOTMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6408,7 +6408,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::NOT); + assertArraysEquals(r, a, mask, ByteVector64Tests::NOT); } static byte ZOMO(byte a) { @@ -6416,7 +6416,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZOMOByte64VectorTests(IntFunction fa) { + static void ZOMOByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6427,11 +6427,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::ZOMO); + assertArraysEquals(r, a, ByteVector64Tests::ZOMO); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ZOMOMaskedByte64VectorTests(IntFunction fa, + static void ZOMOMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6445,7 +6445,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::ZOMO); + assertArraysEquals(r, a, mask, ByteVector64Tests::ZOMO); } static byte BIT_COUNT(byte a) { @@ -6453,7 +6453,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BIT_COUNTByte64VectorTests(IntFunction fa) { + static void BIT_COUNTByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6464,11 +6464,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::BIT_COUNT); + assertArraysEquals(r, a, ByteVector64Tests::BIT_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void BIT_COUNTMaskedByte64VectorTests(IntFunction fa, + static void BIT_COUNTMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6482,7 +6482,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ByteVector64Tests::BIT_COUNT); } static byte TRAILING_ZEROS_COUNT(byte a) { @@ -6490,7 +6490,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void TRAILING_ZEROS_COUNTByte64VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6501,11 +6501,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVector64Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedByte64VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6519,7 +6519,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVector64Tests::TRAILING_ZEROS_COUNT); } static byte LEADING_ZEROS_COUNT(byte a) { @@ -6527,7 +6527,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LEADING_ZEROS_COUNTByte64VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6538,11 +6538,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVector64Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedByte64VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6556,7 +6556,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVector64Tests::LEADING_ZEROS_COUNT); } static byte REVERSE(byte a) { @@ -6564,7 +6564,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSEByte64VectorTests(IntFunction fa) { + static void REVERSEByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6575,11 +6575,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::REVERSE); + assertArraysEquals(r, a, ByteVector64Tests::REVERSE); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSEMaskedByte64VectorTests(IntFunction fa, + static void REVERSEMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6593,7 +6593,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::REVERSE); + assertArraysEquals(r, a, mask, ByteVector64Tests::REVERSE); } static byte REVERSE_BYTES(byte a) { @@ -6601,7 +6601,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSE_BYTESByte64VectorTests(IntFunction fa) { + static void REVERSE_BYTESByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6612,11 +6612,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ByteVector64Tests::REVERSE_BYTES); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedByte64VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedByteVector64Tests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6630,7 +6630,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Byte64VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ByteVector64Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6638,7 +6638,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandByte64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandByteVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6651,7 +6651,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::band); + assertArraysEquals(r, a, b, ByteVector64Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6659,7 +6659,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorByte64VectorTests(IntFunction fa, IntFunction fb) { + static void maskorByteVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6672,7 +6672,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::bor); + assertArraysEquals(r, a, b, ByteVector64Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6680,7 +6680,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorByte64VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorByteVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6693,7 +6693,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::bxor); + assertArraysEquals(r, a, b, ByteVector64Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6701,7 +6701,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotByte64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotByteVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6714,7 +6714,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::bandNot); + assertArraysEquals(r, a, b, ByteVector64Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6722,7 +6722,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqByte64VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqByteVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6735,7 +6735,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Byte64VectorTests::beq); + assertArraysEquals(r, a, b, ByteVector64Tests::beq); } static boolean unot(boolean a) { @@ -6743,7 +6743,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotByte64VectorTests(IntFunction fa) { + static void masknotByteVector64Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6754,7 +6754,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Byte64VectorTests::unot); + assertArraysEquals(r, a, ByteVector64Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6771,7 +6771,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongByte64VectorTests(IntFunction fa) { + static void maskFromToLongByteVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6785,7 +6785,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByte64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltByteVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6801,7 +6801,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByte64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqByteVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6817,7 +6817,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toIntArrayByte64VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayByteVector64TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6828,7 +6828,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toLongArrayByte64VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayByteVector64TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6839,7 +6839,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toDoubleArrayByte64VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayByteVector64TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6850,7 +6850,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toStringByte64VectorTestsSmokeTest(IntFunction fa) { + static void toStringByteVector64TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6863,7 +6863,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void hashCodeByte64VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeByteVector64TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6877,7 +6877,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void reinterpretAsBytesByte64VectorTestsSmokeTest(IntFunction fa) { + static void reinterpretAsBytesByteVector64TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6907,7 +6907,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceLongByte64VectorTests(IntFunction fa) { + static void ADDReduceLongByteVector64Tests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6923,7 +6923,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Byte64VectorTests::ADDReduceLong, Byte64VectorTests::ADDReduceAllLong); + ByteVector64Tests::ADDReduceLong, ByteVector64Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(byte[] a, int idx, boolean[] mask) { @@ -6946,7 +6946,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceLongByte64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongByteVector64TestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6964,11 +6964,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Byte64VectorTests::ADDReduceLongMasked, Byte64VectorTests::ADDReduceAllLongMasked); + ByteVector64Tests::ADDReduceLongMasked, ByteVector64Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastLongByte64VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongByteVector64TestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6979,7 +6979,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByte64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendByteVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6993,12 +6993,12 @@ public class Byte64VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Byte64VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVector64Tests::blend); } @Test(dataProvider = "byteUnaryOpSelectFromProvider") - static void SelectFromByte64VectorTests(IntFunction fa, + static void SelectFromByteVector64Tests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); byte[] order = fs.apply(a.length, SPECIES.length()); @@ -7014,7 +7014,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorByte64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorByteVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] idx = fc.apply(SPECIES.length()); @@ -7032,7 +7032,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpSelectFromMaskProvider") - static void SelectFromByte64VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromByteVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -7051,7 +7051,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousByte64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousByteVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7067,7 +7067,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringByte64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringByteVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7081,7 +7081,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsByte64VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsByteVector64TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7095,7 +7095,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsByte64VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsByteVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7111,7 +7111,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeByte64VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeByteVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7133,7 +7133,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountByte64VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountByteVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7144,7 +7144,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte64VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ByteVector64Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7158,7 +7158,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueByte64VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueByteVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7169,7 +7169,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte64VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ByteVector64Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7183,7 +7183,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueByte64VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueByteVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7194,11 +7194,11 @@ public class Byte64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Byte64VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ByteVector64Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressByte64VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressByteVector64TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7226,7 +7226,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeByte64VectorTestsSmokeTest(int offset) { + static void indexInRangeByteVector64TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7240,7 +7240,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongByte64VectorTestsSmokeTest(int offset) { + static void indexInRangeLongByteVector64TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7267,14 +7267,14 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundByte64VectorTestsSmokeTest(int length) { + static void loopBoundByteVector64TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongByte64VectorTestsSmokeTest(int _length) { + static void loopBoundLongByteVector64TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7282,21 +7282,21 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeByte64VectorTestsSmokeTest() { + static void ElementSizeByteVector64TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Byte.SIZE); } @Test - static void VectorShapeByte64VectorTestsSmokeTest() { + static void VectorShapeByteVector64TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_64_BIT)); } @Test - static void ShapeWithLanesByte64VectorTestsSmokeTest() { + static void ShapeWithLanesByteVector64TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(byte.class); @@ -7304,32 +7304,32 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeByte64VectorTestsSmokeTest() { + static void ElementTypeByteVector64TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementType() == byte.class); } @Test - static void SpeciesElementSizeByte64VectorTestsSmokeTest() { + static void SpeciesElementSizeByteVector64TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementSize() == Byte.SIZE); } @Test - static void VectorTypeByte64VectorTestsSmokeTest() { + static void VectorTypeByteVector64TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesByte64VectorTestsSmokeTest() { + static void WithLanesByteVector64TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(byte.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeByte64VectorTestsSmokeTest() { + static void WithShapeByteVector64TestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7337,7 +7337,7 @@ public class Byte64VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueByte64VectorTestsSmokeTest() { + static void MaskAllTrueByteVector64TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/ByteMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ByteVectorMaxLoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/ByteMaxVectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ByteVectorMaxLoadStoreTests.java index 76c6e9ff49f..93af9674906 100644 --- a/test/jdk/jdk/incubator/vector/ByteMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVectorMaxLoadStoreTests.java @@ -28,7 +28,7 @@ * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation * @run testng/othervm --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED - * -XX:-TieredCompilation ByteMaxVectorLoadStoreTests + * -XX:-TieredCompilation ByteVectorMaxLoadStoreTests * */ @@ -52,7 +52,7 @@ import java.util.List; import java.util.function.*; @Test -public class ByteMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ByteVectorMaxLoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_MAX; diff --git a/test/jdk/jdk/incubator/vector/ByteMaxVectorTests.java b/test/jdk/jdk/incubator/vector/ByteVectorMaxTests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/ByteMaxVectorTests.java rename to test/jdk/jdk/incubator/vector/ByteVectorMaxTests.java index ccbc2e078b9..c2d8188c090 100644 --- a/test/jdk/jdk/incubator/vector/ByteMaxVectorTests.java +++ b/test/jdk/jdk/incubator/vector/ByteVectorMaxTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ByteMaxVectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ByteVectorMaxTests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class ByteMaxVectorTests extends AbstractVectorTest { +public class ByteVectorMaxTests extends AbstractVectorTest { static final VectorSpecies SPECIES = ByteVector.SPECIES_MAX; @@ -1378,7 +1378,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { static final List> BYTE_SHUFFLE_GENERATORS = List.of( withToStringBi("shuffle[random]", (Integer l, Integer m) -> { byte[] a = new byte[l]; - int upper = Math.min(Byte.MAX_VALUE + 1, m); + int upper = m; for (int i = 0; i < 1; i++) { a[i] = (byte)RAND.nextInt(upper); } @@ -1711,7 +1711,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ADDByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1724,7 +1724,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::ADD); + assertArraysEquals(r, a, b, ByteVectorMaxTests::ADD); } static byte add(byte a, byte b) { @@ -1732,7 +1732,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void addByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void addByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1743,11 +1743,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ByteMaxVectorTests::add); + assertArraysEquals(r, a, b, ByteVectorMaxTests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1763,11 +1763,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::ADD); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void addByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1781,7 +1781,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::add); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::add); } static byte SUB(byte a, byte b) { @@ -1789,7 +1789,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void SUBByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUBByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1802,7 +1802,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::SUB); + assertArraysEquals(r, a, b, ByteVectorMaxTests::SUB); } static byte sub(byte a, byte b) { @@ -1810,7 +1810,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void subByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void subByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1821,11 +1821,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ByteMaxVectorTests::sub); + assertArraysEquals(r, a, b, ByteVectorMaxTests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void SUBByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1841,11 +1841,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::SUB); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::SUB); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void subByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1859,7 +1859,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::sub); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::sub); } static byte MUL(byte a, byte b) { @@ -1867,7 +1867,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MULByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MULByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1880,7 +1880,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::MUL); + assertArraysEquals(r, a, b, ByteVectorMaxTests::MUL); } static byte mul(byte a, byte b) { @@ -1888,7 +1888,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void mulByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1899,11 +1899,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ByteMaxVectorTests::mul); + assertArraysEquals(r, a, b, ByteVectorMaxTests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void MULByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1919,11 +1919,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::MUL); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::MUL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -1937,7 +1937,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::mul); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::mul); } static byte DIV(byte a, byte b) { @@ -1945,7 +1945,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void DIVByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void DIVByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1960,7 +1960,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::DIV); + assertArraysEquals(r, a, b, ByteVectorMaxTests::DIV); } static byte div(byte a, byte b) { @@ -1968,7 +1968,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void divByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void divByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -1983,11 +1983,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::div); + assertArraysEquals(r, a, b, ByteVectorMaxTests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void DIVByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2005,11 +2005,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::DIV); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::DIV); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void divByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2027,7 +2027,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::div); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::div); } static byte FIRST_NONZERO(byte a, byte b) { @@ -2035,7 +2035,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void FIRST_NONZEROByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2048,11 +2048,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ByteVectorMaxTests::FIRST_NONZERO); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void FIRST_NONZEROByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2068,7 +2068,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::FIRST_NONZERO); } static byte AND(byte a, byte b) { @@ -2076,7 +2076,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ANDByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2089,7 +2089,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::AND); + assertArraysEquals(r, a, b, ByteVectorMaxTests::AND); } static byte and(byte a, byte b) { @@ -2097,7 +2097,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void andByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void andByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2108,11 +2108,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ByteMaxVectorTests::and); + assertArraysEquals(r, a, b, ByteVectorMaxTests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2128,7 +2128,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::AND); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::AND); } static byte AND_NOT(byte a, byte b) { @@ -2136,7 +2136,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void AND_NOTByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2149,11 +2149,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::AND_NOT); + assertArraysEquals(r, a, b, ByteVectorMaxTests::AND_NOT); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void AND_NOTByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2169,7 +2169,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::AND_NOT); } static byte OR(byte a, byte b) { @@ -2177,7 +2177,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ORByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2190,7 +2190,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::OR); + assertArraysEquals(r, a, b, ByteVectorMaxTests::OR); } static byte or(byte a, byte b) { @@ -2198,7 +2198,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void orByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void orByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2209,11 +2209,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ByteMaxVectorTests::or); + assertArraysEquals(r, a, b, ByteVectorMaxTests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2229,7 +2229,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::OR); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::OR); } static byte XOR(byte a, byte b) { @@ -2237,7 +2237,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void XORByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void XORByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2250,11 +2250,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::XOR); + assertArraysEquals(r, a, b, ByteVectorMaxTests::XOR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void XORByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2270,11 +2270,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::XOR); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::XOR); } @Test(dataProvider = "byteBinaryOpProvider") - static void addByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2284,11 +2284,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::add); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void addByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2301,11 +2301,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ByteVectorMaxTests::add); } @Test(dataProvider = "byteBinaryOpProvider") - static void subByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2315,11 +2315,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::sub); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void subByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2332,11 +2332,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ByteVectorMaxTests::sub); } @Test(dataProvider = "byteBinaryOpProvider") - static void mulByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2346,11 +2346,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::mul); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void mulByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2363,11 +2363,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ByteVectorMaxTests::mul); } @Test(dataProvider = "byteBinaryOpProvider") - static void divByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2379,11 +2379,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::div); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void divByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2398,11 +2398,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ByteVectorMaxTests::div); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2412,11 +2412,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void orByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2426,11 +2426,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::or); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::or); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2443,11 +2443,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ByteVectorMaxTests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ANDByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2457,11 +2457,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void andByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2471,11 +2471,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::and); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::and); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ANDByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2488,11 +2488,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ByteVectorMaxTests::AND); } @Test(dataProvider = "byteBinaryOpProvider") - static void ORByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORByteVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2502,11 +2502,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, ByteMaxVectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ByteVectorMaxTests::OR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ORByteMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORByteVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2519,11 +2519,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, ByteMaxVectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVectorMaxTests::OR); } @Test(dataProvider = "byteBinaryOpProvider") - static void ADDByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDByteVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2533,11 +2533,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, ByteMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ByteVectorMaxTests::ADD); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ADDByteMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDByteVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2550,7 +2550,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, ByteMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVectorMaxTests::ADD); } static byte LSHL(byte a, byte b) { @@ -2558,7 +2558,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LSHLByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2571,11 +2571,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::LSHL); + assertArraysEquals(r, a, b, ByteVectorMaxTests::LSHL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2591,7 +2591,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::LSHL); } static byte ASHR(byte a, byte b) { @@ -2599,7 +2599,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ASHRByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2612,11 +2612,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::ASHR); + assertArraysEquals(r, a, b, ByteVectorMaxTests::ASHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2632,7 +2632,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::ASHR); } static byte LSHR(byte a, byte b) { @@ -2640,7 +2640,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LSHRByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2653,11 +2653,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::LSHR); + assertArraysEquals(r, a, b, ByteVectorMaxTests::LSHR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2673,7 +2673,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::LSHR); } static byte LSHL_unary(byte a, byte b) { @@ -2681,7 +2681,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHLByteMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLByteVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2693,11 +2693,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ByteVectorMaxTests::LSHL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHLByteMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLByteVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2712,7 +2712,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVectorMaxTests::LSHL_unary); } static byte LSHR_unary(byte a, byte b) { @@ -2720,7 +2720,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void LSHRByteMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRByteVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2732,11 +2732,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ByteVectorMaxTests::LSHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void LSHRByteMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRByteVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2751,7 +2751,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVectorMaxTests::LSHR_unary); } static byte ASHR_unary(byte a, byte b) { @@ -2759,7 +2759,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ASHRByteMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRByteVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2771,11 +2771,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ByteVectorMaxTests::ASHR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ASHRByteMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRByteVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2790,7 +2790,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVectorMaxTests::ASHR_unary); } static byte ROR(byte a, byte b) { @@ -2798,7 +2798,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void RORByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2811,11 +2811,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::ROR); + assertArraysEquals(r, a, b, ByteVectorMaxTests::ROR); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2831,7 +2831,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::ROR); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::ROR); } static byte ROL(byte a, byte b) { @@ -2839,7 +2839,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ROLByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2852,11 +2852,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::ROL); + assertArraysEquals(r, a, b, ByteVectorMaxTests::ROL); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2872,7 +2872,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::ROL); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::ROL); } static byte ROR_unary(byte a, byte b) { @@ -2880,7 +2880,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void RORByteMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORByteVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2892,11 +2892,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ByteVectorMaxTests::ROR_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void RORByteMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORByteVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2911,7 +2911,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVectorMaxTests::ROR_unary); } static byte ROL_unary(byte a, byte b) { @@ -2919,7 +2919,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void ROLByteMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLByteVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2931,11 +2931,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ByteVectorMaxTests::ROL_unary); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void ROLByteMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLByteVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -2950,14 +2950,14 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ByteVectorMaxTests::ROL_unary); } static byte LSHR_binary_const(byte a) { return (byte)(((a & 0xFF) >>> CONST_SHIFT)); } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHRByteMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRByteVectorMaxTestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2968,11 +2968,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ByteMaxVectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ByteVectorMaxTests::LSHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHRByteMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRByteVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -2986,7 +2986,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVectorMaxTests::LSHR_binary_const); } static byte LSHL_binary_const(byte a) { @@ -2994,7 +2994,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LSHLByteMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLByteVectorMaxTestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3005,11 +3005,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ByteMaxVectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ByteVectorMaxTests::LSHL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LSHLByteMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLByteVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3023,7 +3023,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVectorMaxTests::LSHL_binary_const); } static byte ASHR_binary_const(byte a) { @@ -3031,7 +3031,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ASHRByteMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRByteVectorMaxTestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3042,11 +3042,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ByteMaxVectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ByteVectorMaxTests::ASHR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ASHRByteMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRByteVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3060,7 +3060,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVectorMaxTests::ASHR_binary_const); } static byte ROR_binary_const(byte a) { @@ -3068,7 +3068,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void RORByteMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void RORByteVectorMaxTestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3079,11 +3079,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ByteMaxVectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ByteVectorMaxTests::ROR_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void RORByteMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORByteVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3097,7 +3097,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ByteVectorMaxTests::ROR_binary_const); } static byte ROL_binary_const(byte a) { @@ -3105,7 +3105,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ROLByteMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void ROLByteVectorMaxTestsScalarShiftConst(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3116,11 +3116,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ByteMaxVectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ByteVectorMaxTests::ROL_binary_const); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ROLByteMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLByteVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3134,14 +3134,14 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ByteVectorMaxTests::ROL_binary_const); } static ByteVector bv_MIN = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MINByteMaxVectorTestsWithMemOp(IntFunction fa) { + static void MINByteVectorMaxTestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3152,13 +3152,13 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, ByteMaxVectorTests::MIN); + assertArraysEquals(r, a, (byte)10, ByteVectorMaxTests::MIN); } static ByteVector bv_min = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void minByteMaxVectorTestsWithMemOp(IntFunction fa) { + static void minByteVectorMaxTestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3169,13 +3169,13 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, ByteMaxVectorTests::min); + assertArraysEquals(r, a, (byte)10, ByteVectorMaxTests::min); } static ByteVector bv_MIN_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINByteMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINByteVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3188,13 +3188,13 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, ByteMaxVectorTests::MIN); + assertArraysEquals(r, a, (byte)10, mask, ByteVectorMaxTests::MIN); } static ByteVector bv_MAX = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void MAXByteMaxVectorTestsWithMemOp(IntFunction fa) { + static void MAXByteVectorMaxTestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3205,13 +3205,13 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, ByteMaxVectorTests::MAX); + assertArraysEquals(r, a, (byte)10, ByteVectorMaxTests::MAX); } static ByteVector bv_max = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpProvider") - static void maxByteMaxVectorTestsWithMemOp(IntFunction fa) { + static void maxByteVectorMaxTestsWithMemOp(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3222,13 +3222,13 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, ByteMaxVectorTests::max); + assertArraysEquals(r, a, (byte)10, ByteVectorMaxTests::max); } static ByteVector bv_MAX_M = ByteVector.broadcast(SPECIES, (byte)10); @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXByteMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXByteVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3241,7 +3241,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (byte)10, mask, ByteMaxVectorTests::MAX); + assertArraysEquals(r, a, (byte)10, mask, ByteVectorMaxTests::MAX); } static byte MIN(byte a, byte b) { @@ -3249,7 +3249,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MINByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3262,7 +3262,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::MIN); + assertArraysEquals(r, a, b, ByteVectorMaxTests::MIN); } static byte min(byte a, byte b) { @@ -3270,7 +3270,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void minByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void minByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3281,7 +3281,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ByteMaxVectorTests::min); + assertArraysEquals(r, a, b, ByteVectorMaxTests::min); } static byte MAX(byte a, byte b) { @@ -3289,7 +3289,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MAXByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3302,7 +3302,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::MAX); + assertArraysEquals(r, a, b, ByteVectorMaxTests::MAX); } static byte max(byte a, byte b) { @@ -3310,7 +3310,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maxByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3321,7 +3321,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ByteMaxVectorTests::max); + assertArraysEquals(r, a, b, ByteVectorMaxTests::max); } static byte UMIN(byte a, byte b) { @@ -3329,7 +3329,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMINByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UMINByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3342,11 +3342,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::UMIN); + assertArraysEquals(r, a, b, ByteVectorMaxTests::UMIN); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMINByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3362,7 +3362,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::UMIN); } static byte UMAX(byte a, byte b) { @@ -3370,7 +3370,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void UMAXByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UMAXByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3383,11 +3383,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::UMAX); + assertArraysEquals(r, a, b, ByteVectorMaxTests::UMAX); } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void UMAXByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3403,7 +3403,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::UMAX); } static byte SADD(byte a, byte b) { @@ -3411,7 +3411,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SADDByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SADDByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3424,11 +3424,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::SADD); + assertArraysEquals(r, a, b, ByteVectorMaxTests::SADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SADDByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3444,7 +3444,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::SADD); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::SADD); } static byte SSUB(byte a, byte b) { @@ -3452,7 +3452,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SSUBByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SSUBByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3465,11 +3465,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::SSUB); + assertArraysEquals(r, a, b, ByteVectorMaxTests::SSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SSUBByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3485,7 +3485,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::SSUB); } static byte SUADD(byte a, byte b) { @@ -3493,7 +3493,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUADDByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUADDByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3506,11 +3506,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::SUADD); + assertArraysEquals(r, a, b, ByteVectorMaxTests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUADDByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3526,7 +3526,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::SUADD); } static byte SUSUB(byte a, byte b) { @@ -3534,7 +3534,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingBinaryOpProvider") - static void SUSUBByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3547,11 +3547,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::SUSUB); + assertArraysEquals(r, a, b, ByteVectorMaxTests::SUSUB); } @Test(dataProvider = "byteSaturatingBinaryOpMaskProvider") - static void SUSUBByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3567,11 +3567,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::SUSUB); } @Test(dataProvider = "byteBinaryOpProvider") - static void MINByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3581,11 +3581,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::MIN); } @Test(dataProvider = "byteBinaryOpProvider") - static void minByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3595,11 +3595,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::min); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::min); } @Test(dataProvider = "byteBinaryOpProvider") - static void MAXByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3609,11 +3609,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::MAX); } @Test(dataProvider = "byteBinaryOpProvider") - static void maxByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -3623,10 +3623,10 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::max); + assertBroadcastArraysEquals(r, a, b, ByteVectorMaxTests::max); } @Test(dataProvider = "byteSaturatingBinaryOpAssocProvider") - static void SUADDAssocByteMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocByteVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -3643,11 +3643,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, ByteMaxVectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ByteVectorMaxTests::SUADD); } @Test(dataProvider = "byteSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -3668,7 +3668,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ByteMaxVectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ByteVectorMaxTests::SUADD); } static byte ANDReduce(byte[] a, int idx) { @@ -3690,7 +3690,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ANDReduceByteMaxVectorTests(IntFunction fa) { + static void ANDReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3706,7 +3706,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::ANDReduce, ByteMaxVectorTests::ANDReduceAll); + ByteVectorMaxTests::ANDReduce, ByteVectorMaxTests::ANDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3752,7 +3752,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ANDReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3770,7 +3770,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::ANDReduceMasked, ByteMaxVectorTests::ANDReduceAllMasked); + ByteVectorMaxTests::ANDReduceMasked, ByteVectorMaxTests::ANDReduceAllMasked); } static byte ORReduce(byte[] a, int idx) { @@ -3792,7 +3792,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ORReduceByteMaxVectorTests(IntFunction fa) { + static void ORReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3808,7 +3808,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::ORReduce, ByteMaxVectorTests::ORReduceAll); + ByteVectorMaxTests::ORReduce, ByteVectorMaxTests::ORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3854,7 +3854,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ORReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3872,7 +3872,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::ORReduceMasked, ByteMaxVectorTests::ORReduceAllMasked); + ByteVectorMaxTests::ORReduceMasked, ByteVectorMaxTests::ORReduceAllMasked); } static byte XORReduce(byte[] a, int idx) { @@ -3894,7 +3894,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void XORReduceByteMaxVectorTests(IntFunction fa) { + static void XORReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -3910,7 +3910,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::XORReduce, ByteMaxVectorTests::XORReduceAll); + ByteVectorMaxTests::XORReduce, ByteVectorMaxTests::XORReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -3956,7 +3956,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void XORReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3974,7 +3974,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::XORReduceMasked, ByteMaxVectorTests::XORReduceAllMasked); + ByteVectorMaxTests::XORReduceMasked, ByteVectorMaxTests::XORReduceAllMasked); } static byte ADDReduce(byte[] a, int idx) { @@ -3996,7 +3996,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceByteMaxVectorTests(IntFunction fa) { + static void ADDReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4012,7 +4012,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::ADDReduce, ByteMaxVectorTests::ADDReduceAll); + ByteVectorMaxTests::ADDReduce, ByteVectorMaxTests::ADDReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4058,7 +4058,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4076,7 +4076,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::ADDReduceMasked, ByteMaxVectorTests::ADDReduceAllMasked); + ByteVectorMaxTests::ADDReduceMasked, ByteVectorMaxTests::ADDReduceAllMasked); } static byte MULReduce(byte[] a, int idx) { @@ -4098,7 +4098,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MULReduceByteMaxVectorTests(IntFunction fa) { + static void MULReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4114,7 +4114,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::MULReduce, ByteMaxVectorTests::MULReduceAll); + ByteVectorMaxTests::MULReduce, ByteVectorMaxTests::MULReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4160,7 +4160,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MULReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4178,7 +4178,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::MULReduceMasked, ByteMaxVectorTests::MULReduceAllMasked); + ByteVectorMaxTests::MULReduceMasked, ByteVectorMaxTests::MULReduceAllMasked); } static byte MINReduce(byte[] a, int idx) { @@ -4200,7 +4200,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MINReduceByteMaxVectorTests(IntFunction fa) { + static void MINReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4216,7 +4216,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::MINReduce, ByteMaxVectorTests::MINReduceAll); + ByteVectorMaxTests::MINReduce, ByteVectorMaxTests::MINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4262,7 +4262,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MINReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4280,7 +4280,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::MINReduceMasked, ByteMaxVectorTests::MINReduceAllMasked); + ByteVectorMaxTests::MINReduceMasked, ByteVectorMaxTests::MINReduceAllMasked); } static byte MAXReduce(byte[] a, int idx) { @@ -4302,7 +4302,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void MAXReduceByteMaxVectorTests(IntFunction fa) { + static void MAXReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4318,7 +4318,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::MAXReduce, ByteMaxVectorTests::MAXReduceAll); + ByteVectorMaxTests::MAXReduce, ByteVectorMaxTests::MAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4364,7 +4364,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void MAXReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4382,7 +4382,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::MAXReduceMasked, ByteMaxVectorTests::MAXReduceAllMasked); + ByteVectorMaxTests::MAXReduceMasked, ByteVectorMaxTests::MAXReduceAllMasked); } static byte UMINReduce(byte[] a, int idx) { @@ -4404,7 +4404,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMINReduceByteMaxVectorTests(IntFunction fa) { + static void UMINReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4420,7 +4420,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::UMINReduce, ByteMaxVectorTests::UMINReduceAll); + ByteVectorMaxTests::UMINReduce, ByteVectorMaxTests::UMINReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4466,7 +4466,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMINReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4484,7 +4484,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::UMINReduceMasked, ByteMaxVectorTests::UMINReduceAllMasked); + ByteVectorMaxTests::UMINReduceMasked, ByteVectorMaxTests::UMINReduceAllMasked); } static byte UMAXReduce(byte[] a, int idx) { @@ -4506,7 +4506,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void UMAXReduceByteMaxVectorTests(IntFunction fa) { + static void UMAXReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4522,7 +4522,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::UMAXReduce, ByteMaxVectorTests::UMAXReduceAll); + ByteVectorMaxTests::UMAXReduce, ByteVectorMaxTests::UMAXReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4568,7 +4568,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void UMAXReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4586,7 +4586,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::UMAXReduceMasked, ByteMaxVectorTests::UMAXReduceAllMasked); + ByteVectorMaxTests::UMAXReduceMasked, ByteVectorMaxTests::UMAXReduceAllMasked); } static byte FIRST_NONZEROReduce(byte[] a, int idx) { @@ -4608,7 +4608,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void FIRST_NONZEROReduceByteMaxVectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4624,7 +4624,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::FIRST_NONZEROReduce, ByteMaxVectorTests::FIRST_NONZEROReduceAll); + ByteVectorMaxTests::FIRST_NONZEROReduce, ByteVectorMaxTests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "byteUnaryOpProvider") @@ -4670,7 +4670,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void FIRST_NONZEROReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4688,7 +4688,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::FIRST_NONZEROReduceMasked, ByteMaxVectorTests::FIRST_NONZEROReduceAllMasked); + ByteVectorMaxTests::FIRST_NONZEROReduceMasked, ByteVectorMaxTests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4701,7 +4701,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueByteMaxVectorTests(IntFunction fm) { + static void anyTrueByteVectorMaxTests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4712,7 +4712,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, ByteMaxVectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ByteVectorMaxTests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4725,7 +4725,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueByteMaxVectorTests(IntFunction fm) { + static void allTrueByteVectorMaxTests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4736,7 +4736,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, ByteMaxVectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ByteVectorMaxTests::allTrue); } static byte SUADDReduce(byte[] a, int idx) { @@ -4758,7 +4758,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSaturatingUnaryOpProvider") - static void SUADDReduceByteMaxVectorTests(IntFunction fa) { + static void SUADDReduceByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); byte ra = 0; @@ -4774,7 +4774,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ByteMaxVectorTests::SUADDReduce, ByteMaxVectorTests::SUADDReduceAll); + ByteVectorMaxTests::SUADDReduce, ByteVectorMaxTests::SUADDReduceAll); } @Test(dataProvider = "byteSaturatingUnaryOpProvider") @@ -4819,7 +4819,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "byteSaturatingUnaryOpMaskProvider") - static void SUADDReduceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4837,11 +4837,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::SUADDReduceMasked, ByteMaxVectorTests::SUADDReduceAllMasked); + ByteVectorMaxTests::SUADDReduceMasked, ByteVectorMaxTests::SUADDReduceAllMasked); } @Test(dataProvider = "byteBinaryOpProvider") - static void withByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void withByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -4864,7 +4864,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_DEFAULTByteMaxVectorTests(IntFunction fa) { + static void IS_DEFAULTByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4881,7 +4881,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_DEFAULTMaskedByteMaxVectorTests(IntFunction fa, + static void IS_DEFAULTMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4905,7 +4905,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpProvider") - static void IS_NEGATIVEByteMaxVectorTests(IntFunction fa) { + static void IS_NEGATIVEByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4922,7 +4922,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTestOpMaskProvider") - static void IS_NEGATIVEMaskedByteMaxVectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4942,7 +4942,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LTByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4961,7 +4961,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ltByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -4980,7 +4980,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5003,7 +5003,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GTByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GTByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5022,7 +5022,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GTByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5045,7 +5045,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void EQByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5064,7 +5064,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void eqByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5083,7 +5083,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5106,7 +5106,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void NEByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void NEByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5125,7 +5125,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void NEByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5148,7 +5148,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LEByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LEByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5167,7 +5167,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LEByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5190,7 +5190,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void GEByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GEByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5209,7 +5209,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void GEByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5232,7 +5232,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULTByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ULTByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5251,7 +5251,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULTByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5274,7 +5274,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGTByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UGTByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5293,7 +5293,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGTByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5316,7 +5316,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ULEByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ULEByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5335,7 +5335,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void ULEByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5358,7 +5358,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void UGEByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UGEByteVectorMaxTests(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5377,7 +5377,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void UGEByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5400,7 +5400,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5416,7 +5416,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5436,7 +5436,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void LTByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTByteVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5452,7 +5452,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void LTByteMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTByteVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5472,7 +5472,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5488,7 +5488,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5508,7 +5508,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void EQByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQByteVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5524,7 +5524,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpMaskProvider") - static void EQByteMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQByteVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5548,7 +5548,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByteMaxVectorTests(IntFunction fa, IntFunction fb, + static void blendByteVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5564,11 +5564,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::blend); + assertArraysEquals(r, a, b, mask, ByteVectorMaxTests::blend); } @Test(dataProvider = "byteUnaryOpShuffleProvider") - static void RearrangeByteMaxVectorTests(IntFunction fa, + static void RearrangeByteVectorMaxTests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5585,7 +5585,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpShuffleMaskProvider") - static void RearrangeByteMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeByteVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -5603,7 +5603,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void compressByteMaxVectorTests(IntFunction fa, + static void compressByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5621,7 +5621,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void expandByteMaxVectorTests(IntFunction fa, + static void expandByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5639,7 +5639,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void getByteMaxVectorTests(IntFunction fa) { + static void getByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -5795,7 +5795,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastByteMaxVectorTests(IntFunction fa) { + static void BroadcastByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5809,7 +5809,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZeroByteMaxVectorTests(IntFunction fa) { + static void ZeroByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5834,7 +5834,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void sliceUnaryByteMaxVectorTests(IntFunction fa) { + static void sliceUnaryByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5845,7 +5845,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, ByteMaxVectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ByteVectorMaxTests::sliceUnary); } static byte[] sliceBinary(byte[] a, byte[] b, int origin, int idx) { @@ -5862,7 +5862,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void sliceBinaryByteMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryByteVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5875,7 +5875,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, ByteMaxVectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ByteVectorMaxTests::sliceBinary); } static byte[] slice(byte[] a, byte[] b, int origin, boolean[] mask, int idx) { @@ -5892,7 +5892,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void sliceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -5909,7 +5909,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, ByteMaxVectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ByteVectorMaxTests::slice); } static byte[] unsliceUnary(byte[] a, int origin, int idx) { @@ -5926,7 +5926,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void unsliceUnaryByteMaxVectorTests(IntFunction fa) { + static void unsliceUnaryByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5937,7 +5937,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, ByteMaxVectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ByteVectorMaxTests::unsliceUnary); } static byte[] unsliceBinary(byte[] a, byte[] b, int origin, int part, int idx) { @@ -5963,7 +5963,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpProvider") - static void unsliceBinaryByteMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryByteVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -5977,7 +5977,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, ByteMaxVectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ByteVectorMaxTests::unsliceBinary); } static byte[] unslice(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx) { @@ -6017,7 +6017,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void unsliceByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6034,7 +6034,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, ByteMaxVectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ByteVectorMaxTests::unslice); } static byte BITWISE_BLEND(byte a, byte b, byte c) { @@ -6046,7 +6046,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByteMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6061,11 +6061,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, ByteMaxVectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ByteVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByteMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6078,11 +6078,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, ByteMaxVectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ByteVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByteMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6100,11 +6100,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, ByteMaxVectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ByteVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6115,11 +6115,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ByteVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByteMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6130,11 +6130,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6145,11 +6145,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { ByteVector bv = ByteVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ByteVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByteMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6160,11 +6160,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { ByteVector cv = ByteVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ByteVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6179,11 +6179,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, ByteMaxVectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ByteVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByteMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVectorMaxTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, ByteMaxVectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ByteVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void BITWISE_BLENDByteMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDByteVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6213,11 +6213,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "byteTernaryOpProvider") - static void bitwiseBlendByteMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendByteVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] c = fc.apply(SPECIES.length()); @@ -6228,11 +6228,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ByteVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "byteTernaryOpMaskProvider") - static void BITWISE_BLENDByteMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDByteVectorMaxTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6246,7 +6246,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ByteMaxVectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ByteVectorMaxTests::BITWISE_BLEND); } static byte NEG(byte a) { @@ -6258,7 +6258,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NEGByteMaxVectorTests(IntFunction fa) { + static void NEGByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6269,11 +6269,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::NEG); + assertArraysEquals(r, a, ByteVectorMaxTests::NEG); } @Test(dataProvider = "byteUnaryOpProvider") - static void negByteMaxVectorTests(IntFunction fa) { + static void negByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6284,11 +6284,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::neg); + assertArraysEquals(r, a, ByteVectorMaxTests::neg); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NEGMaskedByteMaxVectorTests(IntFunction fa, + static void NEGMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6302,7 +6302,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::NEG); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::NEG); } static byte ABS(byte a) { @@ -6314,7 +6314,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ABSByteMaxVectorTests(IntFunction fa) { + static void ABSByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6325,11 +6325,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::ABS); + assertArraysEquals(r, a, ByteVectorMaxTests::ABS); } @Test(dataProvider = "byteUnaryOpProvider") - static void absByteMaxVectorTests(IntFunction fa) { + static void absByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6340,11 +6340,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::abs); + assertArraysEquals(r, a, ByteVectorMaxTests::abs); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ABSMaskedByteMaxVectorTests(IntFunction fa, + static void ABSMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6358,7 +6358,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::ABS); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::ABS); } static byte NOT(byte a) { @@ -6370,7 +6370,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void NOTByteMaxVectorTests(IntFunction fa) { + static void NOTByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6381,11 +6381,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::NOT); + assertArraysEquals(r, a, ByteVectorMaxTests::NOT); } @Test(dataProvider = "byteUnaryOpProvider") - static void notByteMaxVectorTests(IntFunction fa) { + static void notByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6396,11 +6396,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::not); + assertArraysEquals(r, a, ByteVectorMaxTests::not); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void NOTMaskedByteMaxVectorTests(IntFunction fa, + static void NOTMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6414,7 +6414,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::NOT); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::NOT); } static byte ZOMO(byte a) { @@ -6422,7 +6422,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ZOMOByteMaxVectorTests(IntFunction fa) { + static void ZOMOByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6433,11 +6433,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::ZOMO); + assertArraysEquals(r, a, ByteVectorMaxTests::ZOMO); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ZOMOMaskedByteMaxVectorTests(IntFunction fa, + static void ZOMOMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6451,7 +6451,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::ZOMO); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::ZOMO); } static byte BIT_COUNT(byte a) { @@ -6459,7 +6459,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void BIT_COUNTByteMaxVectorTests(IntFunction fa) { + static void BIT_COUNTByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6470,11 +6470,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::BIT_COUNT); + assertArraysEquals(r, a, ByteVectorMaxTests::BIT_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void BIT_COUNTMaskedByteMaxVectorTests(IntFunction fa, + static void BIT_COUNTMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6488,7 +6488,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::BIT_COUNT); } static byte TRAILING_ZEROS_COUNT(byte a) { @@ -6496,7 +6496,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void TRAILING_ZEROS_COUNTByteMaxVectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6507,11 +6507,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVectorMaxTests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedByteMaxVectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6525,7 +6525,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::TRAILING_ZEROS_COUNT); } static byte LEADING_ZEROS_COUNT(byte a) { @@ -6533,7 +6533,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void LEADING_ZEROS_COUNTByteMaxVectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6544,11 +6544,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ByteVectorMaxTests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedByteMaxVectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6562,7 +6562,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::LEADING_ZEROS_COUNT); } static byte REVERSE(byte a) { @@ -6570,7 +6570,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSEByteMaxVectorTests(IntFunction fa) { + static void REVERSEByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6581,11 +6581,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::REVERSE); + assertArraysEquals(r, a, ByteVectorMaxTests::REVERSE); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSEMaskedByteMaxVectorTests(IntFunction fa, + static void REVERSEMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6599,7 +6599,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::REVERSE); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::REVERSE); } static byte REVERSE_BYTES(byte a) { @@ -6607,7 +6607,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void REVERSE_BYTESByteMaxVectorTests(IntFunction fa) { + static void REVERSE_BYTESByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6618,11 +6618,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ByteVectorMaxTests::REVERSE_BYTES); } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedByteMaxVectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedByteVectorMaxTests(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] r = fr.apply(SPECIES.length()); @@ -6636,7 +6636,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ByteMaxVectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ByteVectorMaxTests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6644,7 +6644,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandByteVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6657,7 +6657,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::band); + assertArraysEquals(r, a, b, ByteVectorMaxTests::band); } static boolean bor(boolean a, boolean b) { @@ -6665,7 +6665,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskorByteVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6678,7 +6678,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::bor); + assertArraysEquals(r, a, b, ByteVectorMaxTests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6686,7 +6686,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskxorByteVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6699,7 +6699,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::bxor); + assertArraysEquals(r, a, b, ByteVectorMaxTests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6707,7 +6707,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotByteVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6720,7 +6720,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::bandNot); + assertArraysEquals(r, a, b, ByteVectorMaxTests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6728,7 +6728,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskeqByteVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6741,7 +6741,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ByteMaxVectorTests::beq); + assertArraysEquals(r, a, b, ByteVectorMaxTests::beq); } static boolean unot(boolean a) { @@ -6749,7 +6749,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotByteMaxVectorTests(IntFunction fa) { + static void masknotByteVectorMaxTests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6760,7 +6760,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ByteMaxVectorTests::unot); + assertArraysEquals(r, a, ByteVectorMaxTests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6777,7 +6777,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongByteMaxVectorTests(IntFunction fa) { + static void maskFromToLongByteVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6791,7 +6791,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void ltByteMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltByteVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6807,7 +6807,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteCompareOpProvider") - static void eqByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqByteVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6823,7 +6823,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toIntArrayByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayByteVectorMaxTestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6834,7 +6834,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toLongArrayByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayByteVectorMaxTestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6845,7 +6845,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toDoubleArrayByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayByteVectorMaxTestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6856,7 +6856,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void toStringByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void toStringByteVectorMaxTestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6869,7 +6869,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void hashCodeByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void hashCodeByteVectorMaxTestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6883,7 +6883,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void reinterpretAsBytesByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void reinterpretAsBytesByteVectorMaxTestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6913,7 +6913,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpProvider") - static void ADDReduceLongByteMaxVectorTests(IntFunction fa) { + static void ADDReduceLongByteVectorMaxTests(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6929,7 +6929,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - ByteMaxVectorTests::ADDReduceLong, ByteMaxVectorTests::ADDReduceAllLong); + ByteVectorMaxTests::ADDReduceLong, ByteVectorMaxTests::ADDReduceAllLong); } static long ADDReduceLongMasked(byte[] a, int idx, boolean[] mask) { @@ -6952,7 +6952,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpMaskProvider") - static void ADDReduceLongByteMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongByteVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6970,11 +6970,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - ByteMaxVectorTests::ADDReduceLongMasked, ByteMaxVectorTests::ADDReduceAllLongMasked); + ByteVectorMaxTests::ADDReduceLongMasked, ByteVectorMaxTests::ADDReduceAllLongMasked); } @Test(dataProvider = "byteUnaryOpProvider") - static void BroadcastLongByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongByteVectorMaxTestsSmokeTest(IntFunction fa) { byte[] a = fa.apply(SPECIES.length()); byte[] r = new byte[a.length]; @@ -6985,7 +6985,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteBinaryOpMaskProvider") - static void blendByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendByteVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); @@ -6999,12 +6999,12 @@ public class ByteMaxVectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, ByteMaxVectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ByteVectorMaxTests::blend); } @Test(dataProvider = "byteUnaryOpSelectFromProvider") - static void SelectFromByteMaxVectorTests(IntFunction fa, + static void SelectFromByteVectorMaxTests(IntFunction fa, BiFunction fs) { byte[] a = fa.apply(SPECIES.length()); byte[] order = fs.apply(a.length, SPECIES.length()); @@ -7020,7 +7020,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorByteMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorByteVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { byte[] a = fa.apply(SPECIES.length()); byte[] b = fb.apply(SPECIES.length()); byte[] idx = fc.apply(SPECIES.length()); @@ -7038,7 +7038,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "byteUnaryOpSelectFromMaskProvider") - static void SelectFromByteMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromByteVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { byte[] a = fa.apply(SPECIES.length()); @@ -7057,7 +7057,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousByteMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousByteVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7073,7 +7073,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringByteMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringByteVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7087,7 +7087,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsByteMaxVectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsByteVectorMaxTestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7101,7 +7101,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsByteMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsByteVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7117,7 +7117,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeByteVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7139,7 +7139,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountByteVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7150,7 +7150,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, ByteMaxVectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ByteVectorMaxTests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7164,7 +7164,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueByteVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7175,7 +7175,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, ByteMaxVectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ByteVectorMaxTests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7189,7 +7189,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueByteVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7200,11 +7200,11 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, ByteMaxVectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ByteVectorMaxTests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressByteMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskCompressByteVectorMaxTestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7232,7 +7232,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeByteMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeByteVectorMaxTestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7246,7 +7246,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongByteMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeLongByteVectorMaxTestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7273,14 +7273,14 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundByteMaxVectorTestsSmokeTest(int length) { + static void loopBoundByteVectorMaxTestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongByteMaxVectorTestsSmokeTest(int _length) { + static void loopBoundLongByteVectorMaxTestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7288,21 +7288,21 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test - static void ElementSizeByteMaxVectorTestsSmokeTest() { + static void ElementSizeByteVectorMaxTestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Byte.SIZE); } @Test - static void VectorShapeByteMaxVectorTestsSmokeTest() { + static void VectorShapeByteVectorMaxTestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_Max_BIT)); } @Test - static void ShapeWithLanesByteMaxVectorTestsSmokeTest() { + static void ShapeWithLanesByteVectorMaxTestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(byte.class); @@ -7310,32 +7310,32 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test - static void ElementTypeByteMaxVectorTestsSmokeTest() { + static void ElementTypeByteVectorMaxTestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementType() == byte.class); } @Test - static void SpeciesElementSizeByteMaxVectorTestsSmokeTest() { + static void SpeciesElementSizeByteVectorMaxTestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().elementSize() == Byte.SIZE); } @Test - static void VectorTypeByteMaxVectorTestsSmokeTest() { + static void VectorTypeByteVectorMaxTestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesByteMaxVectorTestsSmokeTest() { + static void WithLanesByteVectorMaxTestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(byte.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeByteMaxVectorTestsSmokeTest() { + static void WithShapeByteVectorMaxTestsSmokeTest() { ByteVector av = ByteVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7343,7 +7343,7 @@ public class ByteMaxVectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueByteMaxVectorTestsSmokeTest() { + static void MaskAllTrueByteVectorMaxTestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Double128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/DoubleVector128LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Double128VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/DoubleVector128LoadStoreTests.java index e4a0a6bf40e..68349a6afd9 100644 --- a/test/jdk/jdk/incubator/vector/Double128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVector128LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Double128VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation DoubleVector128LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Double128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class DoubleVector128LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_128; diff --git a/test/jdk/jdk/incubator/vector/Double128VectorTests.java b/test/jdk/jdk/incubator/vector/DoubleVector128Tests.java similarity index 91% rename from test/jdk/jdk/incubator/vector/Double128VectorTests.java rename to test/jdk/jdk/incubator/vector/DoubleVector128Tests.java index 685590f06e1..7b4b587b142 100644 --- a/test/jdk/jdk/incubator/vector/Double128VectorTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVector128Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Double128VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation DoubleVector128Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Double128VectorTests extends AbstractVectorTest { +public class DoubleVector128Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_128; @@ -1681,7 +1681,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void ADDDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1694,7 +1694,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::ADD); + assertArraysEquals(r, a, b, DoubleVector128Tests::ADD); } static double add(double a, double b) { @@ -1702,7 +1702,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void addDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1713,11 +1713,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double128VectorTests::add); + assertArraysEquals(r, a, b, DoubleVector128Tests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1733,11 +1733,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double128VectorTests::ADD); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1751,7 +1751,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double128VectorTests::add); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::add); } static double SUB(double a, double b) { @@ -1759,7 +1759,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void SUBDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void SUBDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1772,7 +1772,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::SUB); + assertArraysEquals(r, a, b, DoubleVector128Tests::SUB); } static double sub(double a, double b) { @@ -1780,7 +1780,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void subDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1791,11 +1791,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double128VectorTests::sub); + assertArraysEquals(r, a, b, DoubleVector128Tests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void SUBDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1811,11 +1811,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double128VectorTests::SUB); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::SUB); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1829,7 +1829,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double128VectorTests::sub); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::sub); } static double MUL(double a, double b) { @@ -1837,7 +1837,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MULDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void MULDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1850,7 +1850,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::MUL); + assertArraysEquals(r, a, b, DoubleVector128Tests::MUL); } static double mul(double a, double b) { @@ -1858,7 +1858,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void mulDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1869,11 +1869,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double128VectorTests::mul); + assertArraysEquals(r, a, b, DoubleVector128Tests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void MULDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1889,11 +1889,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double128VectorTests::MUL); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::MUL); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1907,7 +1907,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double128VectorTests::mul); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::mul); } static double DIV(double a, double b) { @@ -1915,7 +1915,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void DIVDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void DIVDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1928,7 +1928,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::DIV); + assertArraysEquals(r, a, b, DoubleVector128Tests::DIV); } static double div(double a, double b) { @@ -1936,7 +1936,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void divDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1947,11 +1947,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double128VectorTests::div); + assertArraysEquals(r, a, b, DoubleVector128Tests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void DIVDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1967,11 +1967,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double128VectorTests::DIV); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::DIV); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1985,7 +1985,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double128VectorTests::div); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::div); } static double FIRST_NONZERO(double a, double b) { @@ -1993,7 +1993,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void FIRST_NONZERODouble128VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZERODoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2006,11 +2006,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, DoubleVector128Tests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void FIRST_NONZERODouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZERODoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2026,11 +2026,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2040,11 +2040,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, DoubleVector128Tests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDouble128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addDoubleVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2057,11 +2057,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector128Tests::add); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2071,11 +2071,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, DoubleVector128Tests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDouble128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subDoubleVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2088,11 +2088,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector128Tests::sub); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2102,11 +2102,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, DoubleVector128Tests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDouble128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulDoubleVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2119,11 +2119,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector128Tests::mul); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2133,11 +2133,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, DoubleVector128Tests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDouble128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divDoubleVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2150,11 +2150,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector128Tests::div); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDouble128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDDoubleVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2164,11 +2164,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Double128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, DoubleVector128Tests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDouble128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDDoubleVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2181,13 +2181,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Double128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVector128Tests::ADD); } static DoubleVector bv_MIN = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MINDouble128VectorTestsWithMemOp(IntFunction fa) { + static void MINDoubleVector128TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2198,13 +2198,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double128VectorTests::MIN); + assertArraysEquals(r, a, (double)10, DoubleVector128Tests::MIN); } static DoubleVector bv_min = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void minDouble128VectorTestsWithMemOp(IntFunction fa) { + static void minDoubleVector128TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2215,13 +2215,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double128VectorTests::min); + assertArraysEquals(r, a, (double)10, DoubleVector128Tests::min); } static DoubleVector bv_MIN_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINDouble128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINDoubleVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2234,13 +2234,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, Double128VectorTests::MIN); + assertArraysEquals(r, a, (double)10, mask, DoubleVector128Tests::MIN); } static DoubleVector bv_MAX = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXDouble128VectorTestsWithMemOp(IntFunction fa) { + static void MAXDoubleVector128TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2251,13 +2251,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double128VectorTests::MAX); + assertArraysEquals(r, a, (double)10, DoubleVector128Tests::MAX); } static DoubleVector bv_max = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void maxDouble128VectorTestsWithMemOp(IntFunction fa) { + static void maxDoubleVector128TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2268,13 +2268,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double128VectorTests::max); + assertArraysEquals(r, a, (double)10, DoubleVector128Tests::max); } static DoubleVector bv_MAX_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXDouble128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXDoubleVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2287,7 +2287,7 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, Double128VectorTests::MAX); + assertArraysEquals(r, a, (double)10, mask, DoubleVector128Tests::MAX); } static double MIN(double a, double b) { @@ -2295,7 +2295,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void MINDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2308,7 +2308,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::MIN); + assertArraysEquals(r, a, b, DoubleVector128Tests::MIN); } static double min(double a, double b) { @@ -2316,7 +2316,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void minDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2327,7 +2327,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double128VectorTests::min); + assertArraysEquals(r, a, b, DoubleVector128Tests::min); } static double MAX(double a, double b) { @@ -2335,7 +2335,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void MAXDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2348,7 +2348,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::MAX); + assertArraysEquals(r, a, b, DoubleVector128Tests::MAX); } static double max(double a, double b) { @@ -2356,7 +2356,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void maxDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2367,11 +2367,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double128VectorTests::max); + assertArraysEquals(r, a, b, DoubleVector128Tests::max); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2381,11 +2381,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double128VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, DoubleVector128Tests::MIN); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2395,11 +2395,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double128VectorTests::min); + assertBroadcastArraysEquals(r, a, b, DoubleVector128Tests::min); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2409,11 +2409,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double128VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, DoubleVector128Tests::MAX); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2423,7 +2423,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double128VectorTests::max); + assertBroadcastArraysEquals(r, a, b, DoubleVector128Tests::max); } static double ADDReduce(double[] a, int idx) { @@ -2445,7 +2445,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceDouble128VectorTests(IntFunction fa) { + static void ADDReduceDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2461,7 +2461,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double128VectorTests::ADDReduce, Double128VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVector128Tests::ADDReduce, DoubleVector128Tests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2507,7 +2507,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceDouble128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceDoubleVector128TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2525,7 +2525,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double128VectorTests::ADDReduceMasked, Double128VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVector128Tests::ADDReduceMasked, DoubleVector128Tests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static double MULReduce(double[] a, int idx) { @@ -2547,7 +2547,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MULReduceDouble128VectorTests(IntFunction fa) { + static void MULReduceDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2563,7 +2563,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double128VectorTests::MULReduce, Double128VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVector128Tests::MULReduce, DoubleVector128Tests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2609,7 +2609,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MULReduceDouble128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceDoubleVector128TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2627,7 +2627,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double128VectorTests::MULReduceMasked, Double128VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVector128Tests::MULReduceMasked, DoubleVector128Tests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static double MINReduce(double[] a, int idx) { @@ -2649,7 +2649,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MINReduceDouble128VectorTests(IntFunction fa) { + static void MINReduceDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2665,7 +2665,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double128VectorTests::MINReduce, Double128VectorTests::MINReduceAll); + DoubleVector128Tests::MINReduce, DoubleVector128Tests::MINReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2711,7 +2711,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINReduceDouble128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceDoubleVector128TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2729,7 +2729,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double128VectorTests::MINReduceMasked, Double128VectorTests::MINReduceAllMasked); + DoubleVector128Tests::MINReduceMasked, DoubleVector128Tests::MINReduceAllMasked); } static double MAXReduce(double[] a, int idx) { @@ -2751,7 +2751,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXReduceDouble128VectorTests(IntFunction fa) { + static void MAXReduceDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2767,7 +2767,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double128VectorTests::MAXReduce, Double128VectorTests::MAXReduceAll); + DoubleVector128Tests::MAXReduce, DoubleVector128Tests::MAXReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2813,7 +2813,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXReduceDouble128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceDoubleVector128TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2831,7 +2831,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double128VectorTests::MAXReduceMasked, Double128VectorTests::MAXReduceAllMasked); + DoubleVector128Tests::MAXReduceMasked, DoubleVector128Tests::MAXReduceAllMasked); } static double FIRST_NONZEROReduce(double[] a, int idx) { @@ -2853,7 +2853,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void FIRST_NONZEROReduceDouble128VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2869,7 +2869,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double128VectorTests::FIRST_NONZEROReduce, Double128VectorTests::FIRST_NONZEROReduceAll); + DoubleVector128Tests::FIRST_NONZEROReduce, DoubleVector128Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2915,7 +2915,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void FIRST_NONZEROReduceDouble128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceDoubleVector128TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2933,11 +2933,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double128VectorTests::FIRST_NONZEROReduceMasked, Double128VectorTests::FIRST_NONZEROReduceAllMasked); + DoubleVector128Tests::FIRST_NONZEROReduceMasked, DoubleVector128Tests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "doubleBinaryOpProvider") - static void withDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void withDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2960,7 +2960,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_DEFAULTDouble128VectorTests(IntFunction fa) { + static void IS_DEFAULTDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2977,7 +2977,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_DEFAULTMaskedDouble128VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3001,7 +3001,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NEGATIVEDouble128VectorTests(IntFunction fa) { + static void IS_NEGATIVEDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3018,7 +3018,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NEGATIVEMaskedDouble128VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3042,7 +3042,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_FINITEDouble128VectorTests(IntFunction fa) { + static void IS_FINITEDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3059,7 +3059,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_FINITEMaskedDouble128VectorTests(IntFunction fa, + static void IS_FINITEMaskedDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3083,7 +3083,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NANDouble128VectorTests(IntFunction fa) { + static void IS_NANDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3100,7 +3100,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NANMaskedDouble128VectorTests(IntFunction fa, + static void IS_NANMaskedDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3124,7 +3124,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_INFINITEDouble128VectorTests(IntFunction fa) { + static void IS_INFINITEDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3141,7 +3141,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_INFINITEMaskedDouble128VectorTests(IntFunction fa, + static void IS_INFINITEMaskedDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3161,7 +3161,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void LTDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3180,7 +3180,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void ltDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3199,7 +3199,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3222,7 +3222,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GTDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void GTDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3241,7 +3241,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GTDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3264,7 +3264,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void EQDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3283,7 +3283,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void eqDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3302,7 +3302,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3325,7 +3325,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void NEDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void NEDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3344,7 +3344,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void NEDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3367,7 +3367,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LEDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void LEDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3386,7 +3386,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LEDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3409,7 +3409,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GEDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void GEDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3428,7 +3428,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GEDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3451,7 +3451,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3467,7 +3467,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTDoubleVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3487,7 +3487,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3503,7 +3503,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTDoubleVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3523,7 +3523,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3539,7 +3539,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQDoubleVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3559,7 +3559,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3575,7 +3575,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQDoubleVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3599,7 +3599,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDouble128VectorTests(IntFunction fa, IntFunction fb, + static void blendDoubleVector128Tests(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3615,11 +3615,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double128VectorTests::blend); + assertArraysEquals(r, a, b, mask, DoubleVector128Tests::blend); } @Test(dataProvider = "doubleUnaryOpShuffleProvider") - static void RearrangeDouble128VectorTests(IntFunction fa, + static void RearrangeDoubleVector128Tests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3636,7 +3636,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpShuffleMaskProvider") - static void RearrangeDouble128VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeDoubleVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -3654,7 +3654,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void compressDouble128VectorTests(IntFunction fa, + static void compressDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3672,7 +3672,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void expandDouble128VectorTests(IntFunction fa, + static void expandDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3690,7 +3690,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void getDouble128VectorTests(IntFunction fa) { + static void getDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3846,7 +3846,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void BroadcastDouble128VectorTests(IntFunction fa) { + static void BroadcastDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3860,7 +3860,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ZeroDouble128VectorTests(IntFunction fa) { + static void ZeroDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3885,7 +3885,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sliceUnaryDouble128VectorTests(IntFunction fa) { + static void sliceUnaryDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3896,7 +3896,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Double128VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, DoubleVector128Tests::sliceUnary); } static double[] sliceBinary(double[] a, double[] b, int origin, int idx) { @@ -3913,7 +3913,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void sliceBinaryDouble128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryDoubleVector128TestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3926,7 +3926,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, Double128VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, DoubleVector128Tests::sliceBinary); } static double[] slice(double[] a, double[] b, int origin, boolean[] mask, int idx) { @@ -3943,7 +3943,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void sliceDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3960,7 +3960,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, Double128VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, DoubleVector128Tests::slice); } static double[] unsliceUnary(double[] a, int origin, int idx) { @@ -3977,7 +3977,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void unsliceUnaryDouble128VectorTests(IntFunction fa) { + static void unsliceUnaryDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3988,7 +3988,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Double128VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, DoubleVector128Tests::unsliceUnary); } static double[] unsliceBinary(double[] a, double[] b, int origin, int part, int idx) { @@ -4014,7 +4014,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void unsliceBinaryDouble128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryDoubleVector128TestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -4028,7 +4028,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, Double128VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, DoubleVector128Tests::unsliceBinary); } static double[] unslice(double[] a, double[] b, int origin, int part, boolean[] mask, int idx) { @@ -4068,7 +4068,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void unsliceDouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceDoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4085,7 +4085,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, Double128VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, DoubleVector128Tests::unslice); } static double SIN(double a) { @@ -4097,7 +4097,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINDouble128VectorTests(IntFunction fa) { + static void SINDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4108,7 +4108,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::SIN, Double128VectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::SIN, DoubleVector128Tests::strictSIN); } static double EXP(double a) { @@ -4120,7 +4120,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPDouble128VectorTests(IntFunction fa) { + static void EXPDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4131,7 +4131,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::EXP, Double128VectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::EXP, DoubleVector128Tests::strictEXP); } static double LOG1P(double a) { @@ -4143,7 +4143,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG1PDouble128VectorTests(IntFunction fa) { + static void LOG1PDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4154,7 +4154,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::LOG1P, Double128VectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::LOG1P, DoubleVector128Tests::strictLOG1P); } static double LOG(double a) { @@ -4166,7 +4166,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOGDouble128VectorTests(IntFunction fa) { + static void LOGDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4177,7 +4177,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::LOG, Double128VectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::LOG, DoubleVector128Tests::strictLOG); } static double LOG10(double a) { @@ -4189,7 +4189,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG10Double128VectorTests(IntFunction fa) { + static void LOG10DoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4200,7 +4200,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::LOG10, Double128VectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::LOG10, DoubleVector128Tests::strictLOG10); } static double EXPM1(double a) { @@ -4212,7 +4212,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPM1Double128VectorTests(IntFunction fa) { + static void EXPM1DoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4223,7 +4223,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::EXPM1, Double128VectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::EXPM1, DoubleVector128Tests::strictEXPM1); } static double COS(double a) { @@ -4235,7 +4235,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSDouble128VectorTests(IntFunction fa) { + static void COSDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4246,7 +4246,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::COS, Double128VectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::COS, DoubleVector128Tests::strictCOS); } static double TAN(double a) { @@ -4258,7 +4258,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANDouble128VectorTests(IntFunction fa) { + static void TANDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4269,7 +4269,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::TAN, Double128VectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::TAN, DoubleVector128Tests::strictTAN); } static double SINH(double a) { @@ -4281,7 +4281,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINHDouble128VectorTests(IntFunction fa) { + static void SINHDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4292,7 +4292,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::SINH, Double128VectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::SINH, DoubleVector128Tests::strictSINH); } static double COSH(double a) { @@ -4304,7 +4304,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSHDouble128VectorTests(IntFunction fa) { + static void COSHDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4315,7 +4315,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::COSH, Double128VectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::COSH, DoubleVector128Tests::strictCOSH); } static double TANH(double a) { @@ -4327,7 +4327,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANHDouble128VectorTests(IntFunction fa) { + static void TANHDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4338,7 +4338,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::TANH, Double128VectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::TANH, DoubleVector128Tests::strictTANH); } static double ASIN(double a) { @@ -4350,7 +4350,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ASINDouble128VectorTests(IntFunction fa) { + static void ASINDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4361,7 +4361,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::ASIN, Double128VectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::ASIN, DoubleVector128Tests::strictASIN); } static double ACOS(double a) { @@ -4373,7 +4373,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ACOSDouble128VectorTests(IntFunction fa) { + static void ACOSDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4384,7 +4384,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::ACOS, Double128VectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::ACOS, DoubleVector128Tests::strictACOS); } static double ATAN(double a) { @@ -4396,7 +4396,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ATANDouble128VectorTests(IntFunction fa) { + static void ATANDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4407,7 +4407,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::ATAN, Double128VectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::ATAN, DoubleVector128Tests::strictATAN); } static double CBRT(double a) { @@ -4419,7 +4419,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void CBRTDouble128VectorTests(IntFunction fa) { + static void CBRTDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4430,7 +4430,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double128VectorTests::CBRT, Double128VectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector128Tests::CBRT, DoubleVector128Tests::strictCBRT); } static double HYPOT(double a, double b) { @@ -4442,7 +4442,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void HYPOTDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4455,7 +4455,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double128VectorTests::HYPOT, Double128VectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector128Tests::HYPOT, DoubleVector128Tests::strictHYPOT); } @@ -4468,7 +4468,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void POWDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4481,7 +4481,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double128VectorTests::POW, Double128VectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector128Tests::POW, DoubleVector128Tests::strictPOW); } @@ -4494,7 +4494,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void powDoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4507,7 +4507,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double128VectorTests::pow, Double128VectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector128Tests::pow, DoubleVector128Tests::strictpow); } @@ -4520,7 +4520,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ATAN2Double128VectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2DoubleVector128Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4533,12 +4533,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double128VectorTests::ATAN2, Double128VectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector128Tests::ATAN2, DoubleVector128Tests::strictATAN2); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4548,12 +4548,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double128VectorTests::POW, Double128VectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVector128Tests::POW, DoubleVector128Tests::strictPOW); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4563,7 +4563,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double128VectorTests::pow, Double128VectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVector128Tests::pow, DoubleVector128Tests::strictpow); } @@ -4576,7 +4576,7 @@ relativeError)); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4598,11 +4598,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, Double128VectorTests::FMA); + assertArraysEquals(r, a, b, c, DoubleVector128Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDouble128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4622,11 +4622,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Double128VectorTests::fma); + assertArraysEquals(r, a, b, c, DoubleVector128Tests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMADoubleVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4651,11 +4651,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, Double128VectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, DoubleVector128Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4666,11 +4666,11 @@ relativeError)); DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Double128VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, DoubleVector128Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4681,11 +4681,11 @@ relativeError)); DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Double128VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, DoubleVector128Tests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4700,11 +4700,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Double128VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, DoubleVector128Tests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble128VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector128TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4719,11 +4719,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Double128VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, DoubleVector128Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4741,11 +4741,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Double128VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVector128Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDouble128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4763,11 +4763,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Double128VectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVector128Tests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble128VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector128TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4788,7 +4788,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Double128VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, DoubleVector128Tests::FMA); } static double NEG(double a) { @@ -4800,7 +4800,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void NEGDouble128VectorTests(IntFunction fa) { + static void NEGDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4811,11 +4811,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double128VectorTests::NEG); + assertArraysEquals(r, a, DoubleVector128Tests::NEG); } @Test(dataProvider = "doubleUnaryOpProvider") - static void negDouble128VectorTests(IntFunction fa) { + static void negDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4826,11 +4826,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double128VectorTests::neg); + assertArraysEquals(r, a, DoubleVector128Tests::neg); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void NEGMaskedDouble128VectorTests(IntFunction fa, + static void NEGMaskedDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4844,7 +4844,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double128VectorTests::NEG); + assertArraysEquals(r, a, mask, DoubleVector128Tests::NEG); } static double ABS(double a) { @@ -4856,7 +4856,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ABSDouble128VectorTests(IntFunction fa) { + static void ABSDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4867,11 +4867,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double128VectorTests::ABS); + assertArraysEquals(r, a, DoubleVector128Tests::ABS); } @Test(dataProvider = "doubleUnaryOpProvider") - static void absDouble128VectorTests(IntFunction fa) { + static void absDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4882,11 +4882,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double128VectorTests::abs); + assertArraysEquals(r, a, DoubleVector128Tests::abs); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ABSMaskedDouble128VectorTests(IntFunction fa, + static void ABSMaskedDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4900,7 +4900,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double128VectorTests::ABS); + assertArraysEquals(r, a, mask, DoubleVector128Tests::ABS); } static double SQRT(double a) { @@ -4912,7 +4912,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SQRTDouble128VectorTests(IntFunction fa) { + static void SQRTDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4923,11 +4923,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double128VectorTests::SQRT); + assertArraysEquals(r, a, DoubleVector128Tests::SQRT); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sqrtDouble128VectorTests(IntFunction fa) { + static void sqrtDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4938,11 +4938,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double128VectorTests::sqrt); + assertArraysEquals(r, a, DoubleVector128Tests::sqrt); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void SQRTMaskedDouble128VectorTests(IntFunction fa, + static void SQRTMaskedDoubleVector128Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4956,7 +4956,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double128VectorTests::SQRT); + assertArraysEquals(r, a, mask, DoubleVector128Tests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4964,7 +4964,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandDoubleVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4977,7 +4977,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::band); + assertArraysEquals(r, a, b, DoubleVector128Tests::band); } static boolean bor(boolean a, boolean b) { @@ -4985,7 +4985,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void maskorDoubleVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4998,7 +4998,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::bor); + assertArraysEquals(r, a, b, DoubleVector128Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -5006,7 +5006,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorDoubleVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5019,7 +5019,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::bxor); + assertArraysEquals(r, a, b, DoubleVector128Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5027,7 +5027,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotDoubleVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5040,7 +5040,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::bandNot); + assertArraysEquals(r, a, b, DoubleVector128Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5048,7 +5048,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqDoubleVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5061,7 +5061,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double128VectorTests::beq); + assertArraysEquals(r, a, b, DoubleVector128Tests::beq); } static boolean unot(boolean a) { @@ -5069,7 +5069,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotDouble128VectorTests(IntFunction fa) { + static void masknotDoubleVector128Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5080,7 +5080,7 @@ relativeError)); } } - assertArraysEquals(r, a, Double128VectorTests::unot); + assertArraysEquals(r, a, DoubleVector128Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5097,7 +5097,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongDouble128VectorTests(IntFunction fa) { + static void maskFromToLongDoubleVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5111,7 +5111,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDouble128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltDoubleVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5127,7 +5127,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDouble128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqDoubleVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5143,7 +5143,7 @@ relativeError)); } @Test(dataProvider = "doubletoIntUnaryOpProvider") - static void toIntArrayDouble128VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayDoubleVector128TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5154,7 +5154,7 @@ relativeError)); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void toLongArrayDouble128VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayDoubleVector128TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5166,7 +5166,7 @@ relativeError)); @Test(dataProvider = "doubleUnaryOpProvider") - static void toStringDouble128VectorTestsSmokeTest(IntFunction fa) { + static void toStringDoubleVector128TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5179,7 +5179,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void hashCodeDouble128VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeDoubleVector128TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5212,7 +5212,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceLongDouble128VectorTests(IntFunction fa) { + static void ADDReduceLongDoubleVector128Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5228,7 +5228,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - Double128VectorTests::ADDReduceLong, Double128VectorTests::ADDReduceAllLong); + DoubleVector128Tests::ADDReduceLong, DoubleVector128Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(double[] a, int idx, boolean[] mask) { @@ -5251,7 +5251,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceLongDouble128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongDoubleVector128TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5269,11 +5269,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Double128VectorTests::ADDReduceLongMasked, Double128VectorTests::ADDReduceAllLongMasked); + DoubleVector128Tests::ADDReduceLongMasked, DoubleVector128Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void BroadcastLongDouble128VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongDoubleVector128TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -5284,7 +5284,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDouble128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendDoubleVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5298,12 +5298,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Double128VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVector128Tests::blend); } @Test(dataProvider = "doubleUnaryOpSelectFromProvider") - static void SelectFromDouble128VectorTests(IntFunction fa, + static void SelectFromDoubleVector128Tests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); double[] order = fs.apply(a.length, SPECIES.length()); @@ -5319,7 +5319,7 @@ relativeError)); } @Test(dataProvider = "doubleSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorDouble128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorDoubleVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] idx = fc.apply(SPECIES.length()); @@ -5337,7 +5337,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpSelectFromMaskProvider") - static void SelectFromDouble128VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromDoubleVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -5356,7 +5356,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousDouble128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousDoubleVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5372,7 +5372,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringDouble128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringDoubleVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5386,7 +5386,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsDouble128VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsDoubleVector128TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5400,7 +5400,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsDouble128VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsDoubleVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5416,7 +5416,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeDouble128VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeDoubleVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5438,7 +5438,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountDouble128VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountDoubleVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5449,7 +5449,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double128VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, DoubleVector128Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5463,7 +5463,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueDouble128VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueDoubleVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5474,7 +5474,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double128VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, DoubleVector128Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5488,7 +5488,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueDouble128VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueDoubleVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5499,11 +5499,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double128VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, DoubleVector128Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressDouble128VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressDoubleVector128TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5531,7 +5531,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeDouble128VectorTestsSmokeTest(int offset) { + static void indexInRangeDoubleVector128TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5545,7 +5545,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongDouble128VectorTestsSmokeTest(int offset) { + static void indexInRangeLongDoubleVector128TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5572,14 +5572,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundDouble128VectorTestsSmokeTest(int length) { + static void loopBoundDoubleVector128TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongDouble128VectorTestsSmokeTest(int _length) { + static void loopBoundLongDoubleVector128TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5587,21 +5587,21 @@ relativeError)); } @Test - static void ElementSizeDouble128VectorTestsSmokeTest() { + static void ElementSizeDoubleVector128TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Double.SIZE); } @Test - static void VectorShapeDouble128VectorTestsSmokeTest() { + static void VectorShapeDoubleVector128TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_128_BIT)); } @Test - static void ShapeWithLanesDouble128VectorTestsSmokeTest() { + static void ShapeWithLanesDoubleVector128TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(double.class); @@ -5609,32 +5609,32 @@ relativeError)); } @Test - static void ElementTypeDouble128VectorTestsSmokeTest() { + static void ElementTypeDoubleVector128TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementType() == double.class); } @Test - static void SpeciesElementSizeDouble128VectorTestsSmokeTest() { + static void SpeciesElementSizeDoubleVector128TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementSize() == Double.SIZE); } @Test - static void VectorTypeDouble128VectorTestsSmokeTest() { + static void VectorTypeDoubleVector128TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesDouble128VectorTestsSmokeTest() { + static void WithLanesDoubleVector128TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(double.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeDouble128VectorTestsSmokeTest() { + static void WithShapeDoubleVector128TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5642,7 +5642,7 @@ relativeError)); } @Test - static void MaskAllTrueDouble128VectorTestsSmokeTest() { + static void MaskAllTrueDoubleVector128TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Double256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/DoubleVector256LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Double256VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/DoubleVector256LoadStoreTests.java index 56d5608a89d..b966bafb299 100644 --- a/test/jdk/jdk/incubator/vector/Double256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVector256LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Double256VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation DoubleVector256LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Double256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class DoubleVector256LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_256; diff --git a/test/jdk/jdk/incubator/vector/Double256VectorTests.java b/test/jdk/jdk/incubator/vector/DoubleVector256Tests.java similarity index 91% rename from test/jdk/jdk/incubator/vector/Double256VectorTests.java rename to test/jdk/jdk/incubator/vector/DoubleVector256Tests.java index d39b6f9c923..4d650d7b407 100644 --- a/test/jdk/jdk/incubator/vector/Double256VectorTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVector256Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Double256VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation DoubleVector256Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Double256VectorTests extends AbstractVectorTest { +public class DoubleVector256Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_256; @@ -1681,7 +1681,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void ADDDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1694,7 +1694,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::ADD); + assertArraysEquals(r, a, b, DoubleVector256Tests::ADD); } static double add(double a, double b) { @@ -1702,7 +1702,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void addDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1713,11 +1713,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double256VectorTests::add); + assertArraysEquals(r, a, b, DoubleVector256Tests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1733,11 +1733,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double256VectorTests::ADD); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1751,7 +1751,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double256VectorTests::add); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::add); } static double SUB(double a, double b) { @@ -1759,7 +1759,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void SUBDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void SUBDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1772,7 +1772,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::SUB); + assertArraysEquals(r, a, b, DoubleVector256Tests::SUB); } static double sub(double a, double b) { @@ -1780,7 +1780,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void subDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1791,11 +1791,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double256VectorTests::sub); + assertArraysEquals(r, a, b, DoubleVector256Tests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void SUBDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1811,11 +1811,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double256VectorTests::SUB); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::SUB); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1829,7 +1829,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double256VectorTests::sub); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::sub); } static double MUL(double a, double b) { @@ -1837,7 +1837,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MULDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void MULDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1850,7 +1850,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::MUL); + assertArraysEquals(r, a, b, DoubleVector256Tests::MUL); } static double mul(double a, double b) { @@ -1858,7 +1858,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void mulDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1869,11 +1869,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double256VectorTests::mul); + assertArraysEquals(r, a, b, DoubleVector256Tests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void MULDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1889,11 +1889,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double256VectorTests::MUL); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::MUL); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1907,7 +1907,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double256VectorTests::mul); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::mul); } static double DIV(double a, double b) { @@ -1915,7 +1915,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void DIVDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void DIVDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1928,7 +1928,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::DIV); + assertArraysEquals(r, a, b, DoubleVector256Tests::DIV); } static double div(double a, double b) { @@ -1936,7 +1936,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void divDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1947,11 +1947,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double256VectorTests::div); + assertArraysEquals(r, a, b, DoubleVector256Tests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void DIVDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1967,11 +1967,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double256VectorTests::DIV); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::DIV); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1985,7 +1985,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double256VectorTests::div); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::div); } static double FIRST_NONZERO(double a, double b) { @@ -1993,7 +1993,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void FIRST_NONZERODouble256VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZERODoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2006,11 +2006,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, DoubleVector256Tests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void FIRST_NONZERODouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZERODoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2026,11 +2026,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2040,11 +2040,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, DoubleVector256Tests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addDoubleVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2057,11 +2057,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector256Tests::add); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2071,11 +2071,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, DoubleVector256Tests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subDoubleVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2088,11 +2088,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector256Tests::sub); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2102,11 +2102,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, DoubleVector256Tests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulDoubleVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2119,11 +2119,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector256Tests::mul); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2133,11 +2133,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, DoubleVector256Tests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divDoubleVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2150,11 +2150,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector256Tests::div); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDouble256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDDoubleVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2164,11 +2164,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Double256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, DoubleVector256Tests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDouble256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDDoubleVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2181,13 +2181,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Double256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVector256Tests::ADD); } static DoubleVector bv_MIN = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MINDouble256VectorTestsWithMemOp(IntFunction fa) { + static void MINDoubleVector256TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2198,13 +2198,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double256VectorTests::MIN); + assertArraysEquals(r, a, (double)10, DoubleVector256Tests::MIN); } static DoubleVector bv_min = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void minDouble256VectorTestsWithMemOp(IntFunction fa) { + static void minDoubleVector256TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2215,13 +2215,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double256VectorTests::min); + assertArraysEquals(r, a, (double)10, DoubleVector256Tests::min); } static DoubleVector bv_MIN_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINDouble256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINDoubleVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2234,13 +2234,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, Double256VectorTests::MIN); + assertArraysEquals(r, a, (double)10, mask, DoubleVector256Tests::MIN); } static DoubleVector bv_MAX = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXDouble256VectorTestsWithMemOp(IntFunction fa) { + static void MAXDoubleVector256TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2251,13 +2251,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double256VectorTests::MAX); + assertArraysEquals(r, a, (double)10, DoubleVector256Tests::MAX); } static DoubleVector bv_max = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void maxDouble256VectorTestsWithMemOp(IntFunction fa) { + static void maxDoubleVector256TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2268,13 +2268,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double256VectorTests::max); + assertArraysEquals(r, a, (double)10, DoubleVector256Tests::max); } static DoubleVector bv_MAX_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXDouble256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXDoubleVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2287,7 +2287,7 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, Double256VectorTests::MAX); + assertArraysEquals(r, a, (double)10, mask, DoubleVector256Tests::MAX); } static double MIN(double a, double b) { @@ -2295,7 +2295,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void MINDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2308,7 +2308,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::MIN); + assertArraysEquals(r, a, b, DoubleVector256Tests::MIN); } static double min(double a, double b) { @@ -2316,7 +2316,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void minDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2327,7 +2327,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double256VectorTests::min); + assertArraysEquals(r, a, b, DoubleVector256Tests::min); } static double MAX(double a, double b) { @@ -2335,7 +2335,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void MAXDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2348,7 +2348,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::MAX); + assertArraysEquals(r, a, b, DoubleVector256Tests::MAX); } static double max(double a, double b) { @@ -2356,7 +2356,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void maxDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2367,11 +2367,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double256VectorTests::max); + assertArraysEquals(r, a, b, DoubleVector256Tests::max); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2381,11 +2381,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double256VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, DoubleVector256Tests::MIN); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2395,11 +2395,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double256VectorTests::min); + assertBroadcastArraysEquals(r, a, b, DoubleVector256Tests::min); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2409,11 +2409,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double256VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, DoubleVector256Tests::MAX); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2423,7 +2423,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double256VectorTests::max); + assertBroadcastArraysEquals(r, a, b, DoubleVector256Tests::max); } static double ADDReduce(double[] a, int idx) { @@ -2445,7 +2445,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceDouble256VectorTests(IntFunction fa) { + static void ADDReduceDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2461,7 +2461,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double256VectorTests::ADDReduce, Double256VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVector256Tests::ADDReduce, DoubleVector256Tests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2507,7 +2507,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceDouble256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceDoubleVector256TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2525,7 +2525,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double256VectorTests::ADDReduceMasked, Double256VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVector256Tests::ADDReduceMasked, DoubleVector256Tests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static double MULReduce(double[] a, int idx) { @@ -2547,7 +2547,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MULReduceDouble256VectorTests(IntFunction fa) { + static void MULReduceDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2563,7 +2563,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double256VectorTests::MULReduce, Double256VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVector256Tests::MULReduce, DoubleVector256Tests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2609,7 +2609,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MULReduceDouble256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceDoubleVector256TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2627,7 +2627,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double256VectorTests::MULReduceMasked, Double256VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVector256Tests::MULReduceMasked, DoubleVector256Tests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static double MINReduce(double[] a, int idx) { @@ -2649,7 +2649,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MINReduceDouble256VectorTests(IntFunction fa) { + static void MINReduceDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2665,7 +2665,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double256VectorTests::MINReduce, Double256VectorTests::MINReduceAll); + DoubleVector256Tests::MINReduce, DoubleVector256Tests::MINReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2711,7 +2711,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINReduceDouble256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceDoubleVector256TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2729,7 +2729,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double256VectorTests::MINReduceMasked, Double256VectorTests::MINReduceAllMasked); + DoubleVector256Tests::MINReduceMasked, DoubleVector256Tests::MINReduceAllMasked); } static double MAXReduce(double[] a, int idx) { @@ -2751,7 +2751,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXReduceDouble256VectorTests(IntFunction fa) { + static void MAXReduceDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2767,7 +2767,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double256VectorTests::MAXReduce, Double256VectorTests::MAXReduceAll); + DoubleVector256Tests::MAXReduce, DoubleVector256Tests::MAXReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2813,7 +2813,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXReduceDouble256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceDoubleVector256TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2831,7 +2831,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double256VectorTests::MAXReduceMasked, Double256VectorTests::MAXReduceAllMasked); + DoubleVector256Tests::MAXReduceMasked, DoubleVector256Tests::MAXReduceAllMasked); } static double FIRST_NONZEROReduce(double[] a, int idx) { @@ -2853,7 +2853,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void FIRST_NONZEROReduceDouble256VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2869,7 +2869,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double256VectorTests::FIRST_NONZEROReduce, Double256VectorTests::FIRST_NONZEROReduceAll); + DoubleVector256Tests::FIRST_NONZEROReduce, DoubleVector256Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2915,7 +2915,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void FIRST_NONZEROReduceDouble256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceDoubleVector256TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2933,11 +2933,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double256VectorTests::FIRST_NONZEROReduceMasked, Double256VectorTests::FIRST_NONZEROReduceAllMasked); + DoubleVector256Tests::FIRST_NONZEROReduceMasked, DoubleVector256Tests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "doubleBinaryOpProvider") - static void withDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void withDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2960,7 +2960,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_DEFAULTDouble256VectorTests(IntFunction fa) { + static void IS_DEFAULTDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2977,7 +2977,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_DEFAULTMaskedDouble256VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3001,7 +3001,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NEGATIVEDouble256VectorTests(IntFunction fa) { + static void IS_NEGATIVEDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3018,7 +3018,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NEGATIVEMaskedDouble256VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3042,7 +3042,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_FINITEDouble256VectorTests(IntFunction fa) { + static void IS_FINITEDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3059,7 +3059,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_FINITEMaskedDouble256VectorTests(IntFunction fa, + static void IS_FINITEMaskedDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3083,7 +3083,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NANDouble256VectorTests(IntFunction fa) { + static void IS_NANDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3100,7 +3100,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NANMaskedDouble256VectorTests(IntFunction fa, + static void IS_NANMaskedDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3124,7 +3124,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_INFINITEDouble256VectorTests(IntFunction fa) { + static void IS_INFINITEDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3141,7 +3141,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_INFINITEMaskedDouble256VectorTests(IntFunction fa, + static void IS_INFINITEMaskedDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3161,7 +3161,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void LTDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3180,7 +3180,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void ltDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3199,7 +3199,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3222,7 +3222,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GTDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void GTDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3241,7 +3241,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GTDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3264,7 +3264,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void EQDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3283,7 +3283,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void eqDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3302,7 +3302,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3325,7 +3325,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void NEDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void NEDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3344,7 +3344,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void NEDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3367,7 +3367,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LEDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void LEDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3386,7 +3386,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LEDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3409,7 +3409,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GEDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void GEDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3428,7 +3428,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GEDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3451,7 +3451,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3467,7 +3467,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTDoubleVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3487,7 +3487,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3503,7 +3503,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTDoubleVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3523,7 +3523,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3539,7 +3539,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQDoubleVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3559,7 +3559,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3575,7 +3575,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQDoubleVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3599,7 +3599,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDouble256VectorTests(IntFunction fa, IntFunction fb, + static void blendDoubleVector256Tests(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3615,11 +3615,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double256VectorTests::blend); + assertArraysEquals(r, a, b, mask, DoubleVector256Tests::blend); } @Test(dataProvider = "doubleUnaryOpShuffleProvider") - static void RearrangeDouble256VectorTests(IntFunction fa, + static void RearrangeDoubleVector256Tests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3636,7 +3636,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpShuffleMaskProvider") - static void RearrangeDouble256VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeDoubleVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -3654,7 +3654,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void compressDouble256VectorTests(IntFunction fa, + static void compressDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3672,7 +3672,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void expandDouble256VectorTests(IntFunction fa, + static void expandDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3690,7 +3690,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void getDouble256VectorTests(IntFunction fa) { + static void getDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3846,7 +3846,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void BroadcastDouble256VectorTests(IntFunction fa) { + static void BroadcastDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3860,7 +3860,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ZeroDouble256VectorTests(IntFunction fa) { + static void ZeroDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3885,7 +3885,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sliceUnaryDouble256VectorTests(IntFunction fa) { + static void sliceUnaryDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3896,7 +3896,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Double256VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, DoubleVector256Tests::sliceUnary); } static double[] sliceBinary(double[] a, double[] b, int origin, int idx) { @@ -3913,7 +3913,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void sliceBinaryDouble256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryDoubleVector256TestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3926,7 +3926,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, Double256VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, DoubleVector256Tests::sliceBinary); } static double[] slice(double[] a, double[] b, int origin, boolean[] mask, int idx) { @@ -3943,7 +3943,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void sliceDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3960,7 +3960,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, Double256VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, DoubleVector256Tests::slice); } static double[] unsliceUnary(double[] a, int origin, int idx) { @@ -3977,7 +3977,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void unsliceUnaryDouble256VectorTests(IntFunction fa) { + static void unsliceUnaryDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3988,7 +3988,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Double256VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, DoubleVector256Tests::unsliceUnary); } static double[] unsliceBinary(double[] a, double[] b, int origin, int part, int idx) { @@ -4014,7 +4014,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void unsliceBinaryDouble256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryDoubleVector256TestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -4028,7 +4028,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, Double256VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, DoubleVector256Tests::unsliceBinary); } static double[] unslice(double[] a, double[] b, int origin, int part, boolean[] mask, int idx) { @@ -4068,7 +4068,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void unsliceDouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceDoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4085,7 +4085,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, Double256VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, DoubleVector256Tests::unslice); } static double SIN(double a) { @@ -4097,7 +4097,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINDouble256VectorTests(IntFunction fa) { + static void SINDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4108,7 +4108,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::SIN, Double256VectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::SIN, DoubleVector256Tests::strictSIN); } static double EXP(double a) { @@ -4120,7 +4120,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPDouble256VectorTests(IntFunction fa) { + static void EXPDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4131,7 +4131,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::EXP, Double256VectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::EXP, DoubleVector256Tests::strictEXP); } static double LOG1P(double a) { @@ -4143,7 +4143,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG1PDouble256VectorTests(IntFunction fa) { + static void LOG1PDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4154,7 +4154,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::LOG1P, Double256VectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::LOG1P, DoubleVector256Tests::strictLOG1P); } static double LOG(double a) { @@ -4166,7 +4166,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOGDouble256VectorTests(IntFunction fa) { + static void LOGDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4177,7 +4177,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::LOG, Double256VectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::LOG, DoubleVector256Tests::strictLOG); } static double LOG10(double a) { @@ -4189,7 +4189,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG10Double256VectorTests(IntFunction fa) { + static void LOG10DoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4200,7 +4200,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::LOG10, Double256VectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::LOG10, DoubleVector256Tests::strictLOG10); } static double EXPM1(double a) { @@ -4212,7 +4212,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPM1Double256VectorTests(IntFunction fa) { + static void EXPM1DoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4223,7 +4223,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::EXPM1, Double256VectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::EXPM1, DoubleVector256Tests::strictEXPM1); } static double COS(double a) { @@ -4235,7 +4235,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSDouble256VectorTests(IntFunction fa) { + static void COSDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4246,7 +4246,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::COS, Double256VectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::COS, DoubleVector256Tests::strictCOS); } static double TAN(double a) { @@ -4258,7 +4258,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANDouble256VectorTests(IntFunction fa) { + static void TANDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4269,7 +4269,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::TAN, Double256VectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::TAN, DoubleVector256Tests::strictTAN); } static double SINH(double a) { @@ -4281,7 +4281,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINHDouble256VectorTests(IntFunction fa) { + static void SINHDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4292,7 +4292,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::SINH, Double256VectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::SINH, DoubleVector256Tests::strictSINH); } static double COSH(double a) { @@ -4304,7 +4304,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSHDouble256VectorTests(IntFunction fa) { + static void COSHDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4315,7 +4315,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::COSH, Double256VectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::COSH, DoubleVector256Tests::strictCOSH); } static double TANH(double a) { @@ -4327,7 +4327,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANHDouble256VectorTests(IntFunction fa) { + static void TANHDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4338,7 +4338,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::TANH, Double256VectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::TANH, DoubleVector256Tests::strictTANH); } static double ASIN(double a) { @@ -4350,7 +4350,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ASINDouble256VectorTests(IntFunction fa) { + static void ASINDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4361,7 +4361,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::ASIN, Double256VectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::ASIN, DoubleVector256Tests::strictASIN); } static double ACOS(double a) { @@ -4373,7 +4373,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ACOSDouble256VectorTests(IntFunction fa) { + static void ACOSDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4384,7 +4384,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::ACOS, Double256VectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::ACOS, DoubleVector256Tests::strictACOS); } static double ATAN(double a) { @@ -4396,7 +4396,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ATANDouble256VectorTests(IntFunction fa) { + static void ATANDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4407,7 +4407,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::ATAN, Double256VectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::ATAN, DoubleVector256Tests::strictATAN); } static double CBRT(double a) { @@ -4419,7 +4419,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void CBRTDouble256VectorTests(IntFunction fa) { + static void CBRTDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4430,7 +4430,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::CBRT, Double256VectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector256Tests::CBRT, DoubleVector256Tests::strictCBRT); } static double HYPOT(double a, double b) { @@ -4442,7 +4442,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void HYPOTDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4455,7 +4455,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::HYPOT, Double256VectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector256Tests::HYPOT, DoubleVector256Tests::strictHYPOT); } @@ -4468,7 +4468,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void POWDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4481,7 +4481,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::POW, Double256VectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector256Tests::POW, DoubleVector256Tests::strictPOW); } @@ -4494,7 +4494,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void powDoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4507,7 +4507,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::pow, Double256VectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector256Tests::pow, DoubleVector256Tests::strictpow); } @@ -4520,7 +4520,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ATAN2Double256VectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2DoubleVector256Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4533,12 +4533,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::ATAN2, Double256VectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector256Tests::ATAN2, DoubleVector256Tests::strictATAN2); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4548,12 +4548,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::POW, Double256VectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVector256Tests::POW, DoubleVector256Tests::strictPOW); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4563,7 +4563,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::pow, Double256VectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVector256Tests::pow, DoubleVector256Tests::strictpow); } @@ -4576,7 +4576,7 @@ relativeError)); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4598,11 +4598,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, Double256VectorTests::FMA); + assertArraysEquals(r, a, b, c, DoubleVector256Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDouble256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4622,11 +4622,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Double256VectorTests::fma); + assertArraysEquals(r, a, b, c, DoubleVector256Tests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMADoubleVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4651,11 +4651,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, Double256VectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, DoubleVector256Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4666,11 +4666,11 @@ relativeError)); DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Double256VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, DoubleVector256Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4681,11 +4681,11 @@ relativeError)); DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Double256VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, DoubleVector256Tests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4700,11 +4700,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Double256VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, DoubleVector256Tests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector256TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4719,11 +4719,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Double256VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, DoubleVector256Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4741,11 +4741,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Double256VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVector256Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDouble256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4763,11 +4763,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Double256VectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVector256Tests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector256TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4788,7 +4788,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Double256VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, DoubleVector256Tests::FMA); } static double NEG(double a) { @@ -4800,7 +4800,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void NEGDouble256VectorTests(IntFunction fa) { + static void NEGDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4811,11 +4811,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double256VectorTests::NEG); + assertArraysEquals(r, a, DoubleVector256Tests::NEG); } @Test(dataProvider = "doubleUnaryOpProvider") - static void negDouble256VectorTests(IntFunction fa) { + static void negDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4826,11 +4826,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double256VectorTests::neg); + assertArraysEquals(r, a, DoubleVector256Tests::neg); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void NEGMaskedDouble256VectorTests(IntFunction fa, + static void NEGMaskedDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4844,7 +4844,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double256VectorTests::NEG); + assertArraysEquals(r, a, mask, DoubleVector256Tests::NEG); } static double ABS(double a) { @@ -4856,7 +4856,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ABSDouble256VectorTests(IntFunction fa) { + static void ABSDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4867,11 +4867,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double256VectorTests::ABS); + assertArraysEquals(r, a, DoubleVector256Tests::ABS); } @Test(dataProvider = "doubleUnaryOpProvider") - static void absDouble256VectorTests(IntFunction fa) { + static void absDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4882,11 +4882,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double256VectorTests::abs); + assertArraysEquals(r, a, DoubleVector256Tests::abs); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ABSMaskedDouble256VectorTests(IntFunction fa, + static void ABSMaskedDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4900,7 +4900,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double256VectorTests::ABS); + assertArraysEquals(r, a, mask, DoubleVector256Tests::ABS); } static double SQRT(double a) { @@ -4912,7 +4912,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SQRTDouble256VectorTests(IntFunction fa) { + static void SQRTDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4923,11 +4923,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double256VectorTests::SQRT); + assertArraysEquals(r, a, DoubleVector256Tests::SQRT); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sqrtDouble256VectorTests(IntFunction fa) { + static void sqrtDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4938,11 +4938,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double256VectorTests::sqrt); + assertArraysEquals(r, a, DoubleVector256Tests::sqrt); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void SQRTMaskedDouble256VectorTests(IntFunction fa, + static void SQRTMaskedDoubleVector256Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4956,7 +4956,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double256VectorTests::SQRT); + assertArraysEquals(r, a, mask, DoubleVector256Tests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4964,7 +4964,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandDoubleVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4977,7 +4977,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::band); + assertArraysEquals(r, a, b, DoubleVector256Tests::band); } static boolean bor(boolean a, boolean b) { @@ -4985,7 +4985,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void maskorDoubleVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4998,7 +4998,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::bor); + assertArraysEquals(r, a, b, DoubleVector256Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -5006,7 +5006,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorDoubleVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5019,7 +5019,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::bxor); + assertArraysEquals(r, a, b, DoubleVector256Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5027,7 +5027,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotDoubleVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5040,7 +5040,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::bandNot); + assertArraysEquals(r, a, b, DoubleVector256Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5048,7 +5048,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqDoubleVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5061,7 +5061,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double256VectorTests::beq); + assertArraysEquals(r, a, b, DoubleVector256Tests::beq); } static boolean unot(boolean a) { @@ -5069,7 +5069,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotDouble256VectorTests(IntFunction fa) { + static void masknotDoubleVector256Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5080,7 +5080,7 @@ relativeError)); } } - assertArraysEquals(r, a, Double256VectorTests::unot); + assertArraysEquals(r, a, DoubleVector256Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5097,7 +5097,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongDouble256VectorTests(IntFunction fa) { + static void maskFromToLongDoubleVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5111,7 +5111,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDouble256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltDoubleVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5127,7 +5127,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqDoubleVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5143,7 +5143,7 @@ relativeError)); } @Test(dataProvider = "doubletoIntUnaryOpProvider") - static void toIntArrayDouble256VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayDoubleVector256TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5154,7 +5154,7 @@ relativeError)); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void toLongArrayDouble256VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayDoubleVector256TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5166,7 +5166,7 @@ relativeError)); @Test(dataProvider = "doubleUnaryOpProvider") - static void toStringDouble256VectorTestsSmokeTest(IntFunction fa) { + static void toStringDoubleVector256TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5179,7 +5179,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void hashCodeDouble256VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeDoubleVector256TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5212,7 +5212,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceLongDouble256VectorTests(IntFunction fa) { + static void ADDReduceLongDoubleVector256Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5228,7 +5228,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - Double256VectorTests::ADDReduceLong, Double256VectorTests::ADDReduceAllLong); + DoubleVector256Tests::ADDReduceLong, DoubleVector256Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(double[] a, int idx, boolean[] mask) { @@ -5251,7 +5251,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceLongDouble256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongDoubleVector256TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5269,11 +5269,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Double256VectorTests::ADDReduceLongMasked, Double256VectorTests::ADDReduceAllLongMasked); + DoubleVector256Tests::ADDReduceLongMasked, DoubleVector256Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void BroadcastLongDouble256VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongDoubleVector256TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -5284,7 +5284,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDouble256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendDoubleVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5298,12 +5298,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Double256VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVector256Tests::blend); } @Test(dataProvider = "doubleUnaryOpSelectFromProvider") - static void SelectFromDouble256VectorTests(IntFunction fa, + static void SelectFromDoubleVector256Tests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); double[] order = fs.apply(a.length, SPECIES.length()); @@ -5319,7 +5319,7 @@ relativeError)); } @Test(dataProvider = "doubleSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorDouble256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorDoubleVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] idx = fc.apply(SPECIES.length()); @@ -5337,7 +5337,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpSelectFromMaskProvider") - static void SelectFromDouble256VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromDoubleVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -5356,7 +5356,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousDouble256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousDoubleVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5372,7 +5372,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringDouble256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringDoubleVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5386,7 +5386,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsDouble256VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsDoubleVector256TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5400,7 +5400,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsDouble256VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsDoubleVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5416,7 +5416,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeDouble256VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeDoubleVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5438,7 +5438,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountDouble256VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountDoubleVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5449,7 +5449,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double256VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, DoubleVector256Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5463,7 +5463,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueDouble256VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueDoubleVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5474,7 +5474,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double256VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, DoubleVector256Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5488,7 +5488,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueDouble256VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueDoubleVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5499,11 +5499,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double256VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, DoubleVector256Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressDouble256VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressDoubleVector256TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5531,7 +5531,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeDouble256VectorTestsSmokeTest(int offset) { + static void indexInRangeDoubleVector256TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5545,7 +5545,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongDouble256VectorTestsSmokeTest(int offset) { + static void indexInRangeLongDoubleVector256TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5572,14 +5572,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundDouble256VectorTestsSmokeTest(int length) { + static void loopBoundDoubleVector256TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongDouble256VectorTestsSmokeTest(int _length) { + static void loopBoundLongDoubleVector256TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5587,21 +5587,21 @@ relativeError)); } @Test - static void ElementSizeDouble256VectorTestsSmokeTest() { + static void ElementSizeDoubleVector256TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Double.SIZE); } @Test - static void VectorShapeDouble256VectorTestsSmokeTest() { + static void VectorShapeDoubleVector256TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_256_BIT)); } @Test - static void ShapeWithLanesDouble256VectorTestsSmokeTest() { + static void ShapeWithLanesDoubleVector256TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(double.class); @@ -5609,32 +5609,32 @@ relativeError)); } @Test - static void ElementTypeDouble256VectorTestsSmokeTest() { + static void ElementTypeDoubleVector256TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementType() == double.class); } @Test - static void SpeciesElementSizeDouble256VectorTestsSmokeTest() { + static void SpeciesElementSizeDoubleVector256TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementSize() == Double.SIZE); } @Test - static void VectorTypeDouble256VectorTestsSmokeTest() { + static void VectorTypeDoubleVector256TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesDouble256VectorTestsSmokeTest() { + static void WithLanesDoubleVector256TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(double.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeDouble256VectorTestsSmokeTest() { + static void WithShapeDoubleVector256TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5642,7 +5642,7 @@ relativeError)); } @Test - static void MaskAllTrueDouble256VectorTestsSmokeTest() { + static void MaskAllTrueDoubleVector256TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Double512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/DoubleVector512LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Double512VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/DoubleVector512LoadStoreTests.java index ea76ba814d5..cb60f7363af 100644 --- a/test/jdk/jdk/incubator/vector/Double512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVector512LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Double512VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation DoubleVector512LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Double512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class DoubleVector512LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_512; diff --git a/test/jdk/jdk/incubator/vector/Double512VectorTests.java b/test/jdk/jdk/incubator/vector/DoubleVector512Tests.java similarity index 91% rename from test/jdk/jdk/incubator/vector/Double512VectorTests.java rename to test/jdk/jdk/incubator/vector/DoubleVector512Tests.java index 7983ae0efe7..534470e194c 100644 --- a/test/jdk/jdk/incubator/vector/Double512VectorTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVector512Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Double512VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation DoubleVector512Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Double512VectorTests extends AbstractVectorTest { +public class DoubleVector512Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_512; @@ -1681,7 +1681,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void ADDDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1694,7 +1694,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::ADD); + assertArraysEquals(r, a, b, DoubleVector512Tests::ADD); } static double add(double a, double b) { @@ -1702,7 +1702,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void addDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1713,11 +1713,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double512VectorTests::add); + assertArraysEquals(r, a, b, DoubleVector512Tests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1733,11 +1733,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double512VectorTests::ADD); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1751,7 +1751,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double512VectorTests::add); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::add); } static double SUB(double a, double b) { @@ -1759,7 +1759,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void SUBDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void SUBDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1772,7 +1772,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::SUB); + assertArraysEquals(r, a, b, DoubleVector512Tests::SUB); } static double sub(double a, double b) { @@ -1780,7 +1780,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void subDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1791,11 +1791,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double512VectorTests::sub); + assertArraysEquals(r, a, b, DoubleVector512Tests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void SUBDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1811,11 +1811,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double512VectorTests::SUB); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::SUB); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1829,7 +1829,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double512VectorTests::sub); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::sub); } static double MUL(double a, double b) { @@ -1837,7 +1837,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MULDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void MULDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1850,7 +1850,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::MUL); + assertArraysEquals(r, a, b, DoubleVector512Tests::MUL); } static double mul(double a, double b) { @@ -1858,7 +1858,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void mulDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1869,11 +1869,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double512VectorTests::mul); + assertArraysEquals(r, a, b, DoubleVector512Tests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void MULDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1889,11 +1889,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double512VectorTests::MUL); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::MUL); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1907,7 +1907,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double512VectorTests::mul); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::mul); } static double DIV(double a, double b) { @@ -1915,7 +1915,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void DIVDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void DIVDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1928,7 +1928,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::DIV); + assertArraysEquals(r, a, b, DoubleVector512Tests::DIV); } static double div(double a, double b) { @@ -1936,7 +1936,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void divDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1947,11 +1947,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double512VectorTests::div); + assertArraysEquals(r, a, b, DoubleVector512Tests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void DIVDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1967,11 +1967,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double512VectorTests::DIV); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::DIV); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1985,7 +1985,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double512VectorTests::div); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::div); } static double FIRST_NONZERO(double a, double b) { @@ -1993,7 +1993,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void FIRST_NONZERODouble512VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZERODoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2006,11 +2006,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, DoubleVector512Tests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void FIRST_NONZERODouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZERODoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2026,11 +2026,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2040,11 +2040,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, DoubleVector512Tests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDouble512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addDoubleVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2057,11 +2057,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector512Tests::add); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2071,11 +2071,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, DoubleVector512Tests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDouble512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subDoubleVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2088,11 +2088,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector512Tests::sub); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2102,11 +2102,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, DoubleVector512Tests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDouble512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulDoubleVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2119,11 +2119,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector512Tests::mul); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2133,11 +2133,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, DoubleVector512Tests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDouble512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divDoubleVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2150,11 +2150,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector512Tests::div); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDouble512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDDoubleVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2164,11 +2164,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Double512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, DoubleVector512Tests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDouble512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDDoubleVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2181,13 +2181,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Double512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVector512Tests::ADD); } static DoubleVector bv_MIN = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MINDouble512VectorTestsWithMemOp(IntFunction fa) { + static void MINDoubleVector512TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2198,13 +2198,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double512VectorTests::MIN); + assertArraysEquals(r, a, (double)10, DoubleVector512Tests::MIN); } static DoubleVector bv_min = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void minDouble512VectorTestsWithMemOp(IntFunction fa) { + static void minDoubleVector512TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2215,13 +2215,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double512VectorTests::min); + assertArraysEquals(r, a, (double)10, DoubleVector512Tests::min); } static DoubleVector bv_MIN_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINDouble512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINDoubleVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2234,13 +2234,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, Double512VectorTests::MIN); + assertArraysEquals(r, a, (double)10, mask, DoubleVector512Tests::MIN); } static DoubleVector bv_MAX = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXDouble512VectorTestsWithMemOp(IntFunction fa) { + static void MAXDoubleVector512TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2251,13 +2251,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double512VectorTests::MAX); + assertArraysEquals(r, a, (double)10, DoubleVector512Tests::MAX); } static DoubleVector bv_max = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void maxDouble512VectorTestsWithMemOp(IntFunction fa) { + static void maxDoubleVector512TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2268,13 +2268,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double512VectorTests::max); + assertArraysEquals(r, a, (double)10, DoubleVector512Tests::max); } static DoubleVector bv_MAX_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXDouble512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXDoubleVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2287,7 +2287,7 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, Double512VectorTests::MAX); + assertArraysEquals(r, a, (double)10, mask, DoubleVector512Tests::MAX); } static double MIN(double a, double b) { @@ -2295,7 +2295,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void MINDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2308,7 +2308,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::MIN); + assertArraysEquals(r, a, b, DoubleVector512Tests::MIN); } static double min(double a, double b) { @@ -2316,7 +2316,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void minDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2327,7 +2327,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double512VectorTests::min); + assertArraysEquals(r, a, b, DoubleVector512Tests::min); } static double MAX(double a, double b) { @@ -2335,7 +2335,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void MAXDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2348,7 +2348,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::MAX); + assertArraysEquals(r, a, b, DoubleVector512Tests::MAX); } static double max(double a, double b) { @@ -2356,7 +2356,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void maxDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2367,11 +2367,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double512VectorTests::max); + assertArraysEquals(r, a, b, DoubleVector512Tests::max); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2381,11 +2381,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double512VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, DoubleVector512Tests::MIN); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2395,11 +2395,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double512VectorTests::min); + assertBroadcastArraysEquals(r, a, b, DoubleVector512Tests::min); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2409,11 +2409,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double512VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, DoubleVector512Tests::MAX); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2423,7 +2423,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double512VectorTests::max); + assertBroadcastArraysEquals(r, a, b, DoubleVector512Tests::max); } static double ADDReduce(double[] a, int idx) { @@ -2445,7 +2445,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceDouble512VectorTests(IntFunction fa) { + static void ADDReduceDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2461,7 +2461,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double512VectorTests::ADDReduce, Double512VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVector512Tests::ADDReduce, DoubleVector512Tests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2507,7 +2507,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceDouble512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceDoubleVector512TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2525,7 +2525,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double512VectorTests::ADDReduceMasked, Double512VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVector512Tests::ADDReduceMasked, DoubleVector512Tests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static double MULReduce(double[] a, int idx) { @@ -2547,7 +2547,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MULReduceDouble512VectorTests(IntFunction fa) { + static void MULReduceDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2563,7 +2563,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double512VectorTests::MULReduce, Double512VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVector512Tests::MULReduce, DoubleVector512Tests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2609,7 +2609,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MULReduceDouble512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceDoubleVector512TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2627,7 +2627,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double512VectorTests::MULReduceMasked, Double512VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVector512Tests::MULReduceMasked, DoubleVector512Tests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static double MINReduce(double[] a, int idx) { @@ -2649,7 +2649,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MINReduceDouble512VectorTests(IntFunction fa) { + static void MINReduceDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2665,7 +2665,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double512VectorTests::MINReduce, Double512VectorTests::MINReduceAll); + DoubleVector512Tests::MINReduce, DoubleVector512Tests::MINReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2711,7 +2711,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINReduceDouble512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceDoubleVector512TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2729,7 +2729,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double512VectorTests::MINReduceMasked, Double512VectorTests::MINReduceAllMasked); + DoubleVector512Tests::MINReduceMasked, DoubleVector512Tests::MINReduceAllMasked); } static double MAXReduce(double[] a, int idx) { @@ -2751,7 +2751,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXReduceDouble512VectorTests(IntFunction fa) { + static void MAXReduceDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2767,7 +2767,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double512VectorTests::MAXReduce, Double512VectorTests::MAXReduceAll); + DoubleVector512Tests::MAXReduce, DoubleVector512Tests::MAXReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2813,7 +2813,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXReduceDouble512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceDoubleVector512TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2831,7 +2831,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double512VectorTests::MAXReduceMasked, Double512VectorTests::MAXReduceAllMasked); + DoubleVector512Tests::MAXReduceMasked, DoubleVector512Tests::MAXReduceAllMasked); } static double FIRST_NONZEROReduce(double[] a, int idx) { @@ -2853,7 +2853,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void FIRST_NONZEROReduceDouble512VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2869,7 +2869,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double512VectorTests::FIRST_NONZEROReduce, Double512VectorTests::FIRST_NONZEROReduceAll); + DoubleVector512Tests::FIRST_NONZEROReduce, DoubleVector512Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2915,7 +2915,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void FIRST_NONZEROReduceDouble512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceDoubleVector512TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2933,11 +2933,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double512VectorTests::FIRST_NONZEROReduceMasked, Double512VectorTests::FIRST_NONZEROReduceAllMasked); + DoubleVector512Tests::FIRST_NONZEROReduceMasked, DoubleVector512Tests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "doubleBinaryOpProvider") - static void withDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void withDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2960,7 +2960,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_DEFAULTDouble512VectorTests(IntFunction fa) { + static void IS_DEFAULTDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2977,7 +2977,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_DEFAULTMaskedDouble512VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3001,7 +3001,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NEGATIVEDouble512VectorTests(IntFunction fa) { + static void IS_NEGATIVEDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3018,7 +3018,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NEGATIVEMaskedDouble512VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3042,7 +3042,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_FINITEDouble512VectorTests(IntFunction fa) { + static void IS_FINITEDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3059,7 +3059,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_FINITEMaskedDouble512VectorTests(IntFunction fa, + static void IS_FINITEMaskedDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3083,7 +3083,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NANDouble512VectorTests(IntFunction fa) { + static void IS_NANDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3100,7 +3100,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NANMaskedDouble512VectorTests(IntFunction fa, + static void IS_NANMaskedDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3124,7 +3124,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_INFINITEDouble512VectorTests(IntFunction fa) { + static void IS_INFINITEDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3141,7 +3141,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_INFINITEMaskedDouble512VectorTests(IntFunction fa, + static void IS_INFINITEMaskedDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3161,7 +3161,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void LTDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3180,7 +3180,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void ltDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3199,7 +3199,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3222,7 +3222,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GTDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void GTDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3241,7 +3241,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GTDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3264,7 +3264,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void EQDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3283,7 +3283,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void eqDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3302,7 +3302,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3325,7 +3325,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void NEDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void NEDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3344,7 +3344,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void NEDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3367,7 +3367,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LEDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void LEDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3386,7 +3386,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LEDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3409,7 +3409,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GEDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void GEDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3428,7 +3428,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GEDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3451,7 +3451,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3467,7 +3467,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTDoubleVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3487,7 +3487,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3503,7 +3503,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTDoubleVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3523,7 +3523,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3539,7 +3539,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQDoubleVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3559,7 +3559,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3575,7 +3575,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQDoubleVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3599,7 +3599,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDouble512VectorTests(IntFunction fa, IntFunction fb, + static void blendDoubleVector512Tests(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3615,11 +3615,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double512VectorTests::blend); + assertArraysEquals(r, a, b, mask, DoubleVector512Tests::blend); } @Test(dataProvider = "doubleUnaryOpShuffleProvider") - static void RearrangeDouble512VectorTests(IntFunction fa, + static void RearrangeDoubleVector512Tests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3636,7 +3636,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpShuffleMaskProvider") - static void RearrangeDouble512VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeDoubleVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -3654,7 +3654,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void compressDouble512VectorTests(IntFunction fa, + static void compressDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3672,7 +3672,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void expandDouble512VectorTests(IntFunction fa, + static void expandDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3690,7 +3690,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void getDouble512VectorTests(IntFunction fa) { + static void getDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3846,7 +3846,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void BroadcastDouble512VectorTests(IntFunction fa) { + static void BroadcastDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3860,7 +3860,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ZeroDouble512VectorTests(IntFunction fa) { + static void ZeroDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3885,7 +3885,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sliceUnaryDouble512VectorTests(IntFunction fa) { + static void sliceUnaryDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3896,7 +3896,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Double512VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, DoubleVector512Tests::sliceUnary); } static double[] sliceBinary(double[] a, double[] b, int origin, int idx) { @@ -3913,7 +3913,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void sliceBinaryDouble512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryDoubleVector512TestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3926,7 +3926,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, Double512VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, DoubleVector512Tests::sliceBinary); } static double[] slice(double[] a, double[] b, int origin, boolean[] mask, int idx) { @@ -3943,7 +3943,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void sliceDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3960,7 +3960,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, Double512VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, DoubleVector512Tests::slice); } static double[] unsliceUnary(double[] a, int origin, int idx) { @@ -3977,7 +3977,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void unsliceUnaryDouble512VectorTests(IntFunction fa) { + static void unsliceUnaryDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3988,7 +3988,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Double512VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, DoubleVector512Tests::unsliceUnary); } static double[] unsliceBinary(double[] a, double[] b, int origin, int part, int idx) { @@ -4014,7 +4014,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void unsliceBinaryDouble512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryDoubleVector512TestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -4028,7 +4028,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, Double512VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, DoubleVector512Tests::unsliceBinary); } static double[] unslice(double[] a, double[] b, int origin, int part, boolean[] mask, int idx) { @@ -4068,7 +4068,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void unsliceDouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceDoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4085,7 +4085,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, Double512VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, DoubleVector512Tests::unslice); } static double SIN(double a) { @@ -4097,7 +4097,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINDouble512VectorTests(IntFunction fa) { + static void SINDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4108,7 +4108,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::SIN, Double512VectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::SIN, DoubleVector512Tests::strictSIN); } static double EXP(double a) { @@ -4120,7 +4120,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPDouble512VectorTests(IntFunction fa) { + static void EXPDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4131,7 +4131,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::EXP, Double512VectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::EXP, DoubleVector512Tests::strictEXP); } static double LOG1P(double a) { @@ -4143,7 +4143,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG1PDouble512VectorTests(IntFunction fa) { + static void LOG1PDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4154,7 +4154,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::LOG1P, Double512VectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::LOG1P, DoubleVector512Tests::strictLOG1P); } static double LOG(double a) { @@ -4166,7 +4166,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOGDouble512VectorTests(IntFunction fa) { + static void LOGDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4177,7 +4177,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::LOG, Double512VectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::LOG, DoubleVector512Tests::strictLOG); } static double LOG10(double a) { @@ -4189,7 +4189,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG10Double512VectorTests(IntFunction fa) { + static void LOG10DoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4200,7 +4200,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::LOG10, Double512VectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::LOG10, DoubleVector512Tests::strictLOG10); } static double EXPM1(double a) { @@ -4212,7 +4212,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPM1Double512VectorTests(IntFunction fa) { + static void EXPM1DoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4223,7 +4223,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::EXPM1, Double512VectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::EXPM1, DoubleVector512Tests::strictEXPM1); } static double COS(double a) { @@ -4235,7 +4235,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSDouble512VectorTests(IntFunction fa) { + static void COSDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4246,7 +4246,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::COS, Double512VectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::COS, DoubleVector512Tests::strictCOS); } static double TAN(double a) { @@ -4258,7 +4258,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANDouble512VectorTests(IntFunction fa) { + static void TANDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4269,7 +4269,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::TAN, Double512VectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::TAN, DoubleVector512Tests::strictTAN); } static double SINH(double a) { @@ -4281,7 +4281,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINHDouble512VectorTests(IntFunction fa) { + static void SINHDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4292,7 +4292,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::SINH, Double512VectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::SINH, DoubleVector512Tests::strictSINH); } static double COSH(double a) { @@ -4304,7 +4304,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSHDouble512VectorTests(IntFunction fa) { + static void COSHDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4315,7 +4315,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::COSH, Double512VectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::COSH, DoubleVector512Tests::strictCOSH); } static double TANH(double a) { @@ -4327,7 +4327,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANHDouble512VectorTests(IntFunction fa) { + static void TANHDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4338,7 +4338,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::TANH, Double512VectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::TANH, DoubleVector512Tests::strictTANH); } static double ASIN(double a) { @@ -4350,7 +4350,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ASINDouble512VectorTests(IntFunction fa) { + static void ASINDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4361,7 +4361,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::ASIN, Double512VectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::ASIN, DoubleVector512Tests::strictASIN); } static double ACOS(double a) { @@ -4373,7 +4373,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ACOSDouble512VectorTests(IntFunction fa) { + static void ACOSDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4384,7 +4384,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::ACOS, Double512VectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::ACOS, DoubleVector512Tests::strictACOS); } static double ATAN(double a) { @@ -4396,7 +4396,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ATANDouble512VectorTests(IntFunction fa) { + static void ATANDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4407,7 +4407,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::ATAN, Double512VectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::ATAN, DoubleVector512Tests::strictATAN); } static double CBRT(double a) { @@ -4419,7 +4419,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void CBRTDouble512VectorTests(IntFunction fa) { + static void CBRTDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4430,7 +4430,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double512VectorTests::CBRT, Double512VectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector512Tests::CBRT, DoubleVector512Tests::strictCBRT); } static double HYPOT(double a, double b) { @@ -4442,7 +4442,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void HYPOTDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4455,7 +4455,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double512VectorTests::HYPOT, Double512VectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector512Tests::HYPOT, DoubleVector512Tests::strictHYPOT); } @@ -4468,7 +4468,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void POWDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4481,7 +4481,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double512VectorTests::POW, Double512VectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector512Tests::POW, DoubleVector512Tests::strictPOW); } @@ -4494,7 +4494,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void powDoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4507,7 +4507,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double512VectorTests::pow, Double512VectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector512Tests::pow, DoubleVector512Tests::strictpow); } @@ -4520,7 +4520,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ATAN2Double512VectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2DoubleVector512Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4533,12 +4533,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double512VectorTests::ATAN2, Double512VectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector512Tests::ATAN2, DoubleVector512Tests::strictATAN2); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4548,12 +4548,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double512VectorTests::POW, Double512VectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVector512Tests::POW, DoubleVector512Tests::strictPOW); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4563,7 +4563,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double512VectorTests::pow, Double512VectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVector512Tests::pow, DoubleVector512Tests::strictpow); } @@ -4576,7 +4576,7 @@ relativeError)); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4598,11 +4598,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, Double512VectorTests::FMA); + assertArraysEquals(r, a, b, c, DoubleVector512Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDouble512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4622,11 +4622,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Double512VectorTests::fma); + assertArraysEquals(r, a, b, c, DoubleVector512Tests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMADoubleVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4651,11 +4651,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, Double512VectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, DoubleVector512Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4666,11 +4666,11 @@ relativeError)); DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Double512VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, DoubleVector512Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4681,11 +4681,11 @@ relativeError)); DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Double512VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, DoubleVector512Tests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4700,11 +4700,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Double512VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, DoubleVector512Tests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble512VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector512TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4719,11 +4719,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Double512VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, DoubleVector512Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4741,11 +4741,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Double512VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVector512Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDouble512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4763,11 +4763,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Double512VectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVector512Tests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble512VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector512TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4788,7 +4788,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Double512VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, DoubleVector512Tests::FMA); } static double NEG(double a) { @@ -4800,7 +4800,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void NEGDouble512VectorTests(IntFunction fa) { + static void NEGDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4811,11 +4811,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double512VectorTests::NEG); + assertArraysEquals(r, a, DoubleVector512Tests::NEG); } @Test(dataProvider = "doubleUnaryOpProvider") - static void negDouble512VectorTests(IntFunction fa) { + static void negDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4826,11 +4826,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double512VectorTests::neg); + assertArraysEquals(r, a, DoubleVector512Tests::neg); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void NEGMaskedDouble512VectorTests(IntFunction fa, + static void NEGMaskedDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4844,7 +4844,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double512VectorTests::NEG); + assertArraysEquals(r, a, mask, DoubleVector512Tests::NEG); } static double ABS(double a) { @@ -4856,7 +4856,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ABSDouble512VectorTests(IntFunction fa) { + static void ABSDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4867,11 +4867,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double512VectorTests::ABS); + assertArraysEquals(r, a, DoubleVector512Tests::ABS); } @Test(dataProvider = "doubleUnaryOpProvider") - static void absDouble512VectorTests(IntFunction fa) { + static void absDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4882,11 +4882,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double512VectorTests::abs); + assertArraysEquals(r, a, DoubleVector512Tests::abs); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ABSMaskedDouble512VectorTests(IntFunction fa, + static void ABSMaskedDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4900,7 +4900,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double512VectorTests::ABS); + assertArraysEquals(r, a, mask, DoubleVector512Tests::ABS); } static double SQRT(double a) { @@ -4912,7 +4912,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SQRTDouble512VectorTests(IntFunction fa) { + static void SQRTDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4923,11 +4923,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double512VectorTests::SQRT); + assertArraysEquals(r, a, DoubleVector512Tests::SQRT); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sqrtDouble512VectorTests(IntFunction fa) { + static void sqrtDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4938,11 +4938,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double512VectorTests::sqrt); + assertArraysEquals(r, a, DoubleVector512Tests::sqrt); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void SQRTMaskedDouble512VectorTests(IntFunction fa, + static void SQRTMaskedDoubleVector512Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4956,7 +4956,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double512VectorTests::SQRT); + assertArraysEquals(r, a, mask, DoubleVector512Tests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4964,7 +4964,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandDoubleVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4977,7 +4977,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::band); + assertArraysEquals(r, a, b, DoubleVector512Tests::band); } static boolean bor(boolean a, boolean b) { @@ -4985,7 +4985,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void maskorDoubleVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4998,7 +4998,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::bor); + assertArraysEquals(r, a, b, DoubleVector512Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -5006,7 +5006,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorDoubleVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5019,7 +5019,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::bxor); + assertArraysEquals(r, a, b, DoubleVector512Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5027,7 +5027,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotDoubleVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5040,7 +5040,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::bandNot); + assertArraysEquals(r, a, b, DoubleVector512Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5048,7 +5048,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqDoubleVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5061,7 +5061,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double512VectorTests::beq); + assertArraysEquals(r, a, b, DoubleVector512Tests::beq); } static boolean unot(boolean a) { @@ -5069,7 +5069,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotDouble512VectorTests(IntFunction fa) { + static void masknotDoubleVector512Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5080,7 +5080,7 @@ relativeError)); } } - assertArraysEquals(r, a, Double512VectorTests::unot); + assertArraysEquals(r, a, DoubleVector512Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5097,7 +5097,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongDouble512VectorTests(IntFunction fa) { + static void maskFromToLongDoubleVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5111,7 +5111,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDouble512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltDoubleVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5127,7 +5127,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDouble512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqDoubleVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5143,7 +5143,7 @@ relativeError)); } @Test(dataProvider = "doubletoIntUnaryOpProvider") - static void toIntArrayDouble512VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayDoubleVector512TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5154,7 +5154,7 @@ relativeError)); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void toLongArrayDouble512VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayDoubleVector512TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5166,7 +5166,7 @@ relativeError)); @Test(dataProvider = "doubleUnaryOpProvider") - static void toStringDouble512VectorTestsSmokeTest(IntFunction fa) { + static void toStringDoubleVector512TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5179,7 +5179,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void hashCodeDouble512VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeDoubleVector512TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5212,7 +5212,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceLongDouble512VectorTests(IntFunction fa) { + static void ADDReduceLongDoubleVector512Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5228,7 +5228,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - Double512VectorTests::ADDReduceLong, Double512VectorTests::ADDReduceAllLong); + DoubleVector512Tests::ADDReduceLong, DoubleVector512Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(double[] a, int idx, boolean[] mask) { @@ -5251,7 +5251,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceLongDouble512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongDoubleVector512TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5269,11 +5269,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Double512VectorTests::ADDReduceLongMasked, Double512VectorTests::ADDReduceAllLongMasked); + DoubleVector512Tests::ADDReduceLongMasked, DoubleVector512Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void BroadcastLongDouble512VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongDoubleVector512TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -5284,7 +5284,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDouble512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendDoubleVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5298,12 +5298,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Double512VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVector512Tests::blend); } @Test(dataProvider = "doubleUnaryOpSelectFromProvider") - static void SelectFromDouble512VectorTests(IntFunction fa, + static void SelectFromDoubleVector512Tests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); double[] order = fs.apply(a.length, SPECIES.length()); @@ -5319,7 +5319,7 @@ relativeError)); } @Test(dataProvider = "doubleSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorDouble512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorDoubleVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] idx = fc.apply(SPECIES.length()); @@ -5337,7 +5337,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpSelectFromMaskProvider") - static void SelectFromDouble512VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromDoubleVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -5356,7 +5356,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousDouble512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousDoubleVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5372,7 +5372,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringDouble512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringDoubleVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5386,7 +5386,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsDouble512VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsDoubleVector512TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5400,7 +5400,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsDouble512VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsDoubleVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5416,7 +5416,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeDouble512VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeDoubleVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5438,7 +5438,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountDouble512VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountDoubleVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5449,7 +5449,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double512VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, DoubleVector512Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5463,7 +5463,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueDouble512VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueDoubleVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5474,7 +5474,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double512VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, DoubleVector512Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5488,7 +5488,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueDouble512VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueDoubleVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5499,11 +5499,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double512VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, DoubleVector512Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressDouble512VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressDoubleVector512TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5531,7 +5531,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeDouble512VectorTestsSmokeTest(int offset) { + static void indexInRangeDoubleVector512TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5545,7 +5545,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongDouble512VectorTestsSmokeTest(int offset) { + static void indexInRangeLongDoubleVector512TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5572,14 +5572,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundDouble512VectorTestsSmokeTest(int length) { + static void loopBoundDoubleVector512TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongDouble512VectorTestsSmokeTest(int _length) { + static void loopBoundLongDoubleVector512TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5587,21 +5587,21 @@ relativeError)); } @Test - static void ElementSizeDouble512VectorTestsSmokeTest() { + static void ElementSizeDoubleVector512TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Double.SIZE); } @Test - static void VectorShapeDouble512VectorTestsSmokeTest() { + static void VectorShapeDoubleVector512TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_512_BIT)); } @Test - static void ShapeWithLanesDouble512VectorTestsSmokeTest() { + static void ShapeWithLanesDoubleVector512TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(double.class); @@ -5609,32 +5609,32 @@ relativeError)); } @Test - static void ElementTypeDouble512VectorTestsSmokeTest() { + static void ElementTypeDoubleVector512TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementType() == double.class); } @Test - static void SpeciesElementSizeDouble512VectorTestsSmokeTest() { + static void SpeciesElementSizeDoubleVector512TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementSize() == Double.SIZE); } @Test - static void VectorTypeDouble512VectorTestsSmokeTest() { + static void VectorTypeDoubleVector512TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesDouble512VectorTestsSmokeTest() { + static void WithLanesDoubleVector512TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(double.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeDouble512VectorTestsSmokeTest() { + static void WithShapeDoubleVector512TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5642,7 +5642,7 @@ relativeError)); } @Test - static void MaskAllTrueDouble512VectorTestsSmokeTest() { + static void MaskAllTrueDoubleVector512TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Double64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/DoubleVector64LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Double64VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/DoubleVector64LoadStoreTests.java index 30c4b92aa86..f07f5be00db 100644 --- a/test/jdk/jdk/incubator/vector/Double64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVector64LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Double64VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation DoubleVector64LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Double64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class DoubleVector64LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_64; diff --git a/test/jdk/jdk/incubator/vector/Double64VectorTests.java b/test/jdk/jdk/incubator/vector/DoubleVector64Tests.java similarity index 91% rename from test/jdk/jdk/incubator/vector/Double64VectorTests.java rename to test/jdk/jdk/incubator/vector/DoubleVector64Tests.java index 2cc56b1bce3..7f9f8986f1f 100644 --- a/test/jdk/jdk/incubator/vector/Double64VectorTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVector64Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Double64VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation DoubleVector64Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Double64VectorTests extends AbstractVectorTest { +public class DoubleVector64Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_64; @@ -1681,7 +1681,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void ADDDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1694,7 +1694,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::ADD); + assertArraysEquals(r, a, b, DoubleVector64Tests::ADD); } static double add(double a, double b) { @@ -1702,7 +1702,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void addDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1713,11 +1713,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double64VectorTests::add); + assertArraysEquals(r, a, b, DoubleVector64Tests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1733,11 +1733,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double64VectorTests::ADD); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1751,7 +1751,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double64VectorTests::add); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::add); } static double SUB(double a, double b) { @@ -1759,7 +1759,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void SUBDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void SUBDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1772,7 +1772,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::SUB); + assertArraysEquals(r, a, b, DoubleVector64Tests::SUB); } static double sub(double a, double b) { @@ -1780,7 +1780,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void subDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1791,11 +1791,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double64VectorTests::sub); + assertArraysEquals(r, a, b, DoubleVector64Tests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void SUBDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1811,11 +1811,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double64VectorTests::SUB); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::SUB); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1829,7 +1829,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double64VectorTests::sub); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::sub); } static double MUL(double a, double b) { @@ -1837,7 +1837,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MULDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void MULDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1850,7 +1850,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::MUL); + assertArraysEquals(r, a, b, DoubleVector64Tests::MUL); } static double mul(double a, double b) { @@ -1858,7 +1858,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void mulDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1869,11 +1869,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double64VectorTests::mul); + assertArraysEquals(r, a, b, DoubleVector64Tests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void MULDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1889,11 +1889,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double64VectorTests::MUL); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::MUL); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1907,7 +1907,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double64VectorTests::mul); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::mul); } static double DIV(double a, double b) { @@ -1915,7 +1915,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void DIVDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void DIVDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1928,7 +1928,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::DIV); + assertArraysEquals(r, a, b, DoubleVector64Tests::DIV); } static double div(double a, double b) { @@ -1936,7 +1936,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void divDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1947,11 +1947,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double64VectorTests::div); + assertArraysEquals(r, a, b, DoubleVector64Tests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void DIVDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1967,11 +1967,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double64VectorTests::DIV); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::DIV); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1985,7 +1985,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Double64VectorTests::div); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::div); } static double FIRST_NONZERO(double a, double b) { @@ -1993,7 +1993,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void FIRST_NONZERODouble64VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZERODoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2006,11 +2006,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, DoubleVector64Tests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void FIRST_NONZERODouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZERODoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2026,11 +2026,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2040,11 +2040,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, DoubleVector64Tests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDouble64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addDoubleVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2057,11 +2057,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector64Tests::add); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2071,11 +2071,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, DoubleVector64Tests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDouble64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subDoubleVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2088,11 +2088,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector64Tests::sub); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2102,11 +2102,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, DoubleVector64Tests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDouble64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulDoubleVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2119,11 +2119,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector64Tests::mul); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2133,11 +2133,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, DoubleVector64Tests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDouble64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divDoubleVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2150,11 +2150,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Double64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVector64Tests::div); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDouble64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDDoubleVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2164,11 +2164,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Double64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, DoubleVector64Tests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDouble64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDDoubleVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2181,13 +2181,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Double64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVector64Tests::ADD); } static DoubleVector bv_MIN = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MINDouble64VectorTestsWithMemOp(IntFunction fa) { + static void MINDoubleVector64TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2198,13 +2198,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double64VectorTests::MIN); + assertArraysEquals(r, a, (double)10, DoubleVector64Tests::MIN); } static DoubleVector bv_min = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void minDouble64VectorTestsWithMemOp(IntFunction fa) { + static void minDoubleVector64TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2215,13 +2215,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double64VectorTests::min); + assertArraysEquals(r, a, (double)10, DoubleVector64Tests::min); } static DoubleVector bv_MIN_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINDouble64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINDoubleVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2234,13 +2234,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, Double64VectorTests::MIN); + assertArraysEquals(r, a, (double)10, mask, DoubleVector64Tests::MIN); } static DoubleVector bv_MAX = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXDouble64VectorTestsWithMemOp(IntFunction fa) { + static void MAXDoubleVector64TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2251,13 +2251,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double64VectorTests::MAX); + assertArraysEquals(r, a, (double)10, DoubleVector64Tests::MAX); } static DoubleVector bv_max = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void maxDouble64VectorTestsWithMemOp(IntFunction fa) { + static void maxDoubleVector64TestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2268,13 +2268,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, Double64VectorTests::max); + assertArraysEquals(r, a, (double)10, DoubleVector64Tests::max); } static DoubleVector bv_MAX_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXDouble64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXDoubleVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2287,7 +2287,7 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, Double64VectorTests::MAX); + assertArraysEquals(r, a, (double)10, mask, DoubleVector64Tests::MAX); } static double MIN(double a, double b) { @@ -2295,7 +2295,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void MINDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2308,7 +2308,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::MIN); + assertArraysEquals(r, a, b, DoubleVector64Tests::MIN); } static double min(double a, double b) { @@ -2316,7 +2316,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void minDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2327,7 +2327,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double64VectorTests::min); + assertArraysEquals(r, a, b, DoubleVector64Tests::min); } static double MAX(double a, double b) { @@ -2335,7 +2335,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void MAXDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2348,7 +2348,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::MAX); + assertArraysEquals(r, a, b, DoubleVector64Tests::MAX); } static double max(double a, double b) { @@ -2356,7 +2356,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void maxDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2367,11 +2367,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Double64VectorTests::max); + assertArraysEquals(r, a, b, DoubleVector64Tests::max); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2381,11 +2381,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double64VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, DoubleVector64Tests::MIN); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2395,11 +2395,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double64VectorTests::min); + assertBroadcastArraysEquals(r, a, b, DoubleVector64Tests::min); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2409,11 +2409,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double64VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, DoubleVector64Tests::MAX); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2423,7 +2423,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Double64VectorTests::max); + assertBroadcastArraysEquals(r, a, b, DoubleVector64Tests::max); } static double ADDReduce(double[] a, int idx) { @@ -2445,7 +2445,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceDouble64VectorTests(IntFunction fa) { + static void ADDReduceDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2461,7 +2461,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double64VectorTests::ADDReduce, Double64VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVector64Tests::ADDReduce, DoubleVector64Tests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2507,7 +2507,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceDouble64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceDoubleVector64TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2525,7 +2525,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double64VectorTests::ADDReduceMasked, Double64VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVector64Tests::ADDReduceMasked, DoubleVector64Tests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static double MULReduce(double[] a, int idx) { @@ -2547,7 +2547,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MULReduceDouble64VectorTests(IntFunction fa) { + static void MULReduceDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2563,7 +2563,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double64VectorTests::MULReduce, Double64VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVector64Tests::MULReduce, DoubleVector64Tests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2609,7 +2609,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MULReduceDouble64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceDoubleVector64TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2627,7 +2627,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double64VectorTests::MULReduceMasked, Double64VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVector64Tests::MULReduceMasked, DoubleVector64Tests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static double MINReduce(double[] a, int idx) { @@ -2649,7 +2649,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MINReduceDouble64VectorTests(IntFunction fa) { + static void MINReduceDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2665,7 +2665,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double64VectorTests::MINReduce, Double64VectorTests::MINReduceAll); + DoubleVector64Tests::MINReduce, DoubleVector64Tests::MINReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2711,7 +2711,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINReduceDouble64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceDoubleVector64TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2729,7 +2729,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double64VectorTests::MINReduceMasked, Double64VectorTests::MINReduceAllMasked); + DoubleVector64Tests::MINReduceMasked, DoubleVector64Tests::MINReduceAllMasked); } static double MAXReduce(double[] a, int idx) { @@ -2751,7 +2751,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXReduceDouble64VectorTests(IntFunction fa) { + static void MAXReduceDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2767,7 +2767,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double64VectorTests::MAXReduce, Double64VectorTests::MAXReduceAll); + DoubleVector64Tests::MAXReduce, DoubleVector64Tests::MAXReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2813,7 +2813,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXReduceDouble64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceDoubleVector64TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2831,7 +2831,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double64VectorTests::MAXReduceMasked, Double64VectorTests::MAXReduceAllMasked); + DoubleVector64Tests::MAXReduceMasked, DoubleVector64Tests::MAXReduceAllMasked); } static double FIRST_NONZEROReduce(double[] a, int idx) { @@ -2853,7 +2853,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void FIRST_NONZEROReduceDouble64VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2869,7 +2869,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Double64VectorTests::FIRST_NONZEROReduce, Double64VectorTests::FIRST_NONZEROReduceAll); + DoubleVector64Tests::FIRST_NONZEROReduce, DoubleVector64Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2915,7 +2915,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void FIRST_NONZEROReduceDouble64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceDoubleVector64TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2933,11 +2933,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Double64VectorTests::FIRST_NONZEROReduceMasked, Double64VectorTests::FIRST_NONZEROReduceAllMasked); + DoubleVector64Tests::FIRST_NONZEROReduceMasked, DoubleVector64Tests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "doubleBinaryOpProvider") - static void withDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void withDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2960,7 +2960,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_DEFAULTDouble64VectorTests(IntFunction fa) { + static void IS_DEFAULTDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2977,7 +2977,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_DEFAULTMaskedDouble64VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3001,7 +3001,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NEGATIVEDouble64VectorTests(IntFunction fa) { + static void IS_NEGATIVEDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3018,7 +3018,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NEGATIVEMaskedDouble64VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3042,7 +3042,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_FINITEDouble64VectorTests(IntFunction fa) { + static void IS_FINITEDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3059,7 +3059,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_FINITEMaskedDouble64VectorTests(IntFunction fa, + static void IS_FINITEMaskedDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3083,7 +3083,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NANDouble64VectorTests(IntFunction fa) { + static void IS_NANDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3100,7 +3100,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NANMaskedDouble64VectorTests(IntFunction fa, + static void IS_NANMaskedDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3124,7 +3124,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_INFINITEDouble64VectorTests(IntFunction fa) { + static void IS_INFINITEDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3141,7 +3141,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_INFINITEMaskedDouble64VectorTests(IntFunction fa, + static void IS_INFINITEMaskedDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3161,7 +3161,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void LTDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3180,7 +3180,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void ltDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3199,7 +3199,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3222,7 +3222,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GTDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void GTDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3241,7 +3241,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GTDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3264,7 +3264,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void EQDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3283,7 +3283,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void eqDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3302,7 +3302,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3325,7 +3325,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void NEDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void NEDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3344,7 +3344,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void NEDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3367,7 +3367,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LEDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void LEDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3386,7 +3386,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LEDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3409,7 +3409,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GEDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void GEDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3428,7 +3428,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GEDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3451,7 +3451,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3467,7 +3467,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTDoubleVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3487,7 +3487,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDouble64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3503,7 +3503,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDouble64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTDoubleVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3523,7 +3523,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3539,7 +3539,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQDoubleVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3559,7 +3559,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDouble64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3575,7 +3575,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDouble64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQDoubleVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3599,7 +3599,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDouble64VectorTests(IntFunction fa, IntFunction fb, + static void blendDoubleVector64Tests(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3615,11 +3615,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Double64VectorTests::blend); + assertArraysEquals(r, a, b, mask, DoubleVector64Tests::blend); } @Test(dataProvider = "doubleUnaryOpShuffleProvider") - static void RearrangeDouble64VectorTests(IntFunction fa, + static void RearrangeDoubleVector64Tests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3636,7 +3636,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpShuffleMaskProvider") - static void RearrangeDouble64VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeDoubleVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -3654,7 +3654,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void compressDouble64VectorTests(IntFunction fa, + static void compressDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3672,7 +3672,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void expandDouble64VectorTests(IntFunction fa, + static void expandDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3690,7 +3690,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void getDouble64VectorTests(IntFunction fa) { + static void getDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3846,7 +3846,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void BroadcastDouble64VectorTests(IntFunction fa) { + static void BroadcastDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3860,7 +3860,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ZeroDouble64VectorTests(IntFunction fa) { + static void ZeroDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3885,7 +3885,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sliceUnaryDouble64VectorTests(IntFunction fa) { + static void sliceUnaryDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3896,7 +3896,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Double64VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, DoubleVector64Tests::sliceUnary); } static double[] sliceBinary(double[] a, double[] b, int origin, int idx) { @@ -3913,7 +3913,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void sliceBinaryDouble64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryDoubleVector64TestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3926,7 +3926,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, Double64VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, DoubleVector64Tests::sliceBinary); } static double[] slice(double[] a, double[] b, int origin, boolean[] mask, int idx) { @@ -3943,7 +3943,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void sliceDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3960,7 +3960,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, Double64VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, DoubleVector64Tests::slice); } static double[] unsliceUnary(double[] a, int origin, int idx) { @@ -3977,7 +3977,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void unsliceUnaryDouble64VectorTests(IntFunction fa) { + static void unsliceUnaryDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3988,7 +3988,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Double64VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, DoubleVector64Tests::unsliceUnary); } static double[] unsliceBinary(double[] a, double[] b, int origin, int part, int idx) { @@ -4014,7 +4014,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void unsliceBinaryDouble64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryDoubleVector64TestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -4028,7 +4028,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, Double64VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, DoubleVector64Tests::unsliceBinary); } static double[] unslice(double[] a, double[] b, int origin, int part, boolean[] mask, int idx) { @@ -4068,7 +4068,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void unsliceDouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceDoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4085,7 +4085,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, Double64VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, DoubleVector64Tests::unslice); } static double SIN(double a) { @@ -4097,7 +4097,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINDouble64VectorTests(IntFunction fa) { + static void SINDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4108,7 +4108,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::SIN, Double64VectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::SIN, DoubleVector64Tests::strictSIN); } static double EXP(double a) { @@ -4120,7 +4120,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPDouble64VectorTests(IntFunction fa) { + static void EXPDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4131,7 +4131,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::EXP, Double64VectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::EXP, DoubleVector64Tests::strictEXP); } static double LOG1P(double a) { @@ -4143,7 +4143,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG1PDouble64VectorTests(IntFunction fa) { + static void LOG1PDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4154,7 +4154,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::LOG1P, Double64VectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::LOG1P, DoubleVector64Tests::strictLOG1P); } static double LOG(double a) { @@ -4166,7 +4166,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOGDouble64VectorTests(IntFunction fa) { + static void LOGDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4177,7 +4177,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::LOG, Double64VectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::LOG, DoubleVector64Tests::strictLOG); } static double LOG10(double a) { @@ -4189,7 +4189,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG10Double64VectorTests(IntFunction fa) { + static void LOG10DoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4200,7 +4200,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::LOG10, Double64VectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::LOG10, DoubleVector64Tests::strictLOG10); } static double EXPM1(double a) { @@ -4212,7 +4212,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPM1Double64VectorTests(IntFunction fa) { + static void EXPM1DoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4223,7 +4223,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::EXPM1, Double64VectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::EXPM1, DoubleVector64Tests::strictEXPM1); } static double COS(double a) { @@ -4235,7 +4235,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSDouble64VectorTests(IntFunction fa) { + static void COSDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4246,7 +4246,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::COS, Double64VectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::COS, DoubleVector64Tests::strictCOS); } static double TAN(double a) { @@ -4258,7 +4258,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANDouble64VectorTests(IntFunction fa) { + static void TANDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4269,7 +4269,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::TAN, Double64VectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::TAN, DoubleVector64Tests::strictTAN); } static double SINH(double a) { @@ -4281,7 +4281,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINHDouble64VectorTests(IntFunction fa) { + static void SINHDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4292,7 +4292,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::SINH, Double64VectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::SINH, DoubleVector64Tests::strictSINH); } static double COSH(double a) { @@ -4304,7 +4304,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSHDouble64VectorTests(IntFunction fa) { + static void COSHDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4315,7 +4315,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::COSH, Double64VectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::COSH, DoubleVector64Tests::strictCOSH); } static double TANH(double a) { @@ -4327,7 +4327,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANHDouble64VectorTests(IntFunction fa) { + static void TANHDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4338,7 +4338,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::TANH, Double64VectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::TANH, DoubleVector64Tests::strictTANH); } static double ASIN(double a) { @@ -4350,7 +4350,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ASINDouble64VectorTests(IntFunction fa) { + static void ASINDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4361,7 +4361,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::ASIN, Double64VectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::ASIN, DoubleVector64Tests::strictASIN); } static double ACOS(double a) { @@ -4373,7 +4373,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ACOSDouble64VectorTests(IntFunction fa) { + static void ACOSDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4384,7 +4384,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::ACOS, Double64VectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::ACOS, DoubleVector64Tests::strictACOS); } static double ATAN(double a) { @@ -4396,7 +4396,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ATANDouble64VectorTests(IntFunction fa) { + static void ATANDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4407,7 +4407,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::ATAN, Double64VectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::ATAN, DoubleVector64Tests::strictATAN); } static double CBRT(double a) { @@ -4419,7 +4419,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void CBRTDouble64VectorTests(IntFunction fa) { + static void CBRTDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4430,7 +4430,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Double64VectorTests::CBRT, Double64VectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, DoubleVector64Tests::CBRT, DoubleVector64Tests::strictCBRT); } static double HYPOT(double a, double b) { @@ -4442,7 +4442,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void HYPOTDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4455,7 +4455,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double64VectorTests::HYPOT, Double64VectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector64Tests::HYPOT, DoubleVector64Tests::strictHYPOT); } @@ -4468,7 +4468,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void POWDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4481,7 +4481,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double64VectorTests::POW, Double64VectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector64Tests::POW, DoubleVector64Tests::strictPOW); } @@ -4494,7 +4494,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void powDoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4507,7 +4507,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double64VectorTests::pow, Double64VectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector64Tests::pow, DoubleVector64Tests::strictpow); } @@ -4520,7 +4520,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ATAN2Double64VectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2DoubleVector64Tests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4533,12 +4533,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Double64VectorTests::ATAN2, Double64VectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVector64Tests::ATAN2, DoubleVector64Tests::strictATAN2); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4548,12 +4548,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double64VectorTests::POW, Double64VectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVector64Tests::POW, DoubleVector64Tests::strictPOW); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4563,7 +4563,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double64VectorTests::pow, Double64VectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVector64Tests::pow, DoubleVector64Tests::strictpow); } @@ -4576,7 +4576,7 @@ relativeError)); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4598,11 +4598,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, Double64VectorTests::FMA); + assertArraysEquals(r, a, b, c, DoubleVector64Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDouble64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4622,11 +4622,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Double64VectorTests::fma); + assertArraysEquals(r, a, b, c, DoubleVector64Tests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMADoubleVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4651,11 +4651,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, Double64VectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, DoubleVector64Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4666,11 +4666,11 @@ relativeError)); DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Double64VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, DoubleVector64Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4681,11 +4681,11 @@ relativeError)); DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Double64VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, DoubleVector64Tests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4700,11 +4700,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Double64VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, DoubleVector64Tests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble64VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector64TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4719,11 +4719,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Double64VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, DoubleVector64Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADouble64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4741,11 +4741,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Double64VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVector64Tests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDouble64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4763,11 +4763,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Double64VectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVector64Tests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADouble64VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVector64TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4788,7 +4788,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Double64VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, DoubleVector64Tests::FMA); } static double NEG(double a) { @@ -4800,7 +4800,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void NEGDouble64VectorTests(IntFunction fa) { + static void NEGDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4811,11 +4811,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double64VectorTests::NEG); + assertArraysEquals(r, a, DoubleVector64Tests::NEG); } @Test(dataProvider = "doubleUnaryOpProvider") - static void negDouble64VectorTests(IntFunction fa) { + static void negDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4826,11 +4826,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double64VectorTests::neg); + assertArraysEquals(r, a, DoubleVector64Tests::neg); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void NEGMaskedDouble64VectorTests(IntFunction fa, + static void NEGMaskedDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4844,7 +4844,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double64VectorTests::NEG); + assertArraysEquals(r, a, mask, DoubleVector64Tests::NEG); } static double ABS(double a) { @@ -4856,7 +4856,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ABSDouble64VectorTests(IntFunction fa) { + static void ABSDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4867,11 +4867,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double64VectorTests::ABS); + assertArraysEquals(r, a, DoubleVector64Tests::ABS); } @Test(dataProvider = "doubleUnaryOpProvider") - static void absDouble64VectorTests(IntFunction fa) { + static void absDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4882,11 +4882,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double64VectorTests::abs); + assertArraysEquals(r, a, DoubleVector64Tests::abs); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ABSMaskedDouble64VectorTests(IntFunction fa, + static void ABSMaskedDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4900,7 +4900,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double64VectorTests::ABS); + assertArraysEquals(r, a, mask, DoubleVector64Tests::ABS); } static double SQRT(double a) { @@ -4912,7 +4912,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SQRTDouble64VectorTests(IntFunction fa) { + static void SQRTDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4923,11 +4923,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double64VectorTests::SQRT); + assertArraysEquals(r, a, DoubleVector64Tests::SQRT); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sqrtDouble64VectorTests(IntFunction fa) { + static void sqrtDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4938,11 +4938,11 @@ relativeError)); } } - assertArraysEquals(r, a, Double64VectorTests::sqrt); + assertArraysEquals(r, a, DoubleVector64Tests::sqrt); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void SQRTMaskedDouble64VectorTests(IntFunction fa, + static void SQRTMaskedDoubleVector64Tests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4956,7 +4956,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Double64VectorTests::SQRT); + assertArraysEquals(r, a, mask, DoubleVector64Tests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4964,7 +4964,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandDoubleVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4977,7 +4977,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::band); + assertArraysEquals(r, a, b, DoubleVector64Tests::band); } static boolean bor(boolean a, boolean b) { @@ -4985,7 +4985,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void maskorDoubleVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4998,7 +4998,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::bor); + assertArraysEquals(r, a, b, DoubleVector64Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -5006,7 +5006,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorDoubleVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5019,7 +5019,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::bxor); + assertArraysEquals(r, a, b, DoubleVector64Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5027,7 +5027,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotDoubleVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5040,7 +5040,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::bandNot); + assertArraysEquals(r, a, b, DoubleVector64Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5048,7 +5048,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqDoubleVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5061,7 +5061,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Double64VectorTests::beq); + assertArraysEquals(r, a, b, DoubleVector64Tests::beq); } static boolean unot(boolean a) { @@ -5069,7 +5069,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotDouble64VectorTests(IntFunction fa) { + static void masknotDoubleVector64Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5080,7 +5080,7 @@ relativeError)); } } - assertArraysEquals(r, a, Double64VectorTests::unot); + assertArraysEquals(r, a, DoubleVector64Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5097,7 +5097,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongDouble64VectorTests(IntFunction fa) { + static void maskFromToLongDoubleVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5111,7 +5111,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDouble64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltDoubleVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5127,7 +5127,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDouble64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqDoubleVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5143,7 +5143,7 @@ relativeError)); } @Test(dataProvider = "doubletoIntUnaryOpProvider") - static void toIntArrayDouble64VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayDoubleVector64TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5154,7 +5154,7 @@ relativeError)); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void toLongArrayDouble64VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayDoubleVector64TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5166,7 +5166,7 @@ relativeError)); @Test(dataProvider = "doubleUnaryOpProvider") - static void toStringDouble64VectorTestsSmokeTest(IntFunction fa) { + static void toStringDoubleVector64TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5179,7 +5179,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void hashCodeDouble64VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeDoubleVector64TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5212,7 +5212,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceLongDouble64VectorTests(IntFunction fa) { + static void ADDReduceLongDoubleVector64Tests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5228,7 +5228,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - Double64VectorTests::ADDReduceLong, Double64VectorTests::ADDReduceAllLong); + DoubleVector64Tests::ADDReduceLong, DoubleVector64Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(double[] a, int idx, boolean[] mask) { @@ -5251,7 +5251,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceLongDouble64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongDoubleVector64TestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5269,11 +5269,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Double64VectorTests::ADDReduceLongMasked, Double64VectorTests::ADDReduceAllLongMasked); + DoubleVector64Tests::ADDReduceLongMasked, DoubleVector64Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void BroadcastLongDouble64VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongDoubleVector64TestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -5284,7 +5284,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDouble64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendDoubleVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5298,12 +5298,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Double64VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVector64Tests::blend); } @Test(dataProvider = "doubleUnaryOpSelectFromProvider") - static void SelectFromDouble64VectorTests(IntFunction fa, + static void SelectFromDoubleVector64Tests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); double[] order = fs.apply(a.length, SPECIES.length()); @@ -5319,7 +5319,7 @@ relativeError)); } @Test(dataProvider = "doubleSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorDouble64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorDoubleVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] idx = fc.apply(SPECIES.length()); @@ -5337,7 +5337,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpSelectFromMaskProvider") - static void SelectFromDouble64VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromDoubleVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -5356,7 +5356,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousDouble64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousDoubleVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5372,7 +5372,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringDouble64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringDoubleVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5386,7 +5386,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsDouble64VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsDoubleVector64TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5400,7 +5400,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsDouble64VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsDoubleVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5416,7 +5416,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeDouble64VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeDoubleVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5438,7 +5438,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountDouble64VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountDoubleVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5449,7 +5449,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double64VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, DoubleVector64Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5463,7 +5463,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueDouble64VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueDoubleVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5474,7 +5474,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double64VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, DoubleVector64Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5488,7 +5488,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueDouble64VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueDoubleVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5499,11 +5499,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Double64VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, DoubleVector64Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressDouble64VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressDoubleVector64TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5531,7 +5531,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeDouble64VectorTestsSmokeTest(int offset) { + static void indexInRangeDoubleVector64TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5545,7 +5545,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongDouble64VectorTestsSmokeTest(int offset) { + static void indexInRangeLongDoubleVector64TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5572,14 +5572,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundDouble64VectorTestsSmokeTest(int length) { + static void loopBoundDoubleVector64TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongDouble64VectorTestsSmokeTest(int _length) { + static void loopBoundLongDoubleVector64TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5587,21 +5587,21 @@ relativeError)); } @Test - static void ElementSizeDouble64VectorTestsSmokeTest() { + static void ElementSizeDoubleVector64TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Double.SIZE); } @Test - static void VectorShapeDouble64VectorTestsSmokeTest() { + static void VectorShapeDoubleVector64TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_64_BIT)); } @Test - static void ShapeWithLanesDouble64VectorTestsSmokeTest() { + static void ShapeWithLanesDoubleVector64TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(double.class); @@ -5609,32 +5609,32 @@ relativeError)); } @Test - static void ElementTypeDouble64VectorTestsSmokeTest() { + static void ElementTypeDoubleVector64TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementType() == double.class); } @Test - static void SpeciesElementSizeDouble64VectorTestsSmokeTest() { + static void SpeciesElementSizeDoubleVector64TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementSize() == Double.SIZE); } @Test - static void VectorTypeDouble64VectorTestsSmokeTest() { + static void VectorTypeDoubleVector64TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesDouble64VectorTestsSmokeTest() { + static void WithLanesDoubleVector64TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(double.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeDouble64VectorTestsSmokeTest() { + static void WithShapeDoubleVector64TestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5642,7 +5642,7 @@ relativeError)); } @Test - static void MaskAllTrueDouble64VectorTestsSmokeTest() { + static void MaskAllTrueDoubleVector64TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/DoubleMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/DoubleVectorMaxLoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/DoubleMaxVectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/DoubleVectorMaxLoadStoreTests.java index 7d372239435..e52ce2aa0d4 100644 --- a/test/jdk/jdk/incubator/vector/DoubleMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVectorMaxLoadStoreTests.java @@ -28,7 +28,7 @@ * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation * @run testng/othervm --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED - * -XX:-TieredCompilation DoubleMaxVectorLoadStoreTests + * -XX:-TieredCompilation DoubleVectorMaxLoadStoreTests * */ @@ -52,7 +52,7 @@ import java.util.List; import java.util.function.*; @Test -public class DoubleMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class DoubleVectorMaxLoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_MAX; diff --git a/test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java b/test/jdk/jdk/incubator/vector/DoubleVectorMaxTests.java similarity index 91% rename from test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java rename to test/jdk/jdk/incubator/vector/DoubleVectorMaxTests.java index 9130698d5e4..c4dda942e83 100644 --- a/test/jdk/jdk/incubator/vector/DoubleMaxVectorTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleVectorMaxTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation DoubleMaxVectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation DoubleVectorMaxTests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class DoubleMaxVectorTests extends AbstractVectorTest { +public class DoubleVectorMaxTests extends AbstractVectorTest { static final VectorSpecies SPECIES = DoubleVector.SPECIES_MAX; @@ -1687,7 +1687,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ADDDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1700,7 +1700,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::ADD); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::ADD); } static double add(double a, double b) { @@ -1708,7 +1708,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void addDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1719,11 +1719,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::add); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1739,11 +1739,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::ADD); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void addDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1757,7 +1757,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::add); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::add); } static double SUB(double a, double b) { @@ -1765,7 +1765,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void SUBDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUBDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1778,7 +1778,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::SUB); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::SUB); } static double sub(double a, double b) { @@ -1786,7 +1786,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void subDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1797,11 +1797,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::sub); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void SUBDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1817,11 +1817,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::SUB); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::SUB); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void subDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1835,7 +1835,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::sub); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::sub); } static double MUL(double a, double b) { @@ -1843,7 +1843,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MULDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MULDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1856,7 +1856,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::MUL); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::MUL); } static double mul(double a, double b) { @@ -1864,7 +1864,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void mulDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1875,11 +1875,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::mul); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void MULDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1895,11 +1895,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::MUL); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::MUL); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1913,7 +1913,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::mul); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::mul); } static double DIV(double a, double b) { @@ -1921,7 +1921,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void DIVDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void DIVDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1934,7 +1934,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::DIV); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::DIV); } static double div(double a, double b) { @@ -1942,7 +1942,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void divDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -1953,11 +1953,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::div); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void DIVDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1973,11 +1973,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::DIV); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::DIV); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void divDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -1991,7 +1991,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::div); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::div); } static double FIRST_NONZERO(double a, double b) { @@ -1999,7 +1999,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void FIRST_NONZERODoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZERODoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2012,11 +2012,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void FIRST_NONZERODoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZERODoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2032,11 +2032,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::FIRST_NONZERO); } @Test(dataProvider = "doubleBinaryOpProvider") - static void addDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2046,11 +2046,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, DoubleVectorMaxTests::add); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void addDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addDoubleVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2063,11 +2063,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, DoubleMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVectorMaxTests::add); } @Test(dataProvider = "doubleBinaryOpProvider") - static void subDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2077,11 +2077,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, DoubleVectorMaxTests::sub); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void subDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subDoubleVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2094,11 +2094,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, DoubleMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVectorMaxTests::sub); } @Test(dataProvider = "doubleBinaryOpProvider") - static void mulDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2108,11 +2108,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, DoubleVectorMaxTests::mul); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void mulDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulDoubleVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2125,11 +2125,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, DoubleMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVectorMaxTests::mul); } @Test(dataProvider = "doubleBinaryOpProvider") - static void divDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2139,11 +2139,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, DoubleVectorMaxTests::div); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void divDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divDoubleVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2156,11 +2156,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, DoubleMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, DoubleVectorMaxTests::div); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ADDDoubleMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDDoubleVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2170,11 +2170,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, DoubleMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, DoubleVectorMaxTests::ADD); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void ADDDoubleMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDDoubleVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -2187,13 +2187,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, DoubleMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVectorMaxTests::ADD); } static DoubleVector bv_MIN = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MINDoubleMaxVectorTestsWithMemOp(IntFunction fa) { + static void MINDoubleVectorMaxTestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2204,13 +2204,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, DoubleMaxVectorTests::MIN); + assertArraysEquals(r, a, (double)10, DoubleVectorMaxTests::MIN); } static DoubleVector bv_min = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void minDoubleMaxVectorTestsWithMemOp(IntFunction fa) { + static void minDoubleVectorMaxTestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2221,13 +2221,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, DoubleMaxVectorTests::min); + assertArraysEquals(r, a, (double)10, DoubleVectorMaxTests::min); } static DoubleVector bv_MIN_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINDoubleMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINDoubleVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2240,13 +2240,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, DoubleMaxVectorTests::MIN); + assertArraysEquals(r, a, (double)10, mask, DoubleVectorMaxTests::MIN); } static DoubleVector bv_MAX = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXDoubleMaxVectorTestsWithMemOp(IntFunction fa) { + static void MAXDoubleVectorMaxTestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2257,13 +2257,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, DoubleMaxVectorTests::MAX); + assertArraysEquals(r, a, (double)10, DoubleVectorMaxTests::MAX); } static DoubleVector bv_max = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpProvider") - static void maxDoubleMaxVectorTestsWithMemOp(IntFunction fa) { + static void maxDoubleVectorMaxTestsWithMemOp(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2274,13 +2274,13 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, DoubleMaxVectorTests::max); + assertArraysEquals(r, a, (double)10, DoubleVectorMaxTests::max); } static DoubleVector bv_MAX_M = DoubleVector.broadcast(SPECIES, (double)10); @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXDoubleMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXDoubleVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2293,7 +2293,7 @@ relativeError)); } } - assertArraysEquals(r, a, (double)10, mask, DoubleMaxVectorTests::MAX); + assertArraysEquals(r, a, (double)10, mask, DoubleVectorMaxTests::MAX); } static double MIN(double a, double b) { @@ -2301,7 +2301,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MINDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2314,7 +2314,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::MIN); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::MIN); } static double min(double a, double b) { @@ -2322,7 +2322,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void minDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2333,7 +2333,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::min); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::min); } static double MAX(double a, double b) { @@ -2341,7 +2341,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MAXDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2354,7 +2354,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::MAX); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::MAX); } static double max(double a, double b) { @@ -2362,7 +2362,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maxDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2373,11 +2373,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::max); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::max); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MINDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2387,11 +2387,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, DoubleVectorMaxTests::MIN); } @Test(dataProvider = "doubleBinaryOpProvider") - static void minDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2401,11 +2401,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::min); + assertBroadcastArraysEquals(r, a, b, DoubleVectorMaxTests::min); } @Test(dataProvider = "doubleBinaryOpProvider") - static void MAXDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2415,11 +2415,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, DoubleVectorMaxTests::MAX); } @Test(dataProvider = "doubleBinaryOpProvider") - static void maxDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2429,7 +2429,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::max); + assertBroadcastArraysEquals(r, a, b, DoubleVectorMaxTests::max); } static double ADDReduce(double[] a, int idx) { @@ -2451,7 +2451,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceDoubleMaxVectorTests(IntFunction fa) { + static void ADDReduceDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2467,7 +2467,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - DoubleMaxVectorTests::ADDReduce, DoubleMaxVectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVectorMaxTests::ADDReduce, DoubleVectorMaxTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2513,7 +2513,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2531,7 +2531,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - DoubleMaxVectorTests::ADDReduceMasked, DoubleMaxVectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + DoubleVectorMaxTests::ADDReduceMasked, DoubleVectorMaxTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static double MULReduce(double[] a, int idx) { @@ -2553,7 +2553,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MULReduceDoubleMaxVectorTests(IntFunction fa) { + static void MULReduceDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2569,7 +2569,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - DoubleMaxVectorTests::MULReduce, DoubleMaxVectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVectorMaxTests::MULReduce, DoubleVectorMaxTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2615,7 +2615,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MULReduceDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2633,7 +2633,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - DoubleMaxVectorTests::MULReduceMasked, DoubleMaxVectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + DoubleVectorMaxTests::MULReduceMasked, DoubleVectorMaxTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static double MINReduce(double[] a, int idx) { @@ -2655,7 +2655,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MINReduceDoubleMaxVectorTests(IntFunction fa) { + static void MINReduceDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2671,7 +2671,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - DoubleMaxVectorTests::MINReduce, DoubleMaxVectorTests::MINReduceAll); + DoubleVectorMaxTests::MINReduce, DoubleVectorMaxTests::MINReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2717,7 +2717,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MINReduceDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2735,7 +2735,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - DoubleMaxVectorTests::MINReduceMasked, DoubleMaxVectorTests::MINReduceAllMasked); + DoubleVectorMaxTests::MINReduceMasked, DoubleVectorMaxTests::MINReduceAllMasked); } static double MAXReduce(double[] a, int idx) { @@ -2757,7 +2757,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void MAXReduceDoubleMaxVectorTests(IntFunction fa) { + static void MAXReduceDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2773,7 +2773,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - DoubleMaxVectorTests::MAXReduce, DoubleMaxVectorTests::MAXReduceAll); + DoubleVectorMaxTests::MAXReduce, DoubleVectorMaxTests::MAXReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2819,7 +2819,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void MAXReduceDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2837,7 +2837,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - DoubleMaxVectorTests::MAXReduceMasked, DoubleMaxVectorTests::MAXReduceAllMasked); + DoubleVectorMaxTests::MAXReduceMasked, DoubleVectorMaxTests::MAXReduceAllMasked); } static double FIRST_NONZEROReduce(double[] a, int idx) { @@ -2859,7 +2859,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void FIRST_NONZEROReduceDoubleMaxVectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); double ra = 0; @@ -2875,7 +2875,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - DoubleMaxVectorTests::FIRST_NONZEROReduce, DoubleMaxVectorTests::FIRST_NONZEROReduceAll); + DoubleVectorMaxTests::FIRST_NONZEROReduce, DoubleVectorMaxTests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "doubleUnaryOpProvider") @@ -2921,7 +2921,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void FIRST_NONZEROReduceDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2939,11 +2939,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - DoubleMaxVectorTests::FIRST_NONZEROReduceMasked, DoubleMaxVectorTests::FIRST_NONZEROReduceAllMasked); + DoubleVectorMaxTests::FIRST_NONZEROReduceMasked, DoubleVectorMaxTests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "doubleBinaryOpProvider") - static void withDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void withDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -2966,7 +2966,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_DEFAULTDoubleMaxVectorTests(IntFunction fa) { + static void IS_DEFAULTDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2983,7 +2983,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_DEFAULTMaskedDoubleMaxVectorTests(IntFunction fa, + static void IS_DEFAULTMaskedDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3007,7 +3007,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NEGATIVEDoubleMaxVectorTests(IntFunction fa) { + static void IS_NEGATIVEDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3024,7 +3024,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NEGATIVEMaskedDoubleMaxVectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3048,7 +3048,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_FINITEDoubleMaxVectorTests(IntFunction fa) { + static void IS_FINITEDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3065,7 +3065,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_FINITEMaskedDoubleMaxVectorTests(IntFunction fa, + static void IS_FINITEMaskedDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3089,7 +3089,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_NANDoubleMaxVectorTests(IntFunction fa) { + static void IS_NANDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3106,7 +3106,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_NANMaskedDoubleMaxVectorTests(IntFunction fa, + static void IS_NANMaskedDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3130,7 +3130,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpProvider") - static void IS_INFINITEDoubleMaxVectorTests(IntFunction fa) { + static void IS_INFINITEDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3147,7 +3147,7 @@ relativeError)); } @Test(dataProvider = "doubleTestOpMaskProvider") - static void IS_INFINITEMaskedDoubleMaxVectorTests(IntFunction fa, + static void IS_INFINITEMaskedDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3167,7 +3167,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LTDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3186,7 +3186,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ltDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3205,7 +3205,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3228,7 +3228,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GTDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GTDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3247,7 +3247,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GTDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3270,7 +3270,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void EQDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3289,7 +3289,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void eqDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3308,7 +3308,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3331,7 +3331,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void NEDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void NEDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3350,7 +3350,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void NEDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3373,7 +3373,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LEDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LEDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3392,7 +3392,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LEDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3415,7 +3415,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void GEDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GEDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3434,7 +3434,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void GEDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3457,7 +3457,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3473,7 +3473,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTDoubleVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3493,7 +3493,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void LTDoubleMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTDoubleVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3509,7 +3509,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void LTDoubleMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTDoubleVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3529,7 +3529,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3545,7 +3545,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQDoubleVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3565,7 +3565,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void EQDoubleMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQDoubleVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3581,7 +3581,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpMaskProvider") - static void EQDoubleMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQDoubleVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3605,7 +3605,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDoubleMaxVectorTests(IntFunction fa, IntFunction fb, + static void blendDoubleVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3621,11 +3621,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::blend); + assertArraysEquals(r, a, b, mask, DoubleVectorMaxTests::blend); } @Test(dataProvider = "doubleUnaryOpShuffleProvider") - static void RearrangeDoubleMaxVectorTests(IntFunction fa, + static void RearrangeDoubleVectorMaxTests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3642,7 +3642,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpShuffleMaskProvider") - static void RearrangeDoubleMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeDoubleVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -3660,7 +3660,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void compressDoubleMaxVectorTests(IntFunction fa, + static void compressDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3678,7 +3678,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void expandDoubleMaxVectorTests(IntFunction fa, + static void expandDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3696,7 +3696,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void getDoubleMaxVectorTests(IntFunction fa) { + static void getDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -3852,7 +3852,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void BroadcastDoubleMaxVectorTests(IntFunction fa) { + static void BroadcastDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3866,7 +3866,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ZeroDoubleMaxVectorTests(IntFunction fa) { + static void ZeroDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3891,7 +3891,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sliceUnaryDoubleMaxVectorTests(IntFunction fa) { + static void sliceUnaryDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3902,7 +3902,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, DoubleMaxVectorTests::sliceUnary); + assertArraysEquals(r, a, origin, DoubleVectorMaxTests::sliceUnary); } static double[] sliceBinary(double[] a, double[] b, int origin, int idx) { @@ -3919,7 +3919,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void sliceBinaryDoubleMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryDoubleVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -3932,7 +3932,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, DoubleMaxVectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, DoubleVectorMaxTests::sliceBinary); } static double[] slice(double[] a, double[] b, int origin, boolean[] mask, int idx) { @@ -3949,7 +3949,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void sliceDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -3966,7 +3966,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, DoubleMaxVectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, DoubleVectorMaxTests::slice); } static double[] unsliceUnary(double[] a, int origin, int idx) { @@ -3983,7 +3983,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void unsliceUnaryDoubleMaxVectorTests(IntFunction fa) { + static void unsliceUnaryDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3994,7 +3994,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, DoubleMaxVectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, DoubleVectorMaxTests::unsliceUnary); } static double[] unsliceBinary(double[] a, double[] b, int origin, int part, int idx) { @@ -4020,7 +4020,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void unsliceBinaryDoubleMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryDoubleVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -4034,7 +4034,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, DoubleMaxVectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, DoubleVectorMaxTests::unsliceBinary); } static double[] unslice(double[] a, double[] b, int origin, int part, boolean[] mask, int idx) { @@ -4074,7 +4074,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void unsliceDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4091,7 +4091,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, DoubleMaxVectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, DoubleVectorMaxTests::unslice); } static double SIN(double a) { @@ -4103,7 +4103,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINDoubleMaxVectorTests(IntFunction fa) { + static void SINDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4114,7 +4114,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::SIN, DoubleMaxVectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::SIN, DoubleVectorMaxTests::strictSIN); } static double EXP(double a) { @@ -4126,7 +4126,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPDoubleMaxVectorTests(IntFunction fa) { + static void EXPDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4137,7 +4137,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::EXP, DoubleMaxVectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::EXP, DoubleVectorMaxTests::strictEXP); } static double LOG1P(double a) { @@ -4149,7 +4149,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG1PDoubleMaxVectorTests(IntFunction fa) { + static void LOG1PDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4160,7 +4160,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::LOG1P, DoubleMaxVectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::LOG1P, DoubleVectorMaxTests::strictLOG1P); } static double LOG(double a) { @@ -4172,7 +4172,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOGDoubleMaxVectorTests(IntFunction fa) { + static void LOGDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4183,7 +4183,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::LOG, DoubleMaxVectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::LOG, DoubleVectorMaxTests::strictLOG); } static double LOG10(double a) { @@ -4195,7 +4195,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void LOG10DoubleMaxVectorTests(IntFunction fa) { + static void LOG10DoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4206,7 +4206,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::LOG10, DoubleMaxVectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::LOG10, DoubleVectorMaxTests::strictLOG10); } static double EXPM1(double a) { @@ -4218,7 +4218,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void EXPM1DoubleMaxVectorTests(IntFunction fa) { + static void EXPM1DoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4229,7 +4229,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::EXPM1, DoubleMaxVectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::EXPM1, DoubleVectorMaxTests::strictEXPM1); } static double COS(double a) { @@ -4241,7 +4241,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSDoubleMaxVectorTests(IntFunction fa) { + static void COSDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4252,7 +4252,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::COS, DoubleMaxVectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::COS, DoubleVectorMaxTests::strictCOS); } static double TAN(double a) { @@ -4264,7 +4264,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANDoubleMaxVectorTests(IntFunction fa) { + static void TANDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4275,7 +4275,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::TAN, DoubleMaxVectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::TAN, DoubleVectorMaxTests::strictTAN); } static double SINH(double a) { @@ -4287,7 +4287,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SINHDoubleMaxVectorTests(IntFunction fa) { + static void SINHDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4298,7 +4298,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::SINH, DoubleMaxVectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::SINH, DoubleVectorMaxTests::strictSINH); } static double COSH(double a) { @@ -4310,7 +4310,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void COSHDoubleMaxVectorTests(IntFunction fa) { + static void COSHDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4321,7 +4321,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::COSH, DoubleMaxVectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::COSH, DoubleVectorMaxTests::strictCOSH); } static double TANH(double a) { @@ -4333,7 +4333,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void TANHDoubleMaxVectorTests(IntFunction fa) { + static void TANHDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4344,7 +4344,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::TANH, DoubleMaxVectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::TANH, DoubleVectorMaxTests::strictTANH); } static double ASIN(double a) { @@ -4356,7 +4356,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ASINDoubleMaxVectorTests(IntFunction fa) { + static void ASINDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4367,7 +4367,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::ASIN, DoubleMaxVectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::ASIN, DoubleVectorMaxTests::strictASIN); } static double ACOS(double a) { @@ -4379,7 +4379,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ACOSDoubleMaxVectorTests(IntFunction fa) { + static void ACOSDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4390,7 +4390,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::ACOS, DoubleMaxVectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::ACOS, DoubleVectorMaxTests::strictACOS); } static double ATAN(double a) { @@ -4402,7 +4402,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ATANDoubleMaxVectorTests(IntFunction fa) { + static void ATANDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4413,7 +4413,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::ATAN, DoubleMaxVectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::ATAN, DoubleVectorMaxTests::strictATAN); } static double CBRT(double a) { @@ -4425,7 +4425,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void CBRTDoubleMaxVectorTests(IntFunction fa) { + static void CBRTDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4436,7 +4436,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::CBRT, DoubleMaxVectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, DoubleVectorMaxTests::CBRT, DoubleVectorMaxTests::strictCBRT); } static double HYPOT(double a, double b) { @@ -4448,7 +4448,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void HYPOTDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4461,7 +4461,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::HYPOT, DoubleMaxVectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVectorMaxTests::HYPOT, DoubleVectorMaxTests::strictHYPOT); } @@ -4474,7 +4474,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void POWDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4487,7 +4487,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::POW, DoubleMaxVectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVectorMaxTests::POW, DoubleVectorMaxTests::strictPOW); } @@ -4500,7 +4500,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void powDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4513,7 +4513,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::pow, DoubleMaxVectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVectorMaxTests::pow, DoubleVectorMaxTests::strictpow); } @@ -4526,7 +4526,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpProvider") - static void ATAN2DoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2DoubleVectorMaxTests(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4539,12 +4539,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::ATAN2, DoubleMaxVectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, DoubleVectorMaxTests::ATAN2, DoubleVectorMaxTests::strictATAN2); } @Test(dataProvider = "doubleBinaryOpProvider") - static void POWDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4554,12 +4554,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::POW, DoubleMaxVectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVectorMaxTests::POW, DoubleVectorMaxTests::strictPOW); } @Test(dataProvider = "doubleBinaryOpProvider") - static void powDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4569,7 +4569,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::pow, DoubleMaxVectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleVectorMaxTests::pow, DoubleVectorMaxTests::strictpow); } @@ -4582,7 +4582,7 @@ relativeError)); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADoubleMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4604,11 +4604,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, DoubleMaxVectorTests::FMA); + assertArraysEquals(r, a, b, c, DoubleVectorMaxTests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDoubleMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4628,11 +4628,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, DoubleMaxVectorTests::fma); + assertArraysEquals(r, a, b, c, DoubleVectorMaxTests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMADoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4657,11 +4657,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, DoubleMaxVectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, DoubleVectorMaxTests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4672,11 +4672,11 @@ relativeError)); DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, DoubleMaxVectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, DoubleVectorMaxTests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADoubleMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] c = fc.apply(SPECIES.length()); @@ -4687,11 +4687,11 @@ relativeError)); DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, DoubleMaxVectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, DoubleVectorMaxTests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4706,11 +4706,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, DoubleMaxVectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, DoubleVectorMaxTests::FMA); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADoubleMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVectorMaxTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -4725,11 +4725,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, DoubleMaxVectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, DoubleVectorMaxTests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void FMADoubleMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMADoubleVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("FMA") { case "fma": case "lanewise_FMA": @@ -4747,11 +4747,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleMaxVectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVectorMaxTests::FMA); } @Test(dataProvider = "doubleTernaryOpProvider") - static void fmaDoubleMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaDoubleVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int count = INVOC_COUNT; switch ("fma") { case "fma": case "lanewise_FMA": @@ -4769,11 +4769,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleMaxVectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleVectorMaxTests::fma); } @Test(dataProvider = "doubleTernaryOpMaskProvider") - static void FMADoubleMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMADoubleVectorMaxTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int count = INVOC_COUNT; switch ("FMA") { @@ -4794,7 +4794,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, DoubleMaxVectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, DoubleVectorMaxTests::FMA); } static double NEG(double a) { @@ -4806,7 +4806,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void NEGDoubleMaxVectorTests(IntFunction fa) { + static void NEGDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4817,11 +4817,11 @@ relativeError)); } } - assertArraysEquals(r, a, DoubleMaxVectorTests::NEG); + assertArraysEquals(r, a, DoubleVectorMaxTests::NEG); } @Test(dataProvider = "doubleUnaryOpProvider") - static void negDoubleMaxVectorTests(IntFunction fa) { + static void negDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4832,11 +4832,11 @@ relativeError)); } } - assertArraysEquals(r, a, DoubleMaxVectorTests::neg); + assertArraysEquals(r, a, DoubleVectorMaxTests::neg); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void NEGMaskedDoubleMaxVectorTests(IntFunction fa, + static void NEGMaskedDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4850,7 +4850,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, DoubleMaxVectorTests::NEG); + assertArraysEquals(r, a, mask, DoubleVectorMaxTests::NEG); } static double ABS(double a) { @@ -4862,7 +4862,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ABSDoubleMaxVectorTests(IntFunction fa) { + static void ABSDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4873,11 +4873,11 @@ relativeError)); } } - assertArraysEquals(r, a, DoubleMaxVectorTests::ABS); + assertArraysEquals(r, a, DoubleVectorMaxTests::ABS); } @Test(dataProvider = "doubleUnaryOpProvider") - static void absDoubleMaxVectorTests(IntFunction fa) { + static void absDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4888,11 +4888,11 @@ relativeError)); } } - assertArraysEquals(r, a, DoubleMaxVectorTests::abs); + assertArraysEquals(r, a, DoubleVectorMaxTests::abs); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ABSMaskedDoubleMaxVectorTests(IntFunction fa, + static void ABSMaskedDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4906,7 +4906,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, DoubleMaxVectorTests::ABS); + assertArraysEquals(r, a, mask, DoubleVectorMaxTests::ABS); } static double SQRT(double a) { @@ -4918,7 +4918,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void SQRTDoubleMaxVectorTests(IntFunction fa) { + static void SQRTDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4929,11 +4929,11 @@ relativeError)); } } - assertArraysEquals(r, a, DoubleMaxVectorTests::SQRT); + assertArraysEquals(r, a, DoubleVectorMaxTests::SQRT); } @Test(dataProvider = "doubleUnaryOpProvider") - static void sqrtDoubleMaxVectorTests(IntFunction fa) { + static void sqrtDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4944,11 +4944,11 @@ relativeError)); } } - assertArraysEquals(r, a, DoubleMaxVectorTests::sqrt); + assertArraysEquals(r, a, DoubleVectorMaxTests::sqrt); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void SQRTMaskedDoubleMaxVectorTests(IntFunction fa, + static void SQRTMaskedDoubleVectorMaxTests(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] r = fr.apply(SPECIES.length()); @@ -4962,7 +4962,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, DoubleMaxVectorTests::SQRT); + assertArraysEquals(r, a, mask, DoubleVectorMaxTests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4970,7 +4970,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4983,7 +4983,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::band); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::band); } static boolean bor(boolean a, boolean b) { @@ -4991,7 +4991,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskorDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5004,7 +5004,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::bor); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::bor); } static boolean bxor(boolean a, boolean b) { @@ -5012,7 +5012,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskxorDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5025,7 +5025,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::bxor); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5033,7 +5033,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5046,7 +5046,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::bandNot); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5054,7 +5054,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskeqDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5067,7 +5067,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, DoubleMaxVectorTests::beq); + assertArraysEquals(r, a, b, DoubleVectorMaxTests::beq); } static boolean unot(boolean a) { @@ -5075,7 +5075,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotDoubleMaxVectorTests(IntFunction fa) { + static void masknotDoubleVectorMaxTests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5086,7 +5086,7 @@ relativeError)); } } - assertArraysEquals(r, a, DoubleMaxVectorTests::unot); + assertArraysEquals(r, a, DoubleVectorMaxTests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5103,7 +5103,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongDoubleMaxVectorTests(IntFunction fa) { + static void maskFromToLongDoubleVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5117,7 +5117,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void ltDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltDoubleVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5133,7 +5133,7 @@ relativeError)); } @Test(dataProvider = "doubleCompareOpProvider") - static void eqDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqDoubleVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5149,7 +5149,7 @@ relativeError)); } @Test(dataProvider = "doubletoIntUnaryOpProvider") - static void toIntArrayDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayDoubleVectorMaxTestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5160,7 +5160,7 @@ relativeError)); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void toLongArrayDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayDoubleVectorMaxTestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5172,7 +5172,7 @@ relativeError)); @Test(dataProvider = "doubleUnaryOpProvider") - static void toStringDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void toStringDoubleVectorMaxTestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5185,7 +5185,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void hashCodeDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void hashCodeDoubleVectorMaxTestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5218,7 +5218,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpProvider") - static void ADDReduceLongDoubleMaxVectorTests(IntFunction fa) { + static void ADDReduceLongDoubleVectorMaxTests(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5234,7 +5234,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - DoubleMaxVectorTests::ADDReduceLong, DoubleMaxVectorTests::ADDReduceAllLong); + DoubleVectorMaxTests::ADDReduceLong, DoubleVectorMaxTests::ADDReduceAllLong); } static long ADDReduceLongMasked(double[] a, int idx, boolean[] mask) { @@ -5257,7 +5257,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpMaskProvider") - static void ADDReduceLongDoubleMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongDoubleVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5275,11 +5275,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - DoubleMaxVectorTests::ADDReduceLongMasked, DoubleMaxVectorTests::ADDReduceAllLongMasked); + DoubleVectorMaxTests::ADDReduceLongMasked, DoubleVectorMaxTests::ADDReduceAllLongMasked); } @Test(dataProvider = "doubletoLongUnaryOpProvider") - static void BroadcastLongDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongDoubleVectorMaxTestsSmokeTest(IntFunction fa) { double[] a = fa.apply(SPECIES.length()); double[] r = new double[a.length]; @@ -5290,7 +5290,7 @@ relativeError)); } @Test(dataProvider = "doubleBinaryOpMaskProvider") - static void blendDoubleMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendDoubleVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); @@ -5304,12 +5304,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, DoubleMaxVectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, DoubleVectorMaxTests::blend); } @Test(dataProvider = "doubleUnaryOpSelectFromProvider") - static void SelectFromDoubleMaxVectorTests(IntFunction fa, + static void SelectFromDoubleVectorMaxTests(IntFunction fa, BiFunction fs) { double[] a = fa.apply(SPECIES.length()); double[] order = fs.apply(a.length, SPECIES.length()); @@ -5325,7 +5325,7 @@ relativeError)); } @Test(dataProvider = "doubleSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorDoubleMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorDoubleVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { double[] a = fa.apply(SPECIES.length()); double[] b = fb.apply(SPECIES.length()); double[] idx = fc.apply(SPECIES.length()); @@ -5343,7 +5343,7 @@ relativeError)); } @Test(dataProvider = "doubleUnaryOpSelectFromMaskProvider") - static void SelectFromDoubleMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromDoubleVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { double[] a = fa.apply(SPECIES.length()); @@ -5362,7 +5362,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousDoubleMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousDoubleVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5378,7 +5378,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringDoubleMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringDoubleVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5392,7 +5392,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsDoubleMaxVectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsDoubleVectorMaxTestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5406,7 +5406,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsDoubleMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsDoubleVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5422,7 +5422,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeDoubleVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5444,7 +5444,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountDoubleVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5455,7 +5455,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, DoubleMaxVectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, DoubleVectorMaxTests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5469,7 +5469,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueDoubleVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5480,7 +5480,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, DoubleMaxVectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, DoubleVectorMaxTests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5494,7 +5494,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueDoubleVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5505,11 +5505,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, DoubleMaxVectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, DoubleVectorMaxTests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressDoubleMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskCompressDoubleVectorMaxTestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5537,7 +5537,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeDoubleMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeDoubleVectorMaxTestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5551,7 +5551,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongDoubleMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeLongDoubleVectorMaxTestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5578,14 +5578,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundDoubleMaxVectorTestsSmokeTest(int length) { + static void loopBoundDoubleVectorMaxTestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongDoubleMaxVectorTestsSmokeTest(int _length) { + static void loopBoundLongDoubleVectorMaxTestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5593,21 +5593,21 @@ relativeError)); } @Test - static void ElementSizeDoubleMaxVectorTestsSmokeTest() { + static void ElementSizeDoubleVectorMaxTestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Double.SIZE); } @Test - static void VectorShapeDoubleMaxVectorTestsSmokeTest() { + static void VectorShapeDoubleVectorMaxTestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_Max_BIT)); } @Test - static void ShapeWithLanesDoubleMaxVectorTestsSmokeTest() { + static void ShapeWithLanesDoubleVectorMaxTestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(double.class); @@ -5615,32 +5615,32 @@ relativeError)); } @Test - static void ElementTypeDoubleMaxVectorTestsSmokeTest() { + static void ElementTypeDoubleVectorMaxTestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementType() == double.class); } @Test - static void SpeciesElementSizeDoubleMaxVectorTestsSmokeTest() { + static void SpeciesElementSizeDoubleVectorMaxTestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().elementSize() == Double.SIZE); } @Test - static void VectorTypeDoubleMaxVectorTestsSmokeTest() { + static void VectorTypeDoubleVectorMaxTestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesDoubleMaxVectorTestsSmokeTest() { + static void WithLanesDoubleVectorMaxTestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(double.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeDoubleMaxVectorTestsSmokeTest() { + static void WithShapeDoubleVectorMaxTestsSmokeTest() { DoubleVector av = DoubleVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5648,7 +5648,7 @@ relativeError)); } @Test - static void MaskAllTrueDoubleMaxVectorTestsSmokeTest() { + static void MaskAllTrueDoubleVectorMaxTestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Float128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/FloatVector128LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Float128VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/FloatVector128LoadStoreTests.java index 33a02167a90..5ef419f940d 100644 --- a/test/jdk/jdk/incubator/vector/Float128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVector128LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Float128VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation FloatVector128LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Float128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class FloatVector128LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_128; diff --git a/test/jdk/jdk/incubator/vector/Float128VectorTests.java b/test/jdk/jdk/incubator/vector/FloatVector128Tests.java similarity index 91% rename from test/jdk/jdk/incubator/vector/Float128VectorTests.java rename to test/jdk/jdk/incubator/vector/FloatVector128Tests.java index 71ca2b3b701..51e6365b01b 100644 --- a/test/jdk/jdk/incubator/vector/Float128VectorTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVector128Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Float128VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation FloatVector128Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Float128VectorTests extends AbstractVectorTest { +public class FloatVector128Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_128; @@ -1698,7 +1698,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void ADDFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1711,7 +1711,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::ADD); + assertArraysEquals(r, a, b, FloatVector128Tests::ADD); } static float add(float a, float b) { @@ -1719,7 +1719,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void addFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1730,11 +1730,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float128VectorTests::add); + assertArraysEquals(r, a, b, FloatVector128Tests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1750,11 +1750,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float128VectorTests::ADD); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1768,7 +1768,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float128VectorTests::add); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::add); } static float SUB(float a, float b) { @@ -1776,7 +1776,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void SUBFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void SUBFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1789,7 +1789,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::SUB); + assertArraysEquals(r, a, b, FloatVector128Tests::SUB); } static float sub(float a, float b) { @@ -1797,7 +1797,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void subFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1808,11 +1808,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float128VectorTests::sub); + assertArraysEquals(r, a, b, FloatVector128Tests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void SUBFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1828,11 +1828,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float128VectorTests::SUB); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::SUB); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1846,7 +1846,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float128VectorTests::sub); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::sub); } static float MUL(float a, float b) { @@ -1854,7 +1854,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MULFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void MULFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1867,7 +1867,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::MUL); + assertArraysEquals(r, a, b, FloatVector128Tests::MUL); } static float mul(float a, float b) { @@ -1875,7 +1875,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void mulFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1886,11 +1886,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float128VectorTests::mul); + assertArraysEquals(r, a, b, FloatVector128Tests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void MULFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1906,11 +1906,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float128VectorTests::MUL); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::MUL); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1924,7 +1924,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float128VectorTests::mul); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::mul); } static float DIV(float a, float b) { @@ -1932,7 +1932,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void DIVFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void DIVFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1945,7 +1945,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::DIV); + assertArraysEquals(r, a, b, FloatVector128Tests::DIV); } static float div(float a, float b) { @@ -1953,7 +1953,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void divFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1964,11 +1964,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float128VectorTests::div); + assertArraysEquals(r, a, b, FloatVector128Tests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void DIVFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1984,11 +1984,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float128VectorTests::DIV); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::DIV); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2002,7 +2002,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float128VectorTests::div); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::div); } static float FIRST_NONZERO(float a, float b) { @@ -2010,7 +2010,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void FIRST_NONZEROFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2023,11 +2023,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, FloatVector128Tests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void FIRST_NONZEROFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2043,11 +2043,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2057,11 +2057,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, FloatVector128Tests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloat128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addFloatVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2074,11 +2074,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector128Tests::add); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2088,11 +2088,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, FloatVector128Tests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloat128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subFloatVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2105,11 +2105,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector128Tests::sub); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2119,11 +2119,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, FloatVector128Tests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloat128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulFloatVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2136,11 +2136,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector128Tests::mul); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2150,11 +2150,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, FloatVector128Tests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloat128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divFloatVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2167,11 +2167,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector128Tests::div); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloat128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDFloatVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2181,11 +2181,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Float128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, FloatVector128Tests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloat128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDFloatVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2198,13 +2198,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Float128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVector128Tests::ADD); } static FloatVector bv_MIN = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MINFloat128VectorTestsWithMemOp(IntFunction fa) { + static void MINFloatVector128TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2215,13 +2215,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float128VectorTests::MIN); + assertArraysEquals(r, a, (float)10, FloatVector128Tests::MIN); } static FloatVector bv_min = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void minFloat128VectorTestsWithMemOp(IntFunction fa) { + static void minFloatVector128TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2232,13 +2232,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float128VectorTests::min); + assertArraysEquals(r, a, (float)10, FloatVector128Tests::min); } static FloatVector bv_MIN_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINFloat128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINFloatVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2251,13 +2251,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, Float128VectorTests::MIN); + assertArraysEquals(r, a, (float)10, mask, FloatVector128Tests::MIN); } static FloatVector bv_MAX = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MAXFloat128VectorTestsWithMemOp(IntFunction fa) { + static void MAXFloatVector128TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2268,13 +2268,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float128VectorTests::MAX); + assertArraysEquals(r, a, (float)10, FloatVector128Tests::MAX); } static FloatVector bv_max = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void maxFloat128VectorTestsWithMemOp(IntFunction fa) { + static void maxFloatVector128TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2285,13 +2285,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float128VectorTests::max); + assertArraysEquals(r, a, (float)10, FloatVector128Tests::max); } static FloatVector bv_MAX_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXFloat128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXFloatVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2304,7 +2304,7 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, Float128VectorTests::MAX); + assertArraysEquals(r, a, (float)10, mask, FloatVector128Tests::MAX); } static float MIN(float a, float b) { @@ -2312,7 +2312,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void MINFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2325,7 +2325,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::MIN); + assertArraysEquals(r, a, b, FloatVector128Tests::MIN); } static float min(float a, float b) { @@ -2333,7 +2333,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void minFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2344,7 +2344,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float128VectorTests::min); + assertArraysEquals(r, a, b, FloatVector128Tests::min); } static float MAX(float a, float b) { @@ -2352,7 +2352,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void MAXFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2365,7 +2365,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::MAX); + assertArraysEquals(r, a, b, FloatVector128Tests::MAX); } static float max(float a, float b) { @@ -2373,7 +2373,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void maxFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2384,11 +2384,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float128VectorTests::max); + assertArraysEquals(r, a, b, FloatVector128Tests::max); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2398,11 +2398,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float128VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, FloatVector128Tests::MIN); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2412,11 +2412,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float128VectorTests::min); + assertBroadcastArraysEquals(r, a, b, FloatVector128Tests::min); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2426,11 +2426,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float128VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, FloatVector128Tests::MAX); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2440,7 +2440,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float128VectorTests::max); + assertBroadcastArraysEquals(r, a, b, FloatVector128Tests::max); } static float ADDReduce(float[] a, int idx) { @@ -2462,7 +2462,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceFloat128VectorTests(IntFunction fa) { + static void ADDReduceFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2478,7 +2478,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float128VectorTests::ADDReduce, Float128VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVector128Tests::ADDReduce, FloatVector128Tests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2524,7 +2524,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceFloat128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceFloatVector128TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2542,7 +2542,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float128VectorTests::ADDReduceMasked, Float128VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVector128Tests::ADDReduceMasked, FloatVector128Tests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static float MULReduce(float[] a, int idx) { @@ -2564,7 +2564,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MULReduceFloat128VectorTests(IntFunction fa) { + static void MULReduceFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2580,7 +2580,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float128VectorTests::MULReduce, Float128VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVector128Tests::MULReduce, FloatVector128Tests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2626,7 +2626,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MULReduceFloat128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceFloatVector128TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2644,7 +2644,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float128VectorTests::MULReduceMasked, Float128VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVector128Tests::MULReduceMasked, FloatVector128Tests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static float MINReduce(float[] a, int idx) { @@ -2666,7 +2666,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MINReduceFloat128VectorTests(IntFunction fa) { + static void MINReduceFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2682,7 +2682,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float128VectorTests::MINReduce, Float128VectorTests::MINReduceAll); + FloatVector128Tests::MINReduce, FloatVector128Tests::MINReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2728,7 +2728,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINReduceFloat128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceFloatVector128TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2746,7 +2746,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float128VectorTests::MINReduceMasked, Float128VectorTests::MINReduceAllMasked); + FloatVector128Tests::MINReduceMasked, FloatVector128Tests::MINReduceAllMasked); } static float MAXReduce(float[] a, int idx) { @@ -2768,7 +2768,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MAXReduceFloat128VectorTests(IntFunction fa) { + static void MAXReduceFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2784,7 +2784,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float128VectorTests::MAXReduce, Float128VectorTests::MAXReduceAll); + FloatVector128Tests::MAXReduce, FloatVector128Tests::MAXReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2830,7 +2830,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXReduceFloat128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceFloatVector128TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2848,7 +2848,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float128VectorTests::MAXReduceMasked, Float128VectorTests::MAXReduceAllMasked); + FloatVector128Tests::MAXReduceMasked, FloatVector128Tests::MAXReduceAllMasked); } static float FIRST_NONZEROReduce(float[] a, int idx) { @@ -2870,7 +2870,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void FIRST_NONZEROReduceFloat128VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2886,7 +2886,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float128VectorTests::FIRST_NONZEROReduce, Float128VectorTests::FIRST_NONZEROReduceAll); + FloatVector128Tests::FIRST_NONZEROReduce, FloatVector128Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2932,7 +2932,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void FIRST_NONZEROReduceFloat128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceFloatVector128TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2950,11 +2950,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float128VectorTests::FIRST_NONZEROReduceMasked, Float128VectorTests::FIRST_NONZEROReduceAllMasked); + FloatVector128Tests::FIRST_NONZEROReduceMasked, FloatVector128Tests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "floatBinaryOpProvider") - static void withFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void withFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2977,7 +2977,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_DEFAULTFloat128VectorTests(IntFunction fa) { + static void IS_DEFAULTFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2994,7 +2994,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_DEFAULTMaskedFloat128VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3018,7 +3018,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NEGATIVEFloat128VectorTests(IntFunction fa) { + static void IS_NEGATIVEFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3035,7 +3035,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NEGATIVEMaskedFloat128VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3059,7 +3059,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_FINITEFloat128VectorTests(IntFunction fa) { + static void IS_FINITEFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3076,7 +3076,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_FINITEMaskedFloat128VectorTests(IntFunction fa, + static void IS_FINITEMaskedFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3100,7 +3100,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NANFloat128VectorTests(IntFunction fa) { + static void IS_NANFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3117,7 +3117,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NANMaskedFloat128VectorTests(IntFunction fa, + static void IS_NANMaskedFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3141,7 +3141,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_INFINITEFloat128VectorTests(IntFunction fa) { + static void IS_INFINITEFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3158,7 +3158,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_INFINITEMaskedFloat128VectorTests(IntFunction fa, + static void IS_INFINITEMaskedFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3178,7 +3178,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void LTFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3197,7 +3197,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void ltFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3216,7 +3216,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3239,7 +3239,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GTFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void GTFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3258,7 +3258,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GTFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3281,7 +3281,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void EQFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3300,7 +3300,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void eqFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3319,7 +3319,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3342,7 +3342,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void NEFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void NEFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3361,7 +3361,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void NEFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3384,7 +3384,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LEFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void LEFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3403,7 +3403,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LEFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3426,7 +3426,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GEFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void GEFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3445,7 +3445,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GEFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3468,7 +3468,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3484,7 +3484,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTFloatVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3504,7 +3504,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3520,7 +3520,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTFloatVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3540,7 +3540,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3556,7 +3556,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQFloatVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3576,7 +3576,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3592,7 +3592,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQFloatVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3616,7 +3616,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloat128VectorTests(IntFunction fa, IntFunction fb, + static void blendFloatVector128Tests(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3632,11 +3632,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float128VectorTests::blend); + assertArraysEquals(r, a, b, mask, FloatVector128Tests::blend); } @Test(dataProvider = "floatUnaryOpShuffleProvider") - static void RearrangeFloat128VectorTests(IntFunction fa, + static void RearrangeFloatVector128Tests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3653,7 +3653,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpShuffleMaskProvider") - static void RearrangeFloat128VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeFloatVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -3671,7 +3671,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void compressFloat128VectorTests(IntFunction fa, + static void compressFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3689,7 +3689,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void expandFloat128VectorTests(IntFunction fa, + static void expandFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3707,7 +3707,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void getFloat128VectorTests(IntFunction fa) { + static void getFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3863,7 +3863,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void BroadcastFloat128VectorTests(IntFunction fa) { + static void BroadcastFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3877,7 +3877,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ZeroFloat128VectorTests(IntFunction fa) { + static void ZeroFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3902,7 +3902,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void sliceUnaryFloat128VectorTests(IntFunction fa) { + static void sliceUnaryFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3913,7 +3913,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Float128VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, FloatVector128Tests::sliceUnary); } static float[] sliceBinary(float[] a, float[] b, int origin, int idx) { @@ -3930,7 +3930,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void sliceBinaryFloat128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryFloatVector128TestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3943,7 +3943,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, Float128VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, FloatVector128Tests::sliceBinary); } static float[] slice(float[] a, float[] b, int origin, boolean[] mask, int idx) { @@ -3960,7 +3960,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void sliceFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3977,7 +3977,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, Float128VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, FloatVector128Tests::slice); } static float[] unsliceUnary(float[] a, int origin, int idx) { @@ -3994,7 +3994,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void unsliceUnaryFloat128VectorTests(IntFunction fa) { + static void unsliceUnaryFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -4005,7 +4005,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Float128VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, FloatVector128Tests::unsliceUnary); } static float[] unsliceBinary(float[] a, float[] b, int origin, int part, int idx) { @@ -4031,7 +4031,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void unsliceBinaryFloat128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryFloatVector128TestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -4045,7 +4045,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, Float128VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, FloatVector128Tests::unsliceBinary); } static float[] unslice(float[] a, float[] b, int origin, int part, boolean[] mask, int idx) { @@ -4085,7 +4085,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void unsliceFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4102,7 +4102,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, Float128VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, FloatVector128Tests::unslice); } static float SIN(float a) { @@ -4114,7 +4114,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINFloat128VectorTests(IntFunction fa) { + static void SINFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4125,7 +4125,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::SIN, Float128VectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::SIN, FloatVector128Tests::strictSIN); } static float EXP(float a) { @@ -4137,7 +4137,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPFloat128VectorTests(IntFunction fa) { + static void EXPFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4148,7 +4148,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::EXP, Float128VectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::EXP, FloatVector128Tests::strictEXP); } static float LOG1P(float a) { @@ -4160,7 +4160,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG1PFloat128VectorTests(IntFunction fa) { + static void LOG1PFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4171,7 +4171,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::LOG1P, Float128VectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::LOG1P, FloatVector128Tests::strictLOG1P); } static float LOG(float a) { @@ -4183,7 +4183,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOGFloat128VectorTests(IntFunction fa) { + static void LOGFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4194,7 +4194,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::LOG, Float128VectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::LOG, FloatVector128Tests::strictLOG); } static float LOG10(float a) { @@ -4206,7 +4206,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG10Float128VectorTests(IntFunction fa) { + static void LOG10FloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4217,7 +4217,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::LOG10, Float128VectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::LOG10, FloatVector128Tests::strictLOG10); } static float EXPM1(float a) { @@ -4229,7 +4229,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPM1Float128VectorTests(IntFunction fa) { + static void EXPM1FloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4240,7 +4240,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::EXPM1, Float128VectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::EXPM1, FloatVector128Tests::strictEXPM1); } static float COS(float a) { @@ -4252,7 +4252,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSFloat128VectorTests(IntFunction fa) { + static void COSFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4263,7 +4263,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::COS, Float128VectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::COS, FloatVector128Tests::strictCOS); } static float TAN(float a) { @@ -4275,7 +4275,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANFloat128VectorTests(IntFunction fa) { + static void TANFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4286,7 +4286,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::TAN, Float128VectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::TAN, FloatVector128Tests::strictTAN); } static float SINH(float a) { @@ -4298,7 +4298,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINHFloat128VectorTests(IntFunction fa) { + static void SINHFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4309,7 +4309,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::SINH, Float128VectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::SINH, FloatVector128Tests::strictSINH); } static float COSH(float a) { @@ -4321,7 +4321,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSHFloat128VectorTests(IntFunction fa) { + static void COSHFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4332,7 +4332,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::COSH, Float128VectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::COSH, FloatVector128Tests::strictCOSH); } static float TANH(float a) { @@ -4344,7 +4344,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANHFloat128VectorTests(IntFunction fa) { + static void TANHFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4355,7 +4355,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::TANH, Float128VectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::TANH, FloatVector128Tests::strictTANH); } static float ASIN(float a) { @@ -4367,7 +4367,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ASINFloat128VectorTests(IntFunction fa) { + static void ASINFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4378,7 +4378,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::ASIN, Float128VectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::ASIN, FloatVector128Tests::strictASIN); } static float ACOS(float a) { @@ -4390,7 +4390,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ACOSFloat128VectorTests(IntFunction fa) { + static void ACOSFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4401,7 +4401,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::ACOS, Float128VectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::ACOS, FloatVector128Tests::strictACOS); } static float ATAN(float a) { @@ -4413,7 +4413,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ATANFloat128VectorTests(IntFunction fa) { + static void ATANFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4424,7 +4424,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::ATAN, Float128VectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::ATAN, FloatVector128Tests::strictATAN); } static float CBRT(float a) { @@ -4436,7 +4436,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void CBRTFloat128VectorTests(IntFunction fa) { + static void CBRTFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4447,7 +4447,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float128VectorTests::CBRT, Float128VectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, FloatVector128Tests::CBRT, FloatVector128Tests::strictCBRT); } static float HYPOT(float a, float b) { @@ -4459,7 +4459,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void HYPOTFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4472,7 +4472,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float128VectorTests::HYPOT, Float128VectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector128Tests::HYPOT, FloatVector128Tests::strictHYPOT); } @@ -4485,7 +4485,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void POWFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4498,7 +4498,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float128VectorTests::POW, Float128VectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector128Tests::POW, FloatVector128Tests::strictPOW); } @@ -4511,7 +4511,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void powFloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4524,7 +4524,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float128VectorTests::pow, Float128VectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector128Tests::pow, FloatVector128Tests::strictpow); } @@ -4537,7 +4537,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ATAN2Float128VectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2FloatVector128Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4550,12 +4550,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float128VectorTests::ATAN2, Float128VectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector128Tests::ATAN2, FloatVector128Tests::strictATAN2); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4565,12 +4565,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Float128VectorTests::POW, Float128VectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVector128Tests::POW, FloatVector128Tests::strictPOW); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4580,7 +4580,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Float128VectorTests::pow, Float128VectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVector128Tests::pow, FloatVector128Tests::strictpow); } @@ -4593,7 +4593,7 @@ relativeError)); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4608,11 +4608,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, Float128VectorTests::FMA); + assertArraysEquals(r, a, b, c, FloatVector128Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloat128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4625,11 +4625,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Float128VectorTests::fma); + assertArraysEquals(r, a, b, c, FloatVector128Tests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMAFloatVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4647,11 +4647,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, Float128VectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, FloatVector128Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4662,11 +4662,11 @@ relativeError)); FloatVector bv = FloatVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Float128VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, FloatVector128Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4677,11 +4677,11 @@ relativeError)); FloatVector cv = FloatVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Float128VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, FloatVector128Tests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4696,11 +4696,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Float128VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, FloatVector128Tests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat128VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector128TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4715,11 +4715,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Float128VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, FloatVector128Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4730,11 +4730,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Float128VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVector128Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloat128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4745,11 +4745,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Float128VectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVector128Tests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat128VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector128TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4763,7 +4763,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Float128VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FloatVector128Tests::FMA); } static float NEG(float a) { @@ -4775,7 +4775,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void NEGFloat128VectorTests(IntFunction fa) { + static void NEGFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4786,11 +4786,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float128VectorTests::NEG); + assertArraysEquals(r, a, FloatVector128Tests::NEG); } @Test(dataProvider = "floatUnaryOpProvider") - static void negFloat128VectorTests(IntFunction fa) { + static void negFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4801,11 +4801,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float128VectorTests::neg); + assertArraysEquals(r, a, FloatVector128Tests::neg); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void NEGMaskedFloat128VectorTests(IntFunction fa, + static void NEGMaskedFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4819,7 +4819,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float128VectorTests::NEG); + assertArraysEquals(r, a, mask, FloatVector128Tests::NEG); } static float ABS(float a) { @@ -4831,7 +4831,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ABSFloat128VectorTests(IntFunction fa) { + static void ABSFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4842,11 +4842,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float128VectorTests::ABS); + assertArraysEquals(r, a, FloatVector128Tests::ABS); } @Test(dataProvider = "floatUnaryOpProvider") - static void absFloat128VectorTests(IntFunction fa) { + static void absFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4857,11 +4857,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float128VectorTests::abs); + assertArraysEquals(r, a, FloatVector128Tests::abs); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ABSMaskedFloat128VectorTests(IntFunction fa, + static void ABSMaskedFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4875,7 +4875,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float128VectorTests::ABS); + assertArraysEquals(r, a, mask, FloatVector128Tests::ABS); } static float SQRT(float a) { @@ -4887,7 +4887,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SQRTFloat128VectorTests(IntFunction fa) { + static void SQRTFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4898,11 +4898,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float128VectorTests::SQRT); + assertArraysEquals(r, a, FloatVector128Tests::SQRT); } @Test(dataProvider = "floatUnaryOpProvider") - static void sqrtFloat128VectorTests(IntFunction fa) { + static void sqrtFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4913,11 +4913,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float128VectorTests::sqrt); + assertArraysEquals(r, a, FloatVector128Tests::sqrt); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void SQRTMaskedFloat128VectorTests(IntFunction fa, + static void SQRTMaskedFloatVector128Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4931,7 +4931,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float128VectorTests::SQRT); + assertArraysEquals(r, a, mask, FloatVector128Tests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4939,7 +4939,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandFloatVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4952,7 +4952,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::band); + assertArraysEquals(r, a, b, FloatVector128Tests::band); } static boolean bor(boolean a, boolean b) { @@ -4960,7 +4960,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void maskorFloatVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4973,7 +4973,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::bor); + assertArraysEquals(r, a, b, FloatVector128Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -4981,7 +4981,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorFloatVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4994,7 +4994,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::bxor); + assertArraysEquals(r, a, b, FloatVector128Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5002,7 +5002,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotFloatVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5015,7 +5015,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::bandNot); + assertArraysEquals(r, a, b, FloatVector128Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5023,7 +5023,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqFloatVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5036,7 +5036,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float128VectorTests::beq); + assertArraysEquals(r, a, b, FloatVector128Tests::beq); } static boolean unot(boolean a) { @@ -5044,7 +5044,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotFloat128VectorTests(IntFunction fa) { + static void masknotFloatVector128Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5055,7 +5055,7 @@ relativeError)); } } - assertArraysEquals(r, a, Float128VectorTests::unot); + assertArraysEquals(r, a, FloatVector128Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5072,7 +5072,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongFloat128VectorTests(IntFunction fa) { + static void maskFromToLongFloatVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5086,7 +5086,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloat128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltFloatVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5102,7 +5102,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloat128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqFloatVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5118,7 +5118,7 @@ relativeError)); } @Test(dataProvider = "floattoIntUnaryOpProvider") - static void toIntArrayFloat128VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayFloatVector128TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5129,7 +5129,7 @@ relativeError)); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void toLongArrayFloat128VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayFloatVector128TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5140,7 +5140,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toDoubleArrayFloat128VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayFloatVector128TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5151,7 +5151,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toStringFloat128VectorTestsSmokeTest(IntFunction fa) { + static void toStringFloatVector128TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5164,7 +5164,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void hashCodeFloat128VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeFloatVector128TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5197,7 +5197,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceLongFloat128VectorTests(IntFunction fa) { + static void ADDReduceLongFloatVector128Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5213,7 +5213,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - Float128VectorTests::ADDReduceLong, Float128VectorTests::ADDReduceAllLong); + FloatVector128Tests::ADDReduceLong, FloatVector128Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(float[] a, int idx, boolean[] mask) { @@ -5236,7 +5236,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceLongFloat128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongFloatVector128TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5254,11 +5254,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Float128VectorTests::ADDReduceLongMasked, Float128VectorTests::ADDReduceAllLongMasked); + FloatVector128Tests::ADDReduceLongMasked, FloatVector128Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void BroadcastLongFloat128VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongFloatVector128TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -5269,7 +5269,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloat128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendFloatVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5283,12 +5283,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Float128VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVector128Tests::blend); } @Test(dataProvider = "floatUnaryOpSelectFromProvider") - static void SelectFromFloat128VectorTests(IntFunction fa, + static void SelectFromFloatVector128Tests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); float[] order = fs.apply(a.length, SPECIES.length()); @@ -5304,7 +5304,7 @@ relativeError)); } @Test(dataProvider = "floatSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorFloat128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorFloatVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] idx = fc.apply(SPECIES.length()); @@ -5322,7 +5322,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpSelectFromMaskProvider") - static void SelectFromFloat128VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromFloatVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -5341,7 +5341,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousFloat128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousFloatVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5357,7 +5357,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringFloat128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringFloatVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5371,7 +5371,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsFloat128VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsFloatVector128TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5385,7 +5385,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsFloat128VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsFloatVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5401,7 +5401,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeFloat128VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeFloatVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5423,7 +5423,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountFloat128VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountFloatVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5434,7 +5434,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float128VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, FloatVector128Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5448,7 +5448,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueFloat128VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueFloatVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5459,7 +5459,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float128VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, FloatVector128Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5473,7 +5473,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueFloat128VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueFloatVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5484,11 +5484,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float128VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, FloatVector128Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressFloat128VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressFloatVector128TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5516,7 +5516,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeFloat128VectorTestsSmokeTest(int offset) { + static void indexInRangeFloatVector128TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5530,7 +5530,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongFloat128VectorTestsSmokeTest(int offset) { + static void indexInRangeLongFloatVector128TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5557,14 +5557,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundFloat128VectorTestsSmokeTest(int length) { + static void loopBoundFloatVector128TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongFloat128VectorTestsSmokeTest(int _length) { + static void loopBoundLongFloatVector128TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5572,21 +5572,21 @@ relativeError)); } @Test - static void ElementSizeFloat128VectorTestsSmokeTest() { + static void ElementSizeFloatVector128TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Float.SIZE); } @Test - static void VectorShapeFloat128VectorTestsSmokeTest() { + static void VectorShapeFloatVector128TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_128_BIT)); } @Test - static void ShapeWithLanesFloat128VectorTestsSmokeTest() { + static void ShapeWithLanesFloatVector128TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(float.class); @@ -5594,32 +5594,32 @@ relativeError)); } @Test - static void ElementTypeFloat128VectorTestsSmokeTest() { + static void ElementTypeFloatVector128TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementType() == float.class); } @Test - static void SpeciesElementSizeFloat128VectorTestsSmokeTest() { + static void SpeciesElementSizeFloatVector128TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementSize() == Float.SIZE); } @Test - static void VectorTypeFloat128VectorTestsSmokeTest() { + static void VectorTypeFloatVector128TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesFloat128VectorTestsSmokeTest() { + static void WithLanesFloatVector128TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(float.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeFloat128VectorTestsSmokeTest() { + static void WithShapeFloatVector128TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5627,7 +5627,7 @@ relativeError)); } @Test - static void MaskAllTrueFloat128VectorTestsSmokeTest() { + static void MaskAllTrueFloatVector128TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Float256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/FloatVector256LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Float256VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/FloatVector256LoadStoreTests.java index 0c1d8e9d443..a889bb5e8c8 100644 --- a/test/jdk/jdk/incubator/vector/Float256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVector256LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Float256VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation FloatVector256LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Float256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class FloatVector256LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_256; diff --git a/test/jdk/jdk/incubator/vector/Float256VectorTests.java b/test/jdk/jdk/incubator/vector/FloatVector256Tests.java similarity index 91% rename from test/jdk/jdk/incubator/vector/Float256VectorTests.java rename to test/jdk/jdk/incubator/vector/FloatVector256Tests.java index cc61a5cdc5d..b7d16ecc7f7 100644 --- a/test/jdk/jdk/incubator/vector/Float256VectorTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVector256Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Float256VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation FloatVector256Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Float256VectorTests extends AbstractVectorTest { +public class FloatVector256Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_256; @@ -1698,7 +1698,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void ADDFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1711,7 +1711,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::ADD); + assertArraysEquals(r, a, b, FloatVector256Tests::ADD); } static float add(float a, float b) { @@ -1719,7 +1719,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void addFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1730,11 +1730,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float256VectorTests::add); + assertArraysEquals(r, a, b, FloatVector256Tests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1750,11 +1750,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float256VectorTests::ADD); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1768,7 +1768,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float256VectorTests::add); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::add); } static float SUB(float a, float b) { @@ -1776,7 +1776,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void SUBFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void SUBFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1789,7 +1789,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::SUB); + assertArraysEquals(r, a, b, FloatVector256Tests::SUB); } static float sub(float a, float b) { @@ -1797,7 +1797,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void subFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1808,11 +1808,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float256VectorTests::sub); + assertArraysEquals(r, a, b, FloatVector256Tests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void SUBFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1828,11 +1828,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float256VectorTests::SUB); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::SUB); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1846,7 +1846,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float256VectorTests::sub); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::sub); } static float MUL(float a, float b) { @@ -1854,7 +1854,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MULFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void MULFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1867,7 +1867,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::MUL); + assertArraysEquals(r, a, b, FloatVector256Tests::MUL); } static float mul(float a, float b) { @@ -1875,7 +1875,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void mulFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1886,11 +1886,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float256VectorTests::mul); + assertArraysEquals(r, a, b, FloatVector256Tests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void MULFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1906,11 +1906,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float256VectorTests::MUL); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::MUL); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1924,7 +1924,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float256VectorTests::mul); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::mul); } static float DIV(float a, float b) { @@ -1932,7 +1932,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void DIVFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void DIVFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1945,7 +1945,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::DIV); + assertArraysEquals(r, a, b, FloatVector256Tests::DIV); } static float div(float a, float b) { @@ -1953,7 +1953,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void divFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1964,11 +1964,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float256VectorTests::div); + assertArraysEquals(r, a, b, FloatVector256Tests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void DIVFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1984,11 +1984,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float256VectorTests::DIV); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::DIV); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2002,7 +2002,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float256VectorTests::div); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::div); } static float FIRST_NONZERO(float a, float b) { @@ -2010,7 +2010,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void FIRST_NONZEROFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2023,11 +2023,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, FloatVector256Tests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void FIRST_NONZEROFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2043,11 +2043,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2057,11 +2057,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, FloatVector256Tests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloat256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addFloatVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2074,11 +2074,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector256Tests::add); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2088,11 +2088,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, FloatVector256Tests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloat256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subFloatVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2105,11 +2105,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector256Tests::sub); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2119,11 +2119,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, FloatVector256Tests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloat256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulFloatVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2136,11 +2136,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector256Tests::mul); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2150,11 +2150,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, FloatVector256Tests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloat256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divFloatVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2167,11 +2167,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector256Tests::div); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloat256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDFloatVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2181,11 +2181,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Float256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, FloatVector256Tests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloat256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDFloatVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2198,13 +2198,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Float256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVector256Tests::ADD); } static FloatVector bv_MIN = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MINFloat256VectorTestsWithMemOp(IntFunction fa) { + static void MINFloatVector256TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2215,13 +2215,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float256VectorTests::MIN); + assertArraysEquals(r, a, (float)10, FloatVector256Tests::MIN); } static FloatVector bv_min = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void minFloat256VectorTestsWithMemOp(IntFunction fa) { + static void minFloatVector256TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2232,13 +2232,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float256VectorTests::min); + assertArraysEquals(r, a, (float)10, FloatVector256Tests::min); } static FloatVector bv_MIN_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINFloat256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINFloatVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2251,13 +2251,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, Float256VectorTests::MIN); + assertArraysEquals(r, a, (float)10, mask, FloatVector256Tests::MIN); } static FloatVector bv_MAX = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MAXFloat256VectorTestsWithMemOp(IntFunction fa) { + static void MAXFloatVector256TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2268,13 +2268,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float256VectorTests::MAX); + assertArraysEquals(r, a, (float)10, FloatVector256Tests::MAX); } static FloatVector bv_max = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void maxFloat256VectorTestsWithMemOp(IntFunction fa) { + static void maxFloatVector256TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2285,13 +2285,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float256VectorTests::max); + assertArraysEquals(r, a, (float)10, FloatVector256Tests::max); } static FloatVector bv_MAX_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXFloat256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXFloatVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2304,7 +2304,7 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, Float256VectorTests::MAX); + assertArraysEquals(r, a, (float)10, mask, FloatVector256Tests::MAX); } static float MIN(float a, float b) { @@ -2312,7 +2312,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void MINFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2325,7 +2325,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::MIN); + assertArraysEquals(r, a, b, FloatVector256Tests::MIN); } static float min(float a, float b) { @@ -2333,7 +2333,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void minFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2344,7 +2344,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float256VectorTests::min); + assertArraysEquals(r, a, b, FloatVector256Tests::min); } static float MAX(float a, float b) { @@ -2352,7 +2352,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void MAXFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2365,7 +2365,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::MAX); + assertArraysEquals(r, a, b, FloatVector256Tests::MAX); } static float max(float a, float b) { @@ -2373,7 +2373,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void maxFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2384,11 +2384,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float256VectorTests::max); + assertArraysEquals(r, a, b, FloatVector256Tests::max); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2398,11 +2398,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float256VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, FloatVector256Tests::MIN); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2412,11 +2412,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float256VectorTests::min); + assertBroadcastArraysEquals(r, a, b, FloatVector256Tests::min); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2426,11 +2426,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float256VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, FloatVector256Tests::MAX); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2440,7 +2440,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float256VectorTests::max); + assertBroadcastArraysEquals(r, a, b, FloatVector256Tests::max); } static float ADDReduce(float[] a, int idx) { @@ -2462,7 +2462,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceFloat256VectorTests(IntFunction fa) { + static void ADDReduceFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2478,7 +2478,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float256VectorTests::ADDReduce, Float256VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVector256Tests::ADDReduce, FloatVector256Tests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2524,7 +2524,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceFloat256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceFloatVector256TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2542,7 +2542,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float256VectorTests::ADDReduceMasked, Float256VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVector256Tests::ADDReduceMasked, FloatVector256Tests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static float MULReduce(float[] a, int idx) { @@ -2564,7 +2564,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MULReduceFloat256VectorTests(IntFunction fa) { + static void MULReduceFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2580,7 +2580,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float256VectorTests::MULReduce, Float256VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVector256Tests::MULReduce, FloatVector256Tests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2626,7 +2626,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MULReduceFloat256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceFloatVector256TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2644,7 +2644,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float256VectorTests::MULReduceMasked, Float256VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVector256Tests::MULReduceMasked, FloatVector256Tests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static float MINReduce(float[] a, int idx) { @@ -2666,7 +2666,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MINReduceFloat256VectorTests(IntFunction fa) { + static void MINReduceFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2682,7 +2682,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float256VectorTests::MINReduce, Float256VectorTests::MINReduceAll); + FloatVector256Tests::MINReduce, FloatVector256Tests::MINReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2728,7 +2728,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINReduceFloat256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceFloatVector256TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2746,7 +2746,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float256VectorTests::MINReduceMasked, Float256VectorTests::MINReduceAllMasked); + FloatVector256Tests::MINReduceMasked, FloatVector256Tests::MINReduceAllMasked); } static float MAXReduce(float[] a, int idx) { @@ -2768,7 +2768,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MAXReduceFloat256VectorTests(IntFunction fa) { + static void MAXReduceFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2784,7 +2784,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float256VectorTests::MAXReduce, Float256VectorTests::MAXReduceAll); + FloatVector256Tests::MAXReduce, FloatVector256Tests::MAXReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2830,7 +2830,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXReduceFloat256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceFloatVector256TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2848,7 +2848,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float256VectorTests::MAXReduceMasked, Float256VectorTests::MAXReduceAllMasked); + FloatVector256Tests::MAXReduceMasked, FloatVector256Tests::MAXReduceAllMasked); } static float FIRST_NONZEROReduce(float[] a, int idx) { @@ -2870,7 +2870,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void FIRST_NONZEROReduceFloat256VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2886,7 +2886,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float256VectorTests::FIRST_NONZEROReduce, Float256VectorTests::FIRST_NONZEROReduceAll); + FloatVector256Tests::FIRST_NONZEROReduce, FloatVector256Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2932,7 +2932,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void FIRST_NONZEROReduceFloat256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceFloatVector256TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2950,11 +2950,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float256VectorTests::FIRST_NONZEROReduceMasked, Float256VectorTests::FIRST_NONZEROReduceAllMasked); + FloatVector256Tests::FIRST_NONZEROReduceMasked, FloatVector256Tests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "floatBinaryOpProvider") - static void withFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void withFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2977,7 +2977,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_DEFAULTFloat256VectorTests(IntFunction fa) { + static void IS_DEFAULTFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2994,7 +2994,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_DEFAULTMaskedFloat256VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3018,7 +3018,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NEGATIVEFloat256VectorTests(IntFunction fa) { + static void IS_NEGATIVEFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3035,7 +3035,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NEGATIVEMaskedFloat256VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3059,7 +3059,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_FINITEFloat256VectorTests(IntFunction fa) { + static void IS_FINITEFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3076,7 +3076,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_FINITEMaskedFloat256VectorTests(IntFunction fa, + static void IS_FINITEMaskedFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3100,7 +3100,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NANFloat256VectorTests(IntFunction fa) { + static void IS_NANFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3117,7 +3117,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NANMaskedFloat256VectorTests(IntFunction fa, + static void IS_NANMaskedFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3141,7 +3141,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_INFINITEFloat256VectorTests(IntFunction fa) { + static void IS_INFINITEFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3158,7 +3158,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_INFINITEMaskedFloat256VectorTests(IntFunction fa, + static void IS_INFINITEMaskedFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3178,7 +3178,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void LTFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3197,7 +3197,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void ltFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3216,7 +3216,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3239,7 +3239,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GTFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void GTFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3258,7 +3258,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GTFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3281,7 +3281,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void EQFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3300,7 +3300,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void eqFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3319,7 +3319,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3342,7 +3342,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void NEFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void NEFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3361,7 +3361,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void NEFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3384,7 +3384,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LEFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void LEFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3403,7 +3403,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LEFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3426,7 +3426,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GEFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void GEFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3445,7 +3445,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GEFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3468,7 +3468,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3484,7 +3484,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTFloatVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3504,7 +3504,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3520,7 +3520,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTFloatVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3540,7 +3540,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3556,7 +3556,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQFloatVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3576,7 +3576,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3592,7 +3592,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQFloatVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3616,7 +3616,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloat256VectorTests(IntFunction fa, IntFunction fb, + static void blendFloatVector256Tests(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3632,11 +3632,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float256VectorTests::blend); + assertArraysEquals(r, a, b, mask, FloatVector256Tests::blend); } @Test(dataProvider = "floatUnaryOpShuffleProvider") - static void RearrangeFloat256VectorTests(IntFunction fa, + static void RearrangeFloatVector256Tests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3653,7 +3653,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpShuffleMaskProvider") - static void RearrangeFloat256VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeFloatVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -3671,7 +3671,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void compressFloat256VectorTests(IntFunction fa, + static void compressFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3689,7 +3689,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void expandFloat256VectorTests(IntFunction fa, + static void expandFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3707,7 +3707,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void getFloat256VectorTests(IntFunction fa) { + static void getFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3863,7 +3863,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void BroadcastFloat256VectorTests(IntFunction fa) { + static void BroadcastFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3877,7 +3877,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ZeroFloat256VectorTests(IntFunction fa) { + static void ZeroFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3902,7 +3902,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void sliceUnaryFloat256VectorTests(IntFunction fa) { + static void sliceUnaryFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3913,7 +3913,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Float256VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, FloatVector256Tests::sliceUnary); } static float[] sliceBinary(float[] a, float[] b, int origin, int idx) { @@ -3930,7 +3930,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void sliceBinaryFloat256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryFloatVector256TestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3943,7 +3943,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, Float256VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, FloatVector256Tests::sliceBinary); } static float[] slice(float[] a, float[] b, int origin, boolean[] mask, int idx) { @@ -3960,7 +3960,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void sliceFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3977,7 +3977,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, Float256VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, FloatVector256Tests::slice); } static float[] unsliceUnary(float[] a, int origin, int idx) { @@ -3994,7 +3994,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void unsliceUnaryFloat256VectorTests(IntFunction fa) { + static void unsliceUnaryFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -4005,7 +4005,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Float256VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, FloatVector256Tests::unsliceUnary); } static float[] unsliceBinary(float[] a, float[] b, int origin, int part, int idx) { @@ -4031,7 +4031,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void unsliceBinaryFloat256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryFloatVector256TestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -4045,7 +4045,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, Float256VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, FloatVector256Tests::unsliceBinary); } static float[] unslice(float[] a, float[] b, int origin, int part, boolean[] mask, int idx) { @@ -4085,7 +4085,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void unsliceFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4102,7 +4102,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, Float256VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, FloatVector256Tests::unslice); } static float SIN(float a) { @@ -4114,7 +4114,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINFloat256VectorTests(IntFunction fa) { + static void SINFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4125,7 +4125,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::SIN, Float256VectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::SIN, FloatVector256Tests::strictSIN); } static float EXP(float a) { @@ -4137,7 +4137,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPFloat256VectorTests(IntFunction fa) { + static void EXPFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4148,7 +4148,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::EXP, Float256VectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::EXP, FloatVector256Tests::strictEXP); } static float LOG1P(float a) { @@ -4160,7 +4160,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG1PFloat256VectorTests(IntFunction fa) { + static void LOG1PFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4171,7 +4171,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::LOG1P, Float256VectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::LOG1P, FloatVector256Tests::strictLOG1P); } static float LOG(float a) { @@ -4183,7 +4183,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOGFloat256VectorTests(IntFunction fa) { + static void LOGFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4194,7 +4194,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::LOG, Float256VectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::LOG, FloatVector256Tests::strictLOG); } static float LOG10(float a) { @@ -4206,7 +4206,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG10Float256VectorTests(IntFunction fa) { + static void LOG10FloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4217,7 +4217,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::LOG10, Float256VectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::LOG10, FloatVector256Tests::strictLOG10); } static float EXPM1(float a) { @@ -4229,7 +4229,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPM1Float256VectorTests(IntFunction fa) { + static void EXPM1FloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4240,7 +4240,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::EXPM1, Float256VectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::EXPM1, FloatVector256Tests::strictEXPM1); } static float COS(float a) { @@ -4252,7 +4252,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSFloat256VectorTests(IntFunction fa) { + static void COSFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4263,7 +4263,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::COS, Float256VectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::COS, FloatVector256Tests::strictCOS); } static float TAN(float a) { @@ -4275,7 +4275,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANFloat256VectorTests(IntFunction fa) { + static void TANFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4286,7 +4286,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::TAN, Float256VectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::TAN, FloatVector256Tests::strictTAN); } static float SINH(float a) { @@ -4298,7 +4298,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINHFloat256VectorTests(IntFunction fa) { + static void SINHFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4309,7 +4309,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::SINH, Float256VectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::SINH, FloatVector256Tests::strictSINH); } static float COSH(float a) { @@ -4321,7 +4321,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSHFloat256VectorTests(IntFunction fa) { + static void COSHFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4332,7 +4332,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::COSH, Float256VectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::COSH, FloatVector256Tests::strictCOSH); } static float TANH(float a) { @@ -4344,7 +4344,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANHFloat256VectorTests(IntFunction fa) { + static void TANHFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4355,7 +4355,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::TANH, Float256VectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::TANH, FloatVector256Tests::strictTANH); } static float ASIN(float a) { @@ -4367,7 +4367,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ASINFloat256VectorTests(IntFunction fa) { + static void ASINFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4378,7 +4378,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::ASIN, Float256VectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::ASIN, FloatVector256Tests::strictASIN); } static float ACOS(float a) { @@ -4390,7 +4390,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ACOSFloat256VectorTests(IntFunction fa) { + static void ACOSFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4401,7 +4401,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::ACOS, Float256VectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::ACOS, FloatVector256Tests::strictACOS); } static float ATAN(float a) { @@ -4413,7 +4413,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ATANFloat256VectorTests(IntFunction fa) { + static void ATANFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4424,7 +4424,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::ATAN, Float256VectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::ATAN, FloatVector256Tests::strictATAN); } static float CBRT(float a) { @@ -4436,7 +4436,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void CBRTFloat256VectorTests(IntFunction fa) { + static void CBRTFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4447,7 +4447,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float256VectorTests::CBRT, Float256VectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, FloatVector256Tests::CBRT, FloatVector256Tests::strictCBRT); } static float HYPOT(float a, float b) { @@ -4459,7 +4459,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void HYPOTFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4472,7 +4472,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float256VectorTests::HYPOT, Float256VectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector256Tests::HYPOT, FloatVector256Tests::strictHYPOT); } @@ -4485,7 +4485,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void POWFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4498,7 +4498,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float256VectorTests::POW, Float256VectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector256Tests::POW, FloatVector256Tests::strictPOW); } @@ -4511,7 +4511,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void powFloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4524,7 +4524,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float256VectorTests::pow, Float256VectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector256Tests::pow, FloatVector256Tests::strictpow); } @@ -4537,7 +4537,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ATAN2Float256VectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2FloatVector256Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4550,12 +4550,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float256VectorTests::ATAN2, Float256VectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector256Tests::ATAN2, FloatVector256Tests::strictATAN2); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4565,12 +4565,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Float256VectorTests::POW, Float256VectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVector256Tests::POW, FloatVector256Tests::strictPOW); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4580,7 +4580,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Float256VectorTests::pow, Float256VectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVector256Tests::pow, FloatVector256Tests::strictpow); } @@ -4593,7 +4593,7 @@ relativeError)); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4608,11 +4608,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, Float256VectorTests::FMA); + assertArraysEquals(r, a, b, c, FloatVector256Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloat256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4625,11 +4625,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Float256VectorTests::fma); + assertArraysEquals(r, a, b, c, FloatVector256Tests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMAFloatVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4647,11 +4647,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, Float256VectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, FloatVector256Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4662,11 +4662,11 @@ relativeError)); FloatVector bv = FloatVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Float256VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, FloatVector256Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4677,11 +4677,11 @@ relativeError)); FloatVector cv = FloatVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Float256VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, FloatVector256Tests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4696,11 +4696,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Float256VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, FloatVector256Tests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector256TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4715,11 +4715,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Float256VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, FloatVector256Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4730,11 +4730,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Float256VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVector256Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloat256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4745,11 +4745,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Float256VectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVector256Tests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector256TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4763,7 +4763,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Float256VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FloatVector256Tests::FMA); } static float NEG(float a) { @@ -4775,7 +4775,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void NEGFloat256VectorTests(IntFunction fa) { + static void NEGFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4786,11 +4786,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float256VectorTests::NEG); + assertArraysEquals(r, a, FloatVector256Tests::NEG); } @Test(dataProvider = "floatUnaryOpProvider") - static void negFloat256VectorTests(IntFunction fa) { + static void negFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4801,11 +4801,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float256VectorTests::neg); + assertArraysEquals(r, a, FloatVector256Tests::neg); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void NEGMaskedFloat256VectorTests(IntFunction fa, + static void NEGMaskedFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4819,7 +4819,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float256VectorTests::NEG); + assertArraysEquals(r, a, mask, FloatVector256Tests::NEG); } static float ABS(float a) { @@ -4831,7 +4831,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ABSFloat256VectorTests(IntFunction fa) { + static void ABSFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4842,11 +4842,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float256VectorTests::ABS); + assertArraysEquals(r, a, FloatVector256Tests::ABS); } @Test(dataProvider = "floatUnaryOpProvider") - static void absFloat256VectorTests(IntFunction fa) { + static void absFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4857,11 +4857,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float256VectorTests::abs); + assertArraysEquals(r, a, FloatVector256Tests::abs); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ABSMaskedFloat256VectorTests(IntFunction fa, + static void ABSMaskedFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4875,7 +4875,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float256VectorTests::ABS); + assertArraysEquals(r, a, mask, FloatVector256Tests::ABS); } static float SQRT(float a) { @@ -4887,7 +4887,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SQRTFloat256VectorTests(IntFunction fa) { + static void SQRTFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4898,11 +4898,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float256VectorTests::SQRT); + assertArraysEquals(r, a, FloatVector256Tests::SQRT); } @Test(dataProvider = "floatUnaryOpProvider") - static void sqrtFloat256VectorTests(IntFunction fa) { + static void sqrtFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4913,11 +4913,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float256VectorTests::sqrt); + assertArraysEquals(r, a, FloatVector256Tests::sqrt); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void SQRTMaskedFloat256VectorTests(IntFunction fa, + static void SQRTMaskedFloatVector256Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4931,7 +4931,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float256VectorTests::SQRT); + assertArraysEquals(r, a, mask, FloatVector256Tests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4939,7 +4939,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandFloatVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4952,7 +4952,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::band); + assertArraysEquals(r, a, b, FloatVector256Tests::band); } static boolean bor(boolean a, boolean b) { @@ -4960,7 +4960,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void maskorFloatVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4973,7 +4973,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::bor); + assertArraysEquals(r, a, b, FloatVector256Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -4981,7 +4981,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorFloatVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4994,7 +4994,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::bxor); + assertArraysEquals(r, a, b, FloatVector256Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5002,7 +5002,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotFloatVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5015,7 +5015,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::bandNot); + assertArraysEquals(r, a, b, FloatVector256Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5023,7 +5023,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqFloatVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5036,7 +5036,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float256VectorTests::beq); + assertArraysEquals(r, a, b, FloatVector256Tests::beq); } static boolean unot(boolean a) { @@ -5044,7 +5044,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotFloat256VectorTests(IntFunction fa) { + static void masknotFloatVector256Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5055,7 +5055,7 @@ relativeError)); } } - assertArraysEquals(r, a, Float256VectorTests::unot); + assertArraysEquals(r, a, FloatVector256Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5072,7 +5072,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongFloat256VectorTests(IntFunction fa) { + static void maskFromToLongFloatVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5086,7 +5086,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloat256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltFloatVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5102,7 +5102,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloat256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqFloatVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5118,7 +5118,7 @@ relativeError)); } @Test(dataProvider = "floattoIntUnaryOpProvider") - static void toIntArrayFloat256VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayFloatVector256TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5129,7 +5129,7 @@ relativeError)); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void toLongArrayFloat256VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayFloatVector256TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5140,7 +5140,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toDoubleArrayFloat256VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayFloatVector256TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5151,7 +5151,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toStringFloat256VectorTestsSmokeTest(IntFunction fa) { + static void toStringFloatVector256TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5164,7 +5164,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void hashCodeFloat256VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeFloatVector256TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5197,7 +5197,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceLongFloat256VectorTests(IntFunction fa) { + static void ADDReduceLongFloatVector256Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5213,7 +5213,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - Float256VectorTests::ADDReduceLong, Float256VectorTests::ADDReduceAllLong); + FloatVector256Tests::ADDReduceLong, FloatVector256Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(float[] a, int idx, boolean[] mask) { @@ -5236,7 +5236,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceLongFloat256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongFloatVector256TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5254,11 +5254,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Float256VectorTests::ADDReduceLongMasked, Float256VectorTests::ADDReduceAllLongMasked); + FloatVector256Tests::ADDReduceLongMasked, FloatVector256Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void BroadcastLongFloat256VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongFloatVector256TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -5269,7 +5269,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloat256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendFloatVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5283,12 +5283,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Float256VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVector256Tests::blend); } @Test(dataProvider = "floatUnaryOpSelectFromProvider") - static void SelectFromFloat256VectorTests(IntFunction fa, + static void SelectFromFloatVector256Tests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); float[] order = fs.apply(a.length, SPECIES.length()); @@ -5304,7 +5304,7 @@ relativeError)); } @Test(dataProvider = "floatSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorFloat256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorFloatVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] idx = fc.apply(SPECIES.length()); @@ -5322,7 +5322,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpSelectFromMaskProvider") - static void SelectFromFloat256VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromFloatVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -5341,7 +5341,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousFloat256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousFloatVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5357,7 +5357,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringFloat256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringFloatVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5371,7 +5371,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsFloat256VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsFloatVector256TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5385,7 +5385,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsFloat256VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsFloatVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5401,7 +5401,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeFloat256VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeFloatVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5423,7 +5423,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountFloat256VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountFloatVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5434,7 +5434,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float256VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, FloatVector256Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5448,7 +5448,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueFloat256VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueFloatVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5459,7 +5459,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float256VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, FloatVector256Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5473,7 +5473,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueFloat256VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueFloatVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5484,11 +5484,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float256VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, FloatVector256Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressFloat256VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressFloatVector256TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5516,7 +5516,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeFloat256VectorTestsSmokeTest(int offset) { + static void indexInRangeFloatVector256TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5530,7 +5530,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongFloat256VectorTestsSmokeTest(int offset) { + static void indexInRangeLongFloatVector256TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5557,14 +5557,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundFloat256VectorTestsSmokeTest(int length) { + static void loopBoundFloatVector256TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongFloat256VectorTestsSmokeTest(int _length) { + static void loopBoundLongFloatVector256TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5572,21 +5572,21 @@ relativeError)); } @Test - static void ElementSizeFloat256VectorTestsSmokeTest() { + static void ElementSizeFloatVector256TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Float.SIZE); } @Test - static void VectorShapeFloat256VectorTestsSmokeTest() { + static void VectorShapeFloatVector256TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_256_BIT)); } @Test - static void ShapeWithLanesFloat256VectorTestsSmokeTest() { + static void ShapeWithLanesFloatVector256TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(float.class); @@ -5594,32 +5594,32 @@ relativeError)); } @Test - static void ElementTypeFloat256VectorTestsSmokeTest() { + static void ElementTypeFloatVector256TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementType() == float.class); } @Test - static void SpeciesElementSizeFloat256VectorTestsSmokeTest() { + static void SpeciesElementSizeFloatVector256TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementSize() == Float.SIZE); } @Test - static void VectorTypeFloat256VectorTestsSmokeTest() { + static void VectorTypeFloatVector256TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesFloat256VectorTestsSmokeTest() { + static void WithLanesFloatVector256TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(float.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeFloat256VectorTestsSmokeTest() { + static void WithShapeFloatVector256TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5627,7 +5627,7 @@ relativeError)); } @Test - static void MaskAllTrueFloat256VectorTestsSmokeTest() { + static void MaskAllTrueFloatVector256TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Float512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/FloatVector512LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Float512VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/FloatVector512LoadStoreTests.java index b3fe49e2121..3a33f0175b4 100644 --- a/test/jdk/jdk/incubator/vector/Float512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVector512LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Float512VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation FloatVector512LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Float512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class FloatVector512LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_512; diff --git a/test/jdk/jdk/incubator/vector/Float512VectorTests.java b/test/jdk/jdk/incubator/vector/FloatVector512Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Float512VectorTests.java rename to test/jdk/jdk/incubator/vector/FloatVector512Tests.java index 830001ac268..17493778826 100644 --- a/test/jdk/jdk/incubator/vector/Float512VectorTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVector512Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Float512VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation FloatVector512Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Float512VectorTests extends AbstractVectorTest { +public class FloatVector512Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_512; @@ -1698,7 +1698,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void ADDFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1711,7 +1711,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::ADD); + assertArraysEquals(r, a, b, FloatVector512Tests::ADD); } static float add(float a, float b) { @@ -1719,7 +1719,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void addFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1730,11 +1730,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float512VectorTests::add); + assertArraysEquals(r, a, b, FloatVector512Tests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1750,11 +1750,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float512VectorTests::ADD); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1768,7 +1768,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float512VectorTests::add); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::add); } static float SUB(float a, float b) { @@ -1776,7 +1776,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void SUBFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void SUBFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1789,7 +1789,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::SUB); + assertArraysEquals(r, a, b, FloatVector512Tests::SUB); } static float sub(float a, float b) { @@ -1797,7 +1797,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void subFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1808,11 +1808,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float512VectorTests::sub); + assertArraysEquals(r, a, b, FloatVector512Tests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void SUBFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1828,11 +1828,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float512VectorTests::SUB); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::SUB); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1846,7 +1846,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float512VectorTests::sub); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::sub); } static float MUL(float a, float b) { @@ -1854,7 +1854,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MULFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void MULFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1867,7 +1867,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::MUL); + assertArraysEquals(r, a, b, FloatVector512Tests::MUL); } static float mul(float a, float b) { @@ -1875,7 +1875,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void mulFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1886,11 +1886,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float512VectorTests::mul); + assertArraysEquals(r, a, b, FloatVector512Tests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void MULFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1906,11 +1906,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float512VectorTests::MUL); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::MUL); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1924,7 +1924,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float512VectorTests::mul); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::mul); } static float DIV(float a, float b) { @@ -1932,7 +1932,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void DIVFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void DIVFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1945,7 +1945,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::DIV); + assertArraysEquals(r, a, b, FloatVector512Tests::DIV); } static float div(float a, float b) { @@ -1953,7 +1953,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void divFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1964,11 +1964,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float512VectorTests::div); + assertArraysEquals(r, a, b, FloatVector512Tests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void DIVFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1984,11 +1984,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float512VectorTests::DIV); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::DIV); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2002,7 +2002,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float512VectorTests::div); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::div); } static float FIRST_NONZERO(float a, float b) { @@ -2010,7 +2010,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void FIRST_NONZEROFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2023,11 +2023,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, FloatVector512Tests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void FIRST_NONZEROFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2043,11 +2043,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2057,11 +2057,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, FloatVector512Tests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloat512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addFloatVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2074,11 +2074,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector512Tests::add); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2088,11 +2088,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, FloatVector512Tests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloat512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subFloatVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2105,11 +2105,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector512Tests::sub); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2119,11 +2119,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, FloatVector512Tests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloat512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulFloatVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2136,11 +2136,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector512Tests::mul); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2150,11 +2150,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, FloatVector512Tests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloat512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divFloatVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2167,11 +2167,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector512Tests::div); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloat512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDFloatVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2181,11 +2181,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Float512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, FloatVector512Tests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloat512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDFloatVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2198,13 +2198,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Float512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVector512Tests::ADD); } static FloatVector bv_MIN = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MINFloat512VectorTestsWithMemOp(IntFunction fa) { + static void MINFloatVector512TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2215,13 +2215,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float512VectorTests::MIN); + assertArraysEquals(r, a, (float)10, FloatVector512Tests::MIN); } static FloatVector bv_min = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void minFloat512VectorTestsWithMemOp(IntFunction fa) { + static void minFloatVector512TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2232,13 +2232,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float512VectorTests::min); + assertArraysEquals(r, a, (float)10, FloatVector512Tests::min); } static FloatVector bv_MIN_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINFloat512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINFloatVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2251,13 +2251,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, Float512VectorTests::MIN); + assertArraysEquals(r, a, (float)10, mask, FloatVector512Tests::MIN); } static FloatVector bv_MAX = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MAXFloat512VectorTestsWithMemOp(IntFunction fa) { + static void MAXFloatVector512TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2268,13 +2268,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float512VectorTests::MAX); + assertArraysEquals(r, a, (float)10, FloatVector512Tests::MAX); } static FloatVector bv_max = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void maxFloat512VectorTestsWithMemOp(IntFunction fa) { + static void maxFloatVector512TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2285,13 +2285,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float512VectorTests::max); + assertArraysEquals(r, a, (float)10, FloatVector512Tests::max); } static FloatVector bv_MAX_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXFloat512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXFloatVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2304,7 +2304,7 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, Float512VectorTests::MAX); + assertArraysEquals(r, a, (float)10, mask, FloatVector512Tests::MAX); } static float MIN(float a, float b) { @@ -2312,7 +2312,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void MINFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2325,7 +2325,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::MIN); + assertArraysEquals(r, a, b, FloatVector512Tests::MIN); } static float min(float a, float b) { @@ -2333,7 +2333,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void minFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2344,7 +2344,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float512VectorTests::min); + assertArraysEquals(r, a, b, FloatVector512Tests::min); } static float MAX(float a, float b) { @@ -2352,7 +2352,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void MAXFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2365,7 +2365,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::MAX); + assertArraysEquals(r, a, b, FloatVector512Tests::MAX); } static float max(float a, float b) { @@ -2373,7 +2373,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void maxFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2384,11 +2384,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float512VectorTests::max); + assertArraysEquals(r, a, b, FloatVector512Tests::max); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2398,11 +2398,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float512VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, FloatVector512Tests::MIN); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2412,11 +2412,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float512VectorTests::min); + assertBroadcastArraysEquals(r, a, b, FloatVector512Tests::min); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2426,11 +2426,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float512VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, FloatVector512Tests::MAX); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2440,7 +2440,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float512VectorTests::max); + assertBroadcastArraysEquals(r, a, b, FloatVector512Tests::max); } static float ADDReduce(float[] a, int idx) { @@ -2462,7 +2462,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceFloat512VectorTests(IntFunction fa) { + static void ADDReduceFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2478,7 +2478,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float512VectorTests::ADDReduce, Float512VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVector512Tests::ADDReduce, FloatVector512Tests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2524,7 +2524,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceFloat512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceFloatVector512TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2542,7 +2542,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float512VectorTests::ADDReduceMasked, Float512VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVector512Tests::ADDReduceMasked, FloatVector512Tests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static float MULReduce(float[] a, int idx) { @@ -2564,7 +2564,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MULReduceFloat512VectorTests(IntFunction fa) { + static void MULReduceFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2580,7 +2580,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float512VectorTests::MULReduce, Float512VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVector512Tests::MULReduce, FloatVector512Tests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2626,7 +2626,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MULReduceFloat512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceFloatVector512TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2644,7 +2644,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float512VectorTests::MULReduceMasked, Float512VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVector512Tests::MULReduceMasked, FloatVector512Tests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static float MINReduce(float[] a, int idx) { @@ -2666,7 +2666,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MINReduceFloat512VectorTests(IntFunction fa) { + static void MINReduceFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2682,7 +2682,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float512VectorTests::MINReduce, Float512VectorTests::MINReduceAll); + FloatVector512Tests::MINReduce, FloatVector512Tests::MINReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2728,7 +2728,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINReduceFloat512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceFloatVector512TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2746,7 +2746,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float512VectorTests::MINReduceMasked, Float512VectorTests::MINReduceAllMasked); + FloatVector512Tests::MINReduceMasked, FloatVector512Tests::MINReduceAllMasked); } static float MAXReduce(float[] a, int idx) { @@ -2768,7 +2768,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MAXReduceFloat512VectorTests(IntFunction fa) { + static void MAXReduceFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2784,7 +2784,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float512VectorTests::MAXReduce, Float512VectorTests::MAXReduceAll); + FloatVector512Tests::MAXReduce, FloatVector512Tests::MAXReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2830,7 +2830,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXReduceFloat512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceFloatVector512TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2848,7 +2848,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float512VectorTests::MAXReduceMasked, Float512VectorTests::MAXReduceAllMasked); + FloatVector512Tests::MAXReduceMasked, FloatVector512Tests::MAXReduceAllMasked); } static float FIRST_NONZEROReduce(float[] a, int idx) { @@ -2870,7 +2870,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void FIRST_NONZEROReduceFloat512VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2886,7 +2886,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float512VectorTests::FIRST_NONZEROReduce, Float512VectorTests::FIRST_NONZEROReduceAll); + FloatVector512Tests::FIRST_NONZEROReduce, FloatVector512Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2932,7 +2932,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void FIRST_NONZEROReduceFloat512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceFloatVector512TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2950,11 +2950,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float512VectorTests::FIRST_NONZEROReduceMasked, Float512VectorTests::FIRST_NONZEROReduceAllMasked); + FloatVector512Tests::FIRST_NONZEROReduceMasked, FloatVector512Tests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "floatBinaryOpProvider") - static void withFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void withFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2977,7 +2977,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_DEFAULTFloat512VectorTests(IntFunction fa) { + static void IS_DEFAULTFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2994,7 +2994,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_DEFAULTMaskedFloat512VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3018,7 +3018,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NEGATIVEFloat512VectorTests(IntFunction fa) { + static void IS_NEGATIVEFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3035,7 +3035,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NEGATIVEMaskedFloat512VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3059,7 +3059,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_FINITEFloat512VectorTests(IntFunction fa) { + static void IS_FINITEFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3076,7 +3076,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_FINITEMaskedFloat512VectorTests(IntFunction fa, + static void IS_FINITEMaskedFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3100,7 +3100,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NANFloat512VectorTests(IntFunction fa) { + static void IS_NANFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3117,7 +3117,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NANMaskedFloat512VectorTests(IntFunction fa, + static void IS_NANMaskedFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3141,7 +3141,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_INFINITEFloat512VectorTests(IntFunction fa) { + static void IS_INFINITEFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3158,7 +3158,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_INFINITEMaskedFloat512VectorTests(IntFunction fa, + static void IS_INFINITEMaskedFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3178,7 +3178,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void LTFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3197,7 +3197,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void ltFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3216,7 +3216,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3239,7 +3239,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GTFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void GTFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3258,7 +3258,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GTFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3281,7 +3281,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void EQFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3300,7 +3300,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void eqFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3319,7 +3319,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3342,7 +3342,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void NEFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void NEFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3361,7 +3361,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void NEFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3384,7 +3384,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LEFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void LEFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3403,7 +3403,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LEFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3426,7 +3426,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GEFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void GEFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3445,7 +3445,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GEFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3468,7 +3468,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3484,7 +3484,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTFloatVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3504,7 +3504,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3520,7 +3520,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTFloatVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3540,7 +3540,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3556,7 +3556,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQFloatVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3576,7 +3576,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3592,7 +3592,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQFloatVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3616,7 +3616,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloat512VectorTests(IntFunction fa, IntFunction fb, + static void blendFloatVector512Tests(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3632,11 +3632,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float512VectorTests::blend); + assertArraysEquals(r, a, b, mask, FloatVector512Tests::blend); } @Test(dataProvider = "floatUnaryOpShuffleProvider") - static void RearrangeFloat512VectorTests(IntFunction fa, + static void RearrangeFloatVector512Tests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3653,7 +3653,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpShuffleMaskProvider") - static void RearrangeFloat512VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeFloatVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -3671,7 +3671,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void compressFloat512VectorTests(IntFunction fa, + static void compressFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3689,7 +3689,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void expandFloat512VectorTests(IntFunction fa, + static void expandFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3707,7 +3707,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void getFloat512VectorTests(IntFunction fa) { + static void getFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3863,7 +3863,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void BroadcastFloat512VectorTests(IntFunction fa) { + static void BroadcastFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3877,7 +3877,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ZeroFloat512VectorTests(IntFunction fa) { + static void ZeroFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3902,7 +3902,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void sliceUnaryFloat512VectorTests(IntFunction fa) { + static void sliceUnaryFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3913,7 +3913,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Float512VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, FloatVector512Tests::sliceUnary); } static float[] sliceBinary(float[] a, float[] b, int origin, int idx) { @@ -3930,7 +3930,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void sliceBinaryFloat512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryFloatVector512TestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3943,7 +3943,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, Float512VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, FloatVector512Tests::sliceBinary); } static float[] slice(float[] a, float[] b, int origin, boolean[] mask, int idx) { @@ -3960,7 +3960,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void sliceFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3977,7 +3977,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, Float512VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, FloatVector512Tests::slice); } static float[] unsliceUnary(float[] a, int origin, int idx) { @@ -3994,7 +3994,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void unsliceUnaryFloat512VectorTests(IntFunction fa) { + static void unsliceUnaryFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -4005,7 +4005,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Float512VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, FloatVector512Tests::unsliceUnary); } static float[] unsliceBinary(float[] a, float[] b, int origin, int part, int idx) { @@ -4031,7 +4031,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void unsliceBinaryFloat512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryFloatVector512TestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -4045,7 +4045,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, Float512VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, FloatVector512Tests::unsliceBinary); } static float[] unslice(float[] a, float[] b, int origin, int part, boolean[] mask, int idx) { @@ -4085,7 +4085,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void unsliceFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4102,7 +4102,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, Float512VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, FloatVector512Tests::unslice); } static float SIN(float a) { @@ -4114,7 +4114,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINFloat512VectorTests(IntFunction fa) { + static void SINFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4125,7 +4125,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::SIN, Float512VectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::SIN, FloatVector512Tests::strictSIN); } static float EXP(float a) { @@ -4137,7 +4137,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPFloat512VectorTests(IntFunction fa) { + static void EXPFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4148,7 +4148,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::EXP, Float512VectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::EXP, FloatVector512Tests::strictEXP); } static float LOG1P(float a) { @@ -4160,7 +4160,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG1PFloat512VectorTests(IntFunction fa) { + static void LOG1PFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4171,7 +4171,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::LOG1P, Float512VectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::LOG1P, FloatVector512Tests::strictLOG1P); } static float LOG(float a) { @@ -4183,7 +4183,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOGFloat512VectorTests(IntFunction fa) { + static void LOGFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4194,7 +4194,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::LOG, Float512VectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::LOG, FloatVector512Tests::strictLOG); } static float LOG10(float a) { @@ -4206,7 +4206,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG10Float512VectorTests(IntFunction fa) { + static void LOG10FloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4217,7 +4217,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::LOG10, Float512VectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::LOG10, FloatVector512Tests::strictLOG10); } static float EXPM1(float a) { @@ -4229,7 +4229,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPM1Float512VectorTests(IntFunction fa) { + static void EXPM1FloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4240,7 +4240,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::EXPM1, Float512VectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::EXPM1, FloatVector512Tests::strictEXPM1); } static float COS(float a) { @@ -4252,7 +4252,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSFloat512VectorTests(IntFunction fa) { + static void COSFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4263,7 +4263,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::COS, Float512VectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::COS, FloatVector512Tests::strictCOS); } static float TAN(float a) { @@ -4275,7 +4275,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANFloat512VectorTests(IntFunction fa) { + static void TANFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4286,7 +4286,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::TAN, Float512VectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::TAN, FloatVector512Tests::strictTAN); } static float SINH(float a) { @@ -4298,7 +4298,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINHFloat512VectorTests(IntFunction fa) { + static void SINHFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4309,7 +4309,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::SINH, Float512VectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::SINH, FloatVector512Tests::strictSINH); } static float COSH(float a) { @@ -4321,7 +4321,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSHFloat512VectorTests(IntFunction fa) { + static void COSHFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4332,7 +4332,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::COSH, Float512VectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::COSH, FloatVector512Tests::strictCOSH); } static float TANH(float a) { @@ -4344,7 +4344,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANHFloat512VectorTests(IntFunction fa) { + static void TANHFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4355,7 +4355,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::TANH, Float512VectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::TANH, FloatVector512Tests::strictTANH); } static float ASIN(float a) { @@ -4367,7 +4367,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ASINFloat512VectorTests(IntFunction fa) { + static void ASINFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4378,7 +4378,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::ASIN, Float512VectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::ASIN, FloatVector512Tests::strictASIN); } static float ACOS(float a) { @@ -4390,7 +4390,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ACOSFloat512VectorTests(IntFunction fa) { + static void ACOSFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4401,7 +4401,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::ACOS, Float512VectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::ACOS, FloatVector512Tests::strictACOS); } static float ATAN(float a) { @@ -4413,7 +4413,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ATANFloat512VectorTests(IntFunction fa) { + static void ATANFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4424,7 +4424,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::ATAN, Float512VectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::ATAN, FloatVector512Tests::strictATAN); } static float CBRT(float a) { @@ -4436,7 +4436,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void CBRTFloat512VectorTests(IntFunction fa) { + static void CBRTFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4447,7 +4447,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float512VectorTests::CBRT, Float512VectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, FloatVector512Tests::CBRT, FloatVector512Tests::strictCBRT); } static float HYPOT(float a, float b) { @@ -4459,7 +4459,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void HYPOTFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4472,7 +4472,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float512VectorTests::HYPOT, Float512VectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector512Tests::HYPOT, FloatVector512Tests::strictHYPOT); } @@ -4485,7 +4485,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void POWFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4498,7 +4498,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float512VectorTests::POW, Float512VectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector512Tests::POW, FloatVector512Tests::strictPOW); } @@ -4511,7 +4511,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void powFloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4524,7 +4524,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float512VectorTests::pow, Float512VectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector512Tests::pow, FloatVector512Tests::strictpow); } @@ -4537,7 +4537,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ATAN2Float512VectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2FloatVector512Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4550,12 +4550,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float512VectorTests::ATAN2, Float512VectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector512Tests::ATAN2, FloatVector512Tests::strictATAN2); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4565,12 +4565,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Float512VectorTests::POW, Float512VectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVector512Tests::POW, FloatVector512Tests::strictPOW); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4580,7 +4580,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Float512VectorTests::pow, Float512VectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVector512Tests::pow, FloatVector512Tests::strictpow); } @@ -4593,7 +4593,7 @@ relativeError)); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4608,11 +4608,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, Float512VectorTests::FMA); + assertArraysEquals(r, a, b, c, FloatVector512Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloat512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4625,11 +4625,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Float512VectorTests::fma); + assertArraysEquals(r, a, b, c, FloatVector512Tests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMAFloatVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4647,11 +4647,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, Float512VectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, FloatVector512Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4662,11 +4662,11 @@ relativeError)); FloatVector bv = FloatVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Float512VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, FloatVector512Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4677,11 +4677,11 @@ relativeError)); FloatVector cv = FloatVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Float512VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, FloatVector512Tests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4696,11 +4696,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Float512VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, FloatVector512Tests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat512VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector512TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4715,11 +4715,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Float512VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, FloatVector512Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4730,11 +4730,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Float512VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVector512Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloat512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4745,11 +4745,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Float512VectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVector512Tests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat512VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector512TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4763,7 +4763,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Float512VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FloatVector512Tests::FMA); } static float NEG(float a) { @@ -4775,7 +4775,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void NEGFloat512VectorTests(IntFunction fa) { + static void NEGFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4786,11 +4786,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float512VectorTests::NEG); + assertArraysEquals(r, a, FloatVector512Tests::NEG); } @Test(dataProvider = "floatUnaryOpProvider") - static void negFloat512VectorTests(IntFunction fa) { + static void negFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4801,11 +4801,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float512VectorTests::neg); + assertArraysEquals(r, a, FloatVector512Tests::neg); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void NEGMaskedFloat512VectorTests(IntFunction fa, + static void NEGMaskedFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4819,7 +4819,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float512VectorTests::NEG); + assertArraysEquals(r, a, mask, FloatVector512Tests::NEG); } static float ABS(float a) { @@ -4831,7 +4831,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ABSFloat512VectorTests(IntFunction fa) { + static void ABSFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4842,11 +4842,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float512VectorTests::ABS); + assertArraysEquals(r, a, FloatVector512Tests::ABS); } @Test(dataProvider = "floatUnaryOpProvider") - static void absFloat512VectorTests(IntFunction fa) { + static void absFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4857,11 +4857,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float512VectorTests::abs); + assertArraysEquals(r, a, FloatVector512Tests::abs); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ABSMaskedFloat512VectorTests(IntFunction fa, + static void ABSMaskedFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4875,7 +4875,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float512VectorTests::ABS); + assertArraysEquals(r, a, mask, FloatVector512Tests::ABS); } static float SQRT(float a) { @@ -4887,7 +4887,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SQRTFloat512VectorTests(IntFunction fa) { + static void SQRTFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4898,11 +4898,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float512VectorTests::SQRT); + assertArraysEquals(r, a, FloatVector512Tests::SQRT); } @Test(dataProvider = "floatUnaryOpProvider") - static void sqrtFloat512VectorTests(IntFunction fa) { + static void sqrtFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4913,11 +4913,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float512VectorTests::sqrt); + assertArraysEquals(r, a, FloatVector512Tests::sqrt); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void SQRTMaskedFloat512VectorTests(IntFunction fa, + static void SQRTMaskedFloatVector512Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4931,7 +4931,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float512VectorTests::SQRT); + assertArraysEquals(r, a, mask, FloatVector512Tests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4939,7 +4939,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandFloatVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4952,7 +4952,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::band); + assertArraysEquals(r, a, b, FloatVector512Tests::band); } static boolean bor(boolean a, boolean b) { @@ -4960,7 +4960,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void maskorFloatVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4973,7 +4973,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::bor); + assertArraysEquals(r, a, b, FloatVector512Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -4981,7 +4981,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorFloatVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4994,7 +4994,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::bxor); + assertArraysEquals(r, a, b, FloatVector512Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5002,7 +5002,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotFloatVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5015,7 +5015,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::bandNot); + assertArraysEquals(r, a, b, FloatVector512Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5023,7 +5023,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqFloatVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5036,7 +5036,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float512VectorTests::beq); + assertArraysEquals(r, a, b, FloatVector512Tests::beq); } static boolean unot(boolean a) { @@ -5044,7 +5044,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotFloat512VectorTests(IntFunction fa) { + static void masknotFloatVector512Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5055,7 +5055,7 @@ relativeError)); } } - assertArraysEquals(r, a, Float512VectorTests::unot); + assertArraysEquals(r, a, FloatVector512Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5072,7 +5072,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongFloat512VectorTests(IntFunction fa) { + static void maskFromToLongFloatVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5086,7 +5086,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloat512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltFloatVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5102,7 +5102,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloat512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqFloatVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5118,7 +5118,7 @@ relativeError)); } @Test(dataProvider = "floattoIntUnaryOpProvider") - static void toIntArrayFloat512VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayFloatVector512TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5129,7 +5129,7 @@ relativeError)); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void toLongArrayFloat512VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayFloatVector512TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5140,7 +5140,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toDoubleArrayFloat512VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayFloatVector512TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5151,7 +5151,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toStringFloat512VectorTestsSmokeTest(IntFunction fa) { + static void toStringFloatVector512TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5164,7 +5164,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void hashCodeFloat512VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeFloatVector512TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5197,7 +5197,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceLongFloat512VectorTests(IntFunction fa) { + static void ADDReduceLongFloatVector512Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5213,7 +5213,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - Float512VectorTests::ADDReduceLong, Float512VectorTests::ADDReduceAllLong); + FloatVector512Tests::ADDReduceLong, FloatVector512Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(float[] a, int idx, boolean[] mask) { @@ -5236,7 +5236,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceLongFloat512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongFloatVector512TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5254,11 +5254,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Float512VectorTests::ADDReduceLongMasked, Float512VectorTests::ADDReduceAllLongMasked); + FloatVector512Tests::ADDReduceLongMasked, FloatVector512Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void BroadcastLongFloat512VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongFloatVector512TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -5269,7 +5269,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloat512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendFloatVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5283,12 +5283,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Float512VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVector512Tests::blend); } @Test(dataProvider = "floatUnaryOpSelectFromProvider") - static void SelectFromFloat512VectorTests(IntFunction fa, + static void SelectFromFloatVector512Tests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); float[] order = fs.apply(a.length, SPECIES.length()); @@ -5304,7 +5304,7 @@ relativeError)); } @Test(dataProvider = "floatSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorFloat512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorFloatVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] idx = fc.apply(SPECIES.length()); @@ -5322,7 +5322,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpSelectFromMaskProvider") - static void SelectFromFloat512VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromFloatVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -5341,7 +5341,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousFloat512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousFloatVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5357,7 +5357,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringFloat512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringFloatVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5371,7 +5371,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsFloat512VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsFloatVector512TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5385,7 +5385,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsFloat512VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsFloatVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5401,7 +5401,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeFloat512VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeFloatVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5423,7 +5423,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountFloat512VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountFloatVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5434,7 +5434,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float512VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, FloatVector512Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5448,7 +5448,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueFloat512VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueFloatVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5459,7 +5459,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float512VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, FloatVector512Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5473,7 +5473,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueFloat512VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueFloatVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5484,11 +5484,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float512VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, FloatVector512Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressFloat512VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressFloatVector512TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5516,7 +5516,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeFloat512VectorTestsSmokeTest(int offset) { + static void indexInRangeFloatVector512TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5530,7 +5530,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongFloat512VectorTestsSmokeTest(int offset) { + static void indexInRangeLongFloatVector512TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5557,14 +5557,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundFloat512VectorTestsSmokeTest(int length) { + static void loopBoundFloatVector512TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongFloat512VectorTestsSmokeTest(int _length) { + static void loopBoundLongFloatVector512TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5572,21 +5572,21 @@ relativeError)); } @Test - static void ElementSizeFloat512VectorTestsSmokeTest() { + static void ElementSizeFloatVector512TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Float.SIZE); } @Test - static void VectorShapeFloat512VectorTestsSmokeTest() { + static void VectorShapeFloatVector512TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_512_BIT)); } @Test - static void ShapeWithLanesFloat512VectorTestsSmokeTest() { + static void ShapeWithLanesFloatVector512TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(float.class); @@ -5594,32 +5594,32 @@ relativeError)); } @Test - static void ElementTypeFloat512VectorTestsSmokeTest() { + static void ElementTypeFloatVector512TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementType() == float.class); } @Test - static void SpeciesElementSizeFloat512VectorTestsSmokeTest() { + static void SpeciesElementSizeFloatVector512TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementSize() == Float.SIZE); } @Test - static void VectorTypeFloat512VectorTestsSmokeTest() { + static void VectorTypeFloatVector512TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesFloat512VectorTestsSmokeTest() { + static void WithLanesFloatVector512TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(float.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeFloat512VectorTestsSmokeTest() { + static void WithShapeFloatVector512TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5627,7 +5627,7 @@ relativeError)); } @Test - static void MaskAllTrueFloat512VectorTestsSmokeTest() { + static void MaskAllTrueFloatVector512TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Float64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/FloatVector64LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Float64VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/FloatVector64LoadStoreTests.java index afa08dc8f33..359558abbd1 100644 --- a/test/jdk/jdk/incubator/vector/Float64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVector64LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Float64VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation FloatVector64LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Float64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class FloatVector64LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_64; diff --git a/test/jdk/jdk/incubator/vector/Float64VectorTests.java b/test/jdk/jdk/incubator/vector/FloatVector64Tests.java similarity index 91% rename from test/jdk/jdk/incubator/vector/Float64VectorTests.java rename to test/jdk/jdk/incubator/vector/FloatVector64Tests.java index 4a8f917b50e..663a56dfe26 100644 --- a/test/jdk/jdk/incubator/vector/Float64VectorTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVector64Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Float64VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation FloatVector64Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Float64VectorTests extends AbstractVectorTest { +public class FloatVector64Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_64; @@ -1698,7 +1698,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void ADDFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1711,7 +1711,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::ADD); + assertArraysEquals(r, a, b, FloatVector64Tests::ADD); } static float add(float a, float b) { @@ -1719,7 +1719,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void addFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1730,11 +1730,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float64VectorTests::add); + assertArraysEquals(r, a, b, FloatVector64Tests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1750,11 +1750,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float64VectorTests::ADD); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1768,7 +1768,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float64VectorTests::add); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::add); } static float SUB(float a, float b) { @@ -1776,7 +1776,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void SUBFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void SUBFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1789,7 +1789,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::SUB); + assertArraysEquals(r, a, b, FloatVector64Tests::SUB); } static float sub(float a, float b) { @@ -1797,7 +1797,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void subFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1808,11 +1808,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float64VectorTests::sub); + assertArraysEquals(r, a, b, FloatVector64Tests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void SUBFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1828,11 +1828,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float64VectorTests::SUB); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::SUB); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1846,7 +1846,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float64VectorTests::sub); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::sub); } static float MUL(float a, float b) { @@ -1854,7 +1854,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MULFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void MULFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1867,7 +1867,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::MUL); + assertArraysEquals(r, a, b, FloatVector64Tests::MUL); } static float mul(float a, float b) { @@ -1875,7 +1875,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void mulFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1886,11 +1886,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float64VectorTests::mul); + assertArraysEquals(r, a, b, FloatVector64Tests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void MULFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1906,11 +1906,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float64VectorTests::MUL); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::MUL); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1924,7 +1924,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float64VectorTests::mul); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::mul); } static float DIV(float a, float b) { @@ -1932,7 +1932,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void DIVFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void DIVFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1945,7 +1945,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::DIV); + assertArraysEquals(r, a, b, FloatVector64Tests::DIV); } static float div(float a, float b) { @@ -1953,7 +1953,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void divFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1964,11 +1964,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float64VectorTests::div); + assertArraysEquals(r, a, b, FloatVector64Tests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void DIVFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1984,11 +1984,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float64VectorTests::DIV); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::DIV); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2002,7 +2002,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Float64VectorTests::div); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::div); } static float FIRST_NONZERO(float a, float b) { @@ -2010,7 +2010,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void FIRST_NONZEROFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2023,11 +2023,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, FloatVector64Tests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void FIRST_NONZEROFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2043,11 +2043,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2057,11 +2057,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, FloatVector64Tests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloat64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addFloatVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2074,11 +2074,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector64Tests::add); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2088,11 +2088,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, FloatVector64Tests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloat64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subFloatVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2105,11 +2105,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector64Tests::sub); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2119,11 +2119,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, FloatVector64Tests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloat64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulFloatVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2136,11 +2136,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector64Tests::mul); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2150,11 +2150,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, FloatVector64Tests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloat64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divFloatVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2167,11 +2167,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Float64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, FloatVector64Tests::div); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloat64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDFloatVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2181,11 +2181,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Float64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, FloatVector64Tests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloat64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDFloatVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2198,13 +2198,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Float64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVector64Tests::ADD); } static FloatVector bv_MIN = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MINFloat64VectorTestsWithMemOp(IntFunction fa) { + static void MINFloatVector64TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2215,13 +2215,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float64VectorTests::MIN); + assertArraysEquals(r, a, (float)10, FloatVector64Tests::MIN); } static FloatVector bv_min = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void minFloat64VectorTestsWithMemOp(IntFunction fa) { + static void minFloatVector64TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2232,13 +2232,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float64VectorTests::min); + assertArraysEquals(r, a, (float)10, FloatVector64Tests::min); } static FloatVector bv_MIN_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINFloat64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINFloatVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2251,13 +2251,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, Float64VectorTests::MIN); + assertArraysEquals(r, a, (float)10, mask, FloatVector64Tests::MIN); } static FloatVector bv_MAX = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MAXFloat64VectorTestsWithMemOp(IntFunction fa) { + static void MAXFloatVector64TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2268,13 +2268,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float64VectorTests::MAX); + assertArraysEquals(r, a, (float)10, FloatVector64Tests::MAX); } static FloatVector bv_max = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void maxFloat64VectorTestsWithMemOp(IntFunction fa) { + static void maxFloatVector64TestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2285,13 +2285,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, Float64VectorTests::max); + assertArraysEquals(r, a, (float)10, FloatVector64Tests::max); } static FloatVector bv_MAX_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXFloat64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXFloatVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2304,7 +2304,7 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, Float64VectorTests::MAX); + assertArraysEquals(r, a, (float)10, mask, FloatVector64Tests::MAX); } static float MIN(float a, float b) { @@ -2312,7 +2312,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void MINFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2325,7 +2325,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::MIN); + assertArraysEquals(r, a, b, FloatVector64Tests::MIN); } static float min(float a, float b) { @@ -2333,7 +2333,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void minFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2344,7 +2344,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float64VectorTests::min); + assertArraysEquals(r, a, b, FloatVector64Tests::min); } static float MAX(float a, float b) { @@ -2352,7 +2352,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void MAXFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2365,7 +2365,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::MAX); + assertArraysEquals(r, a, b, FloatVector64Tests::MAX); } static float max(float a, float b) { @@ -2373,7 +2373,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void maxFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2384,11 +2384,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Float64VectorTests::max); + assertArraysEquals(r, a, b, FloatVector64Tests::max); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2398,11 +2398,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float64VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, FloatVector64Tests::MIN); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2412,11 +2412,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float64VectorTests::min); + assertBroadcastArraysEquals(r, a, b, FloatVector64Tests::min); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2426,11 +2426,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float64VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, FloatVector64Tests::MAX); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2440,7 +2440,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Float64VectorTests::max); + assertBroadcastArraysEquals(r, a, b, FloatVector64Tests::max); } static float ADDReduce(float[] a, int idx) { @@ -2462,7 +2462,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceFloat64VectorTests(IntFunction fa) { + static void ADDReduceFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2478,7 +2478,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float64VectorTests::ADDReduce, Float64VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVector64Tests::ADDReduce, FloatVector64Tests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2524,7 +2524,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceFloat64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceFloatVector64TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2542,7 +2542,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float64VectorTests::ADDReduceMasked, Float64VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVector64Tests::ADDReduceMasked, FloatVector64Tests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static float MULReduce(float[] a, int idx) { @@ -2564,7 +2564,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MULReduceFloat64VectorTests(IntFunction fa) { + static void MULReduceFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2580,7 +2580,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float64VectorTests::MULReduce, Float64VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVector64Tests::MULReduce, FloatVector64Tests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2626,7 +2626,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MULReduceFloat64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceFloatVector64TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2644,7 +2644,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float64VectorTests::MULReduceMasked, Float64VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVector64Tests::MULReduceMasked, FloatVector64Tests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static float MINReduce(float[] a, int idx) { @@ -2666,7 +2666,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MINReduceFloat64VectorTests(IntFunction fa) { + static void MINReduceFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2682,7 +2682,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float64VectorTests::MINReduce, Float64VectorTests::MINReduceAll); + FloatVector64Tests::MINReduce, FloatVector64Tests::MINReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2728,7 +2728,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINReduceFloat64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceFloatVector64TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2746,7 +2746,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float64VectorTests::MINReduceMasked, Float64VectorTests::MINReduceAllMasked); + FloatVector64Tests::MINReduceMasked, FloatVector64Tests::MINReduceAllMasked); } static float MAXReduce(float[] a, int idx) { @@ -2768,7 +2768,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MAXReduceFloat64VectorTests(IntFunction fa) { + static void MAXReduceFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2784,7 +2784,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float64VectorTests::MAXReduce, Float64VectorTests::MAXReduceAll); + FloatVector64Tests::MAXReduce, FloatVector64Tests::MAXReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2830,7 +2830,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXReduceFloat64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceFloatVector64TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2848,7 +2848,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float64VectorTests::MAXReduceMasked, Float64VectorTests::MAXReduceAllMasked); + FloatVector64Tests::MAXReduceMasked, FloatVector64Tests::MAXReduceAllMasked); } static float FIRST_NONZEROReduce(float[] a, int idx) { @@ -2870,7 +2870,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void FIRST_NONZEROReduceFloat64VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2886,7 +2886,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - Float64VectorTests::FIRST_NONZEROReduce, Float64VectorTests::FIRST_NONZEROReduceAll); + FloatVector64Tests::FIRST_NONZEROReduce, FloatVector64Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2932,7 +2932,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void FIRST_NONZEROReduceFloat64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceFloatVector64TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2950,11 +2950,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - Float64VectorTests::FIRST_NONZEROReduceMasked, Float64VectorTests::FIRST_NONZEROReduceAllMasked); + FloatVector64Tests::FIRST_NONZEROReduceMasked, FloatVector64Tests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "floatBinaryOpProvider") - static void withFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void withFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2977,7 +2977,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_DEFAULTFloat64VectorTests(IntFunction fa) { + static void IS_DEFAULTFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -2994,7 +2994,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_DEFAULTMaskedFloat64VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3018,7 +3018,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NEGATIVEFloat64VectorTests(IntFunction fa) { + static void IS_NEGATIVEFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3035,7 +3035,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NEGATIVEMaskedFloat64VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3059,7 +3059,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_FINITEFloat64VectorTests(IntFunction fa) { + static void IS_FINITEFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3076,7 +3076,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_FINITEMaskedFloat64VectorTests(IntFunction fa, + static void IS_FINITEMaskedFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3100,7 +3100,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NANFloat64VectorTests(IntFunction fa) { + static void IS_NANFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3117,7 +3117,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NANMaskedFloat64VectorTests(IntFunction fa, + static void IS_NANMaskedFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3141,7 +3141,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_INFINITEFloat64VectorTests(IntFunction fa) { + static void IS_INFINITEFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3158,7 +3158,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_INFINITEMaskedFloat64VectorTests(IntFunction fa, + static void IS_INFINITEMaskedFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3178,7 +3178,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void LTFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3197,7 +3197,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void ltFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3216,7 +3216,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3239,7 +3239,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GTFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void GTFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3258,7 +3258,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GTFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3281,7 +3281,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void EQFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3300,7 +3300,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void eqFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3319,7 +3319,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3342,7 +3342,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void NEFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void NEFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3361,7 +3361,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void NEFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3384,7 +3384,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LEFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void LEFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3403,7 +3403,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LEFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3426,7 +3426,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GEFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void GEFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3445,7 +3445,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GEFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3468,7 +3468,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3484,7 +3484,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTFloatVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3504,7 +3504,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloat64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3520,7 +3520,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloat64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTFloatVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3540,7 +3540,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3556,7 +3556,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQFloatVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3576,7 +3576,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloat64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3592,7 +3592,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloat64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQFloatVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3616,7 +3616,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloat64VectorTests(IntFunction fa, IntFunction fb, + static void blendFloatVector64Tests(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3632,11 +3632,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, Float64VectorTests::blend); + assertArraysEquals(r, a, b, mask, FloatVector64Tests::blend); } @Test(dataProvider = "floatUnaryOpShuffleProvider") - static void RearrangeFloat64VectorTests(IntFunction fa, + static void RearrangeFloatVector64Tests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3653,7 +3653,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpShuffleMaskProvider") - static void RearrangeFloat64VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeFloatVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -3671,7 +3671,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void compressFloat64VectorTests(IntFunction fa, + static void compressFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3689,7 +3689,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void expandFloat64VectorTests(IntFunction fa, + static void expandFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3707,7 +3707,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void getFloat64VectorTests(IntFunction fa) { + static void getFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3863,7 +3863,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void BroadcastFloat64VectorTests(IntFunction fa) { + static void BroadcastFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3877,7 +3877,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ZeroFloat64VectorTests(IntFunction fa) { + static void ZeroFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3902,7 +3902,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void sliceUnaryFloat64VectorTests(IntFunction fa) { + static void sliceUnaryFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3913,7 +3913,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Float64VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, FloatVector64Tests::sliceUnary); } static float[] sliceBinary(float[] a, float[] b, int origin, int idx) { @@ -3930,7 +3930,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void sliceBinaryFloat64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryFloatVector64TestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3943,7 +3943,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, Float64VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, FloatVector64Tests::sliceBinary); } static float[] slice(float[] a, float[] b, int origin, boolean[] mask, int idx) { @@ -3960,7 +3960,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void sliceFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3977,7 +3977,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, Float64VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, FloatVector64Tests::slice); } static float[] unsliceUnary(float[] a, int origin, int idx) { @@ -3994,7 +3994,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void unsliceUnaryFloat64VectorTests(IntFunction fa) { + static void unsliceUnaryFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -4005,7 +4005,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, Float64VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, FloatVector64Tests::unsliceUnary); } static float[] unsliceBinary(float[] a, float[] b, int origin, int part, int idx) { @@ -4031,7 +4031,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void unsliceBinaryFloat64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryFloatVector64TestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -4045,7 +4045,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, Float64VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, FloatVector64Tests::unsliceBinary); } static float[] unslice(float[] a, float[] b, int origin, int part, boolean[] mask, int idx) { @@ -4085,7 +4085,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void unsliceFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4102,7 +4102,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, Float64VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, FloatVector64Tests::unslice); } static float SIN(float a) { @@ -4114,7 +4114,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINFloat64VectorTests(IntFunction fa) { + static void SINFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4125,7 +4125,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::SIN, Float64VectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::SIN, FloatVector64Tests::strictSIN); } static float EXP(float a) { @@ -4137,7 +4137,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPFloat64VectorTests(IntFunction fa) { + static void EXPFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4148,7 +4148,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::EXP, Float64VectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::EXP, FloatVector64Tests::strictEXP); } static float LOG1P(float a) { @@ -4160,7 +4160,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG1PFloat64VectorTests(IntFunction fa) { + static void LOG1PFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4171,7 +4171,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::LOG1P, Float64VectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::LOG1P, FloatVector64Tests::strictLOG1P); } static float LOG(float a) { @@ -4183,7 +4183,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOGFloat64VectorTests(IntFunction fa) { + static void LOGFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4194,7 +4194,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::LOG, Float64VectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::LOG, FloatVector64Tests::strictLOG); } static float LOG10(float a) { @@ -4206,7 +4206,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG10Float64VectorTests(IntFunction fa) { + static void LOG10FloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4217,7 +4217,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::LOG10, Float64VectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::LOG10, FloatVector64Tests::strictLOG10); } static float EXPM1(float a) { @@ -4229,7 +4229,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPM1Float64VectorTests(IntFunction fa) { + static void EXPM1FloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4240,7 +4240,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::EXPM1, Float64VectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::EXPM1, FloatVector64Tests::strictEXPM1); } static float COS(float a) { @@ -4252,7 +4252,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSFloat64VectorTests(IntFunction fa) { + static void COSFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4263,7 +4263,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::COS, Float64VectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::COS, FloatVector64Tests::strictCOS); } static float TAN(float a) { @@ -4275,7 +4275,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANFloat64VectorTests(IntFunction fa) { + static void TANFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4286,7 +4286,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::TAN, Float64VectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::TAN, FloatVector64Tests::strictTAN); } static float SINH(float a) { @@ -4298,7 +4298,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINHFloat64VectorTests(IntFunction fa) { + static void SINHFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4309,7 +4309,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::SINH, Float64VectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::SINH, FloatVector64Tests::strictSINH); } static float COSH(float a) { @@ -4321,7 +4321,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSHFloat64VectorTests(IntFunction fa) { + static void COSHFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4332,7 +4332,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::COSH, Float64VectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::COSH, FloatVector64Tests::strictCOSH); } static float TANH(float a) { @@ -4344,7 +4344,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANHFloat64VectorTests(IntFunction fa) { + static void TANHFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4355,7 +4355,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::TANH, Float64VectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::TANH, FloatVector64Tests::strictTANH); } static float ASIN(float a) { @@ -4367,7 +4367,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ASINFloat64VectorTests(IntFunction fa) { + static void ASINFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4378,7 +4378,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::ASIN, Float64VectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::ASIN, FloatVector64Tests::strictASIN); } static float ACOS(float a) { @@ -4390,7 +4390,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ACOSFloat64VectorTests(IntFunction fa) { + static void ACOSFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4401,7 +4401,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::ACOS, Float64VectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::ACOS, FloatVector64Tests::strictACOS); } static float ATAN(float a) { @@ -4413,7 +4413,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ATANFloat64VectorTests(IntFunction fa) { + static void ATANFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4424,7 +4424,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::ATAN, Float64VectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::ATAN, FloatVector64Tests::strictATAN); } static float CBRT(float a) { @@ -4436,7 +4436,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void CBRTFloat64VectorTests(IntFunction fa) { + static void CBRTFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4447,7 +4447,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, Float64VectorTests::CBRT, Float64VectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, FloatVector64Tests::CBRT, FloatVector64Tests::strictCBRT); } static float HYPOT(float a, float b) { @@ -4459,7 +4459,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void HYPOTFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4472,7 +4472,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float64VectorTests::HYPOT, Float64VectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector64Tests::HYPOT, FloatVector64Tests::strictHYPOT); } @@ -4485,7 +4485,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void POWFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4498,7 +4498,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float64VectorTests::POW, Float64VectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector64Tests::POW, FloatVector64Tests::strictPOW); } @@ -4511,7 +4511,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void powFloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4524,7 +4524,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float64VectorTests::pow, Float64VectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector64Tests::pow, FloatVector64Tests::strictpow); } @@ -4537,7 +4537,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ATAN2Float64VectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2FloatVector64Tests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4550,12 +4550,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, Float64VectorTests::ATAN2, Float64VectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVector64Tests::ATAN2, FloatVector64Tests::strictATAN2); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4565,12 +4565,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Float64VectorTests::POW, Float64VectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVector64Tests::POW, FloatVector64Tests::strictPOW); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4580,7 +4580,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Float64VectorTests::pow, Float64VectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVector64Tests::pow, FloatVector64Tests::strictpow); } @@ -4593,7 +4593,7 @@ relativeError)); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4608,11 +4608,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, Float64VectorTests::FMA); + assertArraysEquals(r, a, b, c, FloatVector64Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloat64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4625,11 +4625,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Float64VectorTests::fma); + assertArraysEquals(r, a, b, c, FloatVector64Tests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMAFloatVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4647,11 +4647,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, Float64VectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, FloatVector64Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4662,11 +4662,11 @@ relativeError)); FloatVector bv = FloatVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Float64VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, FloatVector64Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4677,11 +4677,11 @@ relativeError)); FloatVector cv = FloatVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Float64VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, FloatVector64Tests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4696,11 +4696,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Float64VectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, FloatVector64Tests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat64VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector64TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4715,11 +4715,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Float64VectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, FloatVector64Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloat64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4730,11 +4730,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Float64VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVector64Tests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloat64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4745,11 +4745,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Float64VectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVector64Tests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloat64VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVector64TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4763,7 +4763,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Float64VectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FloatVector64Tests::FMA); } static float NEG(float a) { @@ -4775,7 +4775,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void NEGFloat64VectorTests(IntFunction fa) { + static void NEGFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4786,11 +4786,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float64VectorTests::NEG); + assertArraysEquals(r, a, FloatVector64Tests::NEG); } @Test(dataProvider = "floatUnaryOpProvider") - static void negFloat64VectorTests(IntFunction fa) { + static void negFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4801,11 +4801,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float64VectorTests::neg); + assertArraysEquals(r, a, FloatVector64Tests::neg); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void NEGMaskedFloat64VectorTests(IntFunction fa, + static void NEGMaskedFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4819,7 +4819,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float64VectorTests::NEG); + assertArraysEquals(r, a, mask, FloatVector64Tests::NEG); } static float ABS(float a) { @@ -4831,7 +4831,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ABSFloat64VectorTests(IntFunction fa) { + static void ABSFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4842,11 +4842,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float64VectorTests::ABS); + assertArraysEquals(r, a, FloatVector64Tests::ABS); } @Test(dataProvider = "floatUnaryOpProvider") - static void absFloat64VectorTests(IntFunction fa) { + static void absFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4857,11 +4857,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float64VectorTests::abs); + assertArraysEquals(r, a, FloatVector64Tests::abs); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ABSMaskedFloat64VectorTests(IntFunction fa, + static void ABSMaskedFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4875,7 +4875,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float64VectorTests::ABS); + assertArraysEquals(r, a, mask, FloatVector64Tests::ABS); } static float SQRT(float a) { @@ -4887,7 +4887,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SQRTFloat64VectorTests(IntFunction fa) { + static void SQRTFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4898,11 +4898,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float64VectorTests::SQRT); + assertArraysEquals(r, a, FloatVector64Tests::SQRT); } @Test(dataProvider = "floatUnaryOpProvider") - static void sqrtFloat64VectorTests(IntFunction fa) { + static void sqrtFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4913,11 +4913,11 @@ relativeError)); } } - assertArraysEquals(r, a, Float64VectorTests::sqrt); + assertArraysEquals(r, a, FloatVector64Tests::sqrt); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void SQRTMaskedFloat64VectorTests(IntFunction fa, + static void SQRTMaskedFloatVector64Tests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4931,7 +4931,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, Float64VectorTests::SQRT); + assertArraysEquals(r, a, mask, FloatVector64Tests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4939,7 +4939,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandFloatVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4952,7 +4952,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::band); + assertArraysEquals(r, a, b, FloatVector64Tests::band); } static boolean bor(boolean a, boolean b) { @@ -4960,7 +4960,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void maskorFloatVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4973,7 +4973,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::bor); + assertArraysEquals(r, a, b, FloatVector64Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -4981,7 +4981,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorFloatVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4994,7 +4994,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::bxor); + assertArraysEquals(r, a, b, FloatVector64Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5002,7 +5002,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotFloatVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5015,7 +5015,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::bandNot); + assertArraysEquals(r, a, b, FloatVector64Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5023,7 +5023,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqFloatVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5036,7 +5036,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, Float64VectorTests::beq); + assertArraysEquals(r, a, b, FloatVector64Tests::beq); } static boolean unot(boolean a) { @@ -5044,7 +5044,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotFloat64VectorTests(IntFunction fa) { + static void masknotFloatVector64Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5055,7 +5055,7 @@ relativeError)); } } - assertArraysEquals(r, a, Float64VectorTests::unot); + assertArraysEquals(r, a, FloatVector64Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5072,7 +5072,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongFloat64VectorTests(IntFunction fa) { + static void maskFromToLongFloatVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5086,7 +5086,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloat64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltFloatVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5102,7 +5102,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloat64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqFloatVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5118,7 +5118,7 @@ relativeError)); } @Test(dataProvider = "floattoIntUnaryOpProvider") - static void toIntArrayFloat64VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayFloatVector64TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5129,7 +5129,7 @@ relativeError)); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void toLongArrayFloat64VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayFloatVector64TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5140,7 +5140,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toDoubleArrayFloat64VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayFloatVector64TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5151,7 +5151,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toStringFloat64VectorTestsSmokeTest(IntFunction fa) { + static void toStringFloatVector64TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5164,7 +5164,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void hashCodeFloat64VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeFloatVector64TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5197,7 +5197,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceLongFloat64VectorTests(IntFunction fa) { + static void ADDReduceLongFloatVector64Tests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5213,7 +5213,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - Float64VectorTests::ADDReduceLong, Float64VectorTests::ADDReduceAllLong); + FloatVector64Tests::ADDReduceLong, FloatVector64Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(float[] a, int idx, boolean[] mask) { @@ -5236,7 +5236,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceLongFloat64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongFloatVector64TestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5254,11 +5254,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Float64VectorTests::ADDReduceLongMasked, Float64VectorTests::ADDReduceAllLongMasked); + FloatVector64Tests::ADDReduceLongMasked, FloatVector64Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void BroadcastLongFloat64VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongFloatVector64TestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -5269,7 +5269,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloat64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendFloatVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5283,12 +5283,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Float64VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVector64Tests::blend); } @Test(dataProvider = "floatUnaryOpSelectFromProvider") - static void SelectFromFloat64VectorTests(IntFunction fa, + static void SelectFromFloatVector64Tests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); float[] order = fs.apply(a.length, SPECIES.length()); @@ -5304,7 +5304,7 @@ relativeError)); } @Test(dataProvider = "floatSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorFloat64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorFloatVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] idx = fc.apply(SPECIES.length()); @@ -5322,7 +5322,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpSelectFromMaskProvider") - static void SelectFromFloat64VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromFloatVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -5341,7 +5341,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousFloat64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousFloatVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5357,7 +5357,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringFloat64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringFloatVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5371,7 +5371,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsFloat64VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsFloatVector64TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5385,7 +5385,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsFloat64VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsFloatVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5401,7 +5401,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeFloat64VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeFloatVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5423,7 +5423,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountFloat64VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountFloatVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5434,7 +5434,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float64VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, FloatVector64Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5448,7 +5448,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueFloat64VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueFloatVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5459,7 +5459,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float64VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, FloatVector64Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5473,7 +5473,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueFloat64VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueFloatVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5484,11 +5484,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, Float64VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, FloatVector64Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressFloat64VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressFloatVector64TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5516,7 +5516,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeFloat64VectorTestsSmokeTest(int offset) { + static void indexInRangeFloatVector64TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5530,7 +5530,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongFloat64VectorTestsSmokeTest(int offset) { + static void indexInRangeLongFloatVector64TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5557,14 +5557,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundFloat64VectorTestsSmokeTest(int length) { + static void loopBoundFloatVector64TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongFloat64VectorTestsSmokeTest(int _length) { + static void loopBoundLongFloatVector64TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5572,21 +5572,21 @@ relativeError)); } @Test - static void ElementSizeFloat64VectorTestsSmokeTest() { + static void ElementSizeFloatVector64TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Float.SIZE); } @Test - static void VectorShapeFloat64VectorTestsSmokeTest() { + static void VectorShapeFloatVector64TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_64_BIT)); } @Test - static void ShapeWithLanesFloat64VectorTestsSmokeTest() { + static void ShapeWithLanesFloatVector64TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(float.class); @@ -5594,32 +5594,32 @@ relativeError)); } @Test - static void ElementTypeFloat64VectorTestsSmokeTest() { + static void ElementTypeFloatVector64TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementType() == float.class); } @Test - static void SpeciesElementSizeFloat64VectorTestsSmokeTest() { + static void SpeciesElementSizeFloatVector64TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementSize() == Float.SIZE); } @Test - static void VectorTypeFloat64VectorTestsSmokeTest() { + static void VectorTypeFloatVector64TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesFloat64VectorTestsSmokeTest() { + static void WithLanesFloatVector64TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(float.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeFloat64VectorTestsSmokeTest() { + static void WithShapeFloatVector64TestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5627,7 +5627,7 @@ relativeError)); } @Test - static void MaskAllTrueFloat64VectorTestsSmokeTest() { + static void MaskAllTrueFloatVector64TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/FloatMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/FloatVectorMaxLoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/FloatMaxVectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/FloatVectorMaxLoadStoreTests.java index 931e9b78306..d1832ea8e3a 100644 --- a/test/jdk/jdk/incubator/vector/FloatMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVectorMaxLoadStoreTests.java @@ -28,7 +28,7 @@ * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation * @run testng/othervm --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED - * -XX:-TieredCompilation FloatMaxVectorLoadStoreTests + * -XX:-TieredCompilation FloatVectorMaxLoadStoreTests * */ @@ -52,7 +52,7 @@ import java.util.List; import java.util.function.*; @Test -public class FloatMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class FloatVectorMaxLoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_MAX; diff --git a/test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java b/test/jdk/jdk/incubator/vector/FloatVectorMaxTests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java rename to test/jdk/jdk/incubator/vector/FloatVectorMaxTests.java index 6ea96388706..9d272f43863 100644 --- a/test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java +++ b/test/jdk/jdk/incubator/vector/FloatVectorMaxTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation FloatMaxVectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation FloatVectorMaxTests */ // -- This file was mechanically generated: Do not edit! -- // @@ -55,7 +55,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class FloatMaxVectorTests extends AbstractVectorTest { +public class FloatVectorMaxTests extends AbstractVectorTest { static final VectorSpecies SPECIES = FloatVector.SPECIES_MAX; @@ -1704,7 +1704,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ADDFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1717,7 +1717,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::ADD); + assertArraysEquals(r, a, b, FloatVectorMaxTests::ADD); } static float add(float a, float b) { @@ -1725,7 +1725,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void addFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1736,11 +1736,11 @@ relativeError)); av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, FloatMaxVectorTests::add); + assertArraysEquals(r, a, b, FloatVectorMaxTests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1756,11 +1756,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::ADD); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void addFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1774,7 +1774,7 @@ relativeError)); av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::add); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::add); } static float SUB(float a, float b) { @@ -1782,7 +1782,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void SUBFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUBFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1795,7 +1795,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::SUB); + assertArraysEquals(r, a, b, FloatVectorMaxTests::SUB); } static float sub(float a, float b) { @@ -1803,7 +1803,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void subFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1814,11 +1814,11 @@ relativeError)); av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, FloatMaxVectorTests::sub); + assertArraysEquals(r, a, b, FloatVectorMaxTests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void SUBFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1834,11 +1834,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::SUB); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::SUB); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void subFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1852,7 +1852,7 @@ relativeError)); av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::sub); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::sub); } static float MUL(float a, float b) { @@ -1860,7 +1860,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MULFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MULFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1873,7 +1873,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::MUL); + assertArraysEquals(r, a, b, FloatVectorMaxTests::MUL); } static float mul(float a, float b) { @@ -1881,7 +1881,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void mulFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1892,11 +1892,11 @@ relativeError)); av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, FloatMaxVectorTests::mul); + assertArraysEquals(r, a, b, FloatVectorMaxTests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void MULFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1912,11 +1912,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::MUL); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::MUL); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1930,7 +1930,7 @@ relativeError)); av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::mul); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::mul); } static float DIV(float a, float b) { @@ -1938,7 +1938,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void DIVFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void DIVFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1951,7 +1951,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::DIV); + assertArraysEquals(r, a, b, FloatVectorMaxTests::DIV); } static float div(float a, float b) { @@ -1959,7 +1959,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void divFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -1970,11 +1970,11 @@ relativeError)); av.div(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, FloatMaxVectorTests::div); + assertArraysEquals(r, a, b, FloatVectorMaxTests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void DIVFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -1990,11 +1990,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::DIV); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::DIV); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void divFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2008,7 +2008,7 @@ relativeError)); av.div(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::div); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::div); } static float FIRST_NONZERO(float a, float b) { @@ -2016,7 +2016,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void FIRST_NONZEROFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2029,11 +2029,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, FloatVectorMaxTests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void FIRST_NONZEROFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2049,11 +2049,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::FIRST_NONZERO); } @Test(dataProvider = "floatBinaryOpProvider") - static void addFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2063,11 +2063,11 @@ relativeError)); av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, FloatVectorMaxTests::add); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void addFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addFloatVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2080,11 +2080,11 @@ relativeError)); av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, FloatMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, FloatVectorMaxTests::add); } @Test(dataProvider = "floatBinaryOpProvider") - static void subFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2094,11 +2094,11 @@ relativeError)); av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, FloatVectorMaxTests::sub); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void subFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subFloatVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2111,11 +2111,11 @@ relativeError)); av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, FloatMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, FloatVectorMaxTests::sub); } @Test(dataProvider = "floatBinaryOpProvider") - static void mulFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2125,11 +2125,11 @@ relativeError)); av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, FloatVectorMaxTests::mul); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void mulFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulFloatVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2142,11 +2142,11 @@ relativeError)); av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, FloatMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, FloatVectorMaxTests::mul); } @Test(dataProvider = "floatBinaryOpProvider") - static void divFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2156,11 +2156,11 @@ relativeError)); av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, FloatVectorMaxTests::div); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void divFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divFloatVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2173,11 +2173,11 @@ relativeError)); av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, FloatMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, FloatVectorMaxTests::div); } @Test(dataProvider = "floatBinaryOpProvider") - static void ADDFloatMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDFloatVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2187,11 +2187,11 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, FloatMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, FloatVectorMaxTests::ADD); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void ADDFloatMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDFloatVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -2204,13 +2204,13 @@ relativeError)); av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, FloatMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVectorMaxTests::ADD); } static FloatVector bv_MIN = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MINFloatMaxVectorTestsWithMemOp(IntFunction fa) { + static void MINFloatVectorMaxTestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2221,13 +2221,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, FloatMaxVectorTests::MIN); + assertArraysEquals(r, a, (float)10, FloatVectorMaxTests::MIN); } static FloatVector bv_min = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void minFloatMaxVectorTestsWithMemOp(IntFunction fa) { + static void minFloatVectorMaxTestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2238,13 +2238,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, FloatMaxVectorTests::min); + assertArraysEquals(r, a, (float)10, FloatVectorMaxTests::min); } static FloatVector bv_MIN_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINFloatMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINFloatVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2257,13 +2257,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, FloatMaxVectorTests::MIN); + assertArraysEquals(r, a, (float)10, mask, FloatVectorMaxTests::MIN); } static FloatVector bv_MAX = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void MAXFloatMaxVectorTestsWithMemOp(IntFunction fa) { + static void MAXFloatVectorMaxTestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2274,13 +2274,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, FloatMaxVectorTests::MAX); + assertArraysEquals(r, a, (float)10, FloatVectorMaxTests::MAX); } static FloatVector bv_max = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpProvider") - static void maxFloatMaxVectorTestsWithMemOp(IntFunction fa) { + static void maxFloatVectorMaxTestsWithMemOp(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2291,13 +2291,13 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, FloatMaxVectorTests::max); + assertArraysEquals(r, a, (float)10, FloatVectorMaxTests::max); } static FloatVector bv_MAX_M = FloatVector.broadcast(SPECIES, (float)10); @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXFloatMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXFloatVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2310,7 +2310,7 @@ relativeError)); } } - assertArraysEquals(r, a, (float)10, mask, FloatMaxVectorTests::MAX); + assertArraysEquals(r, a, (float)10, mask, FloatVectorMaxTests::MAX); } static float MIN(float a, float b) { @@ -2318,7 +2318,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MINFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2331,7 +2331,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::MIN); + assertArraysEquals(r, a, b, FloatVectorMaxTests::MIN); } static float min(float a, float b) { @@ -2339,7 +2339,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void minFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2350,7 +2350,7 @@ relativeError)); av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, FloatMaxVectorTests::min); + assertArraysEquals(r, a, b, FloatVectorMaxTests::min); } static float MAX(float a, float b) { @@ -2358,7 +2358,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MAXFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2371,7 +2371,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::MAX); + assertArraysEquals(r, a, b, FloatVectorMaxTests::MAX); } static float max(float a, float b) { @@ -2379,7 +2379,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maxFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2390,11 +2390,11 @@ relativeError)); av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, FloatMaxVectorTests::max); + assertArraysEquals(r, a, b, FloatVectorMaxTests::max); } @Test(dataProvider = "floatBinaryOpProvider") - static void MINFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2404,11 +2404,11 @@ relativeError)); av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, FloatVectorMaxTests::MIN); } @Test(dataProvider = "floatBinaryOpProvider") - static void minFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2418,11 +2418,11 @@ relativeError)); av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::min); + assertBroadcastArraysEquals(r, a, b, FloatVectorMaxTests::min); } @Test(dataProvider = "floatBinaryOpProvider") - static void MAXFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2432,11 +2432,11 @@ relativeError)); av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, FloatVectorMaxTests::MAX); } @Test(dataProvider = "floatBinaryOpProvider") - static void maxFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2446,7 +2446,7 @@ relativeError)); av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::max); + assertBroadcastArraysEquals(r, a, b, FloatVectorMaxTests::max); } static float ADDReduce(float[] a, int idx) { @@ -2468,7 +2468,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceFloatMaxVectorTests(IntFunction fa) { + static void ADDReduceFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2484,7 +2484,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - FloatMaxVectorTests::ADDReduce, FloatMaxVectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVectorMaxTests::ADDReduce, FloatVectorMaxTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2530,7 +2530,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2548,7 +2548,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - FloatMaxVectorTests::ADDReduceMasked, FloatMaxVectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); + FloatVectorMaxTests::ADDReduceMasked, FloatVectorMaxTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD); } static float MULReduce(float[] a, int idx) { @@ -2570,7 +2570,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MULReduceFloatMaxVectorTests(IntFunction fa) { + static void MULReduceFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2586,7 +2586,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - FloatMaxVectorTests::MULReduce, FloatMaxVectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVectorMaxTests::MULReduce, FloatVectorMaxTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2632,7 +2632,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MULReduceFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2650,7 +2650,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - FloatMaxVectorTests::MULReduceMasked, FloatMaxVectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); + FloatVectorMaxTests::MULReduceMasked, FloatVectorMaxTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL); } static float MINReduce(float[] a, int idx) { @@ -2672,7 +2672,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MINReduceFloatMaxVectorTests(IntFunction fa) { + static void MINReduceFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2688,7 +2688,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - FloatMaxVectorTests::MINReduce, FloatMaxVectorTests::MINReduceAll); + FloatVectorMaxTests::MINReduce, FloatVectorMaxTests::MINReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2734,7 +2734,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MINReduceFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2752,7 +2752,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - FloatMaxVectorTests::MINReduceMasked, FloatMaxVectorTests::MINReduceAllMasked); + FloatVectorMaxTests::MINReduceMasked, FloatVectorMaxTests::MINReduceAllMasked); } static float MAXReduce(float[] a, int idx) { @@ -2774,7 +2774,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void MAXReduceFloatMaxVectorTests(IntFunction fa) { + static void MAXReduceFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2790,7 +2790,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - FloatMaxVectorTests::MAXReduce, FloatMaxVectorTests::MAXReduceAll); + FloatVectorMaxTests::MAXReduce, FloatVectorMaxTests::MAXReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2836,7 +2836,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void MAXReduceFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2854,7 +2854,7 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - FloatMaxVectorTests::MAXReduceMasked, FloatMaxVectorTests::MAXReduceAllMasked); + FloatVectorMaxTests::MAXReduceMasked, FloatVectorMaxTests::MAXReduceAllMasked); } static float FIRST_NONZEROReduce(float[] a, int idx) { @@ -2876,7 +2876,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void FIRST_NONZEROReduceFloatMaxVectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); float ra = 0; @@ -2892,7 +2892,7 @@ relativeError)); } assertReductionArraysEquals(r, ra, a, - FloatMaxVectorTests::FIRST_NONZEROReduce, FloatMaxVectorTests::FIRST_NONZEROReduceAll); + FloatVectorMaxTests::FIRST_NONZEROReduce, FloatVectorMaxTests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "floatUnaryOpProvider") @@ -2938,7 +2938,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void FIRST_NONZEROReduceFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -2956,11 +2956,11 @@ relativeError)); } assertReductionArraysEqualsMasked(r, ra, a, mask, - FloatMaxVectorTests::FIRST_NONZEROReduceMasked, FloatMaxVectorTests::FIRST_NONZEROReduceAllMasked); + FloatVectorMaxTests::FIRST_NONZEROReduceMasked, FloatVectorMaxTests::FIRST_NONZEROReduceAllMasked); } @Test(dataProvider = "floatBinaryOpProvider") - static void withFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void withFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -2983,7 +2983,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_DEFAULTFloatMaxVectorTests(IntFunction fa) { + static void IS_DEFAULTFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3000,7 +3000,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_DEFAULTMaskedFloatMaxVectorTests(IntFunction fa, + static void IS_DEFAULTMaskedFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3024,7 +3024,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NEGATIVEFloatMaxVectorTests(IntFunction fa) { + static void IS_NEGATIVEFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3041,7 +3041,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NEGATIVEMaskedFloatMaxVectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3065,7 +3065,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_FINITEFloatMaxVectorTests(IntFunction fa) { + static void IS_FINITEFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3082,7 +3082,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_FINITEMaskedFloatMaxVectorTests(IntFunction fa, + static void IS_FINITEMaskedFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3106,7 +3106,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_NANFloatMaxVectorTests(IntFunction fa) { + static void IS_NANFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3123,7 +3123,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_NANMaskedFloatMaxVectorTests(IntFunction fa, + static void IS_NANMaskedFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3147,7 +3147,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpProvider") - static void IS_INFINITEFloatMaxVectorTests(IntFunction fa) { + static void IS_INFINITEFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -3164,7 +3164,7 @@ relativeError)); } @Test(dataProvider = "floatTestOpMaskProvider") - static void IS_INFINITEMaskedFloatMaxVectorTests(IntFunction fa, + static void IS_INFINITEMaskedFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3184,7 +3184,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LTFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3203,7 +3203,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ltFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3222,7 +3222,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3245,7 +3245,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GTFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GTFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3264,7 +3264,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GTFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3287,7 +3287,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void EQFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3306,7 +3306,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void eqFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3325,7 +3325,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3348,7 +3348,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void NEFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void NEFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3367,7 +3367,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void NEFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3390,7 +3390,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LEFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LEFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3409,7 +3409,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LEFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3432,7 +3432,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void GEFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GEFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3451,7 +3451,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void GEFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3474,7 +3474,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3490,7 +3490,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTFloatVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3510,7 +3510,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void LTFloatMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTFloatVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3526,7 +3526,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void LTFloatMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTFloatVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3546,7 +3546,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3562,7 +3562,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQFloatVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3582,7 +3582,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void EQFloatMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQFloatVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3598,7 +3598,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpMaskProvider") - static void EQFloatMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQFloatVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3622,7 +3622,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloatMaxVectorTests(IntFunction fa, IntFunction fb, + static void blendFloatVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3638,11 +3638,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::blend); + assertArraysEquals(r, a, b, mask, FloatVectorMaxTests::blend); } @Test(dataProvider = "floatUnaryOpShuffleProvider") - static void RearrangeFloatMaxVectorTests(IntFunction fa, + static void RearrangeFloatVectorMaxTests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -3659,7 +3659,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpShuffleMaskProvider") - static void RearrangeFloatMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeFloatVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -3677,7 +3677,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void compressFloatMaxVectorTests(IntFunction fa, + static void compressFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3695,7 +3695,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void expandFloatMaxVectorTests(IntFunction fa, + static void expandFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3713,7 +3713,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void getFloatMaxVectorTests(IntFunction fa) { + static void getFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -3869,7 +3869,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void BroadcastFloatMaxVectorTests(IntFunction fa) { + static void BroadcastFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3883,7 +3883,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ZeroFloatMaxVectorTests(IntFunction fa) { + static void ZeroFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3908,7 +3908,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void sliceUnaryFloatMaxVectorTests(IntFunction fa) { + static void sliceUnaryFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -3919,7 +3919,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, FloatMaxVectorTests::sliceUnary); + assertArraysEquals(r, a, origin, FloatVectorMaxTests::sliceUnary); } static float[] sliceBinary(float[] a, float[] b, int origin, int idx) { @@ -3936,7 +3936,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void sliceBinaryFloatMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryFloatVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -3949,7 +3949,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, FloatMaxVectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, FloatVectorMaxTests::sliceBinary); } static float[] slice(float[] a, float[] b, int origin, boolean[] mask, int idx) { @@ -3966,7 +3966,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void sliceFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -3983,7 +3983,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, mask, FloatMaxVectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, FloatVectorMaxTests::slice); } static float[] unsliceUnary(float[] a, int origin, int idx) { @@ -4000,7 +4000,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void unsliceUnaryFloatMaxVectorTests(IntFunction fa) { + static void unsliceUnaryFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -4011,7 +4011,7 @@ relativeError)); } } - assertArraysEquals(r, a, origin, FloatMaxVectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, FloatVectorMaxTests::unsliceUnary); } static float[] unsliceBinary(float[] a, float[] b, int origin, int part, int idx) { @@ -4037,7 +4037,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void unsliceBinaryFloatMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryFloatVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -4051,7 +4051,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, FloatMaxVectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, FloatVectorMaxTests::unsliceBinary); } static float[] unslice(float[] a, float[] b, int origin, int part, boolean[] mask, int idx) { @@ -4091,7 +4091,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void unsliceFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4108,7 +4108,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, origin, part, mask, FloatMaxVectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, FloatVectorMaxTests::unslice); } static float SIN(float a) { @@ -4120,7 +4120,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINFloatMaxVectorTests(IntFunction fa) { + static void SINFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4131,7 +4131,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::SIN, FloatMaxVectorTests::strictSIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::SIN, FloatVectorMaxTests::strictSIN); } static float EXP(float a) { @@ -4143,7 +4143,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPFloatMaxVectorTests(IntFunction fa) { + static void EXPFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4154,7 +4154,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::EXP, FloatMaxVectorTests::strictEXP); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::EXP, FloatVectorMaxTests::strictEXP); } static float LOG1P(float a) { @@ -4166,7 +4166,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG1PFloatMaxVectorTests(IntFunction fa) { + static void LOG1PFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4177,7 +4177,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::LOG1P, FloatMaxVectorTests::strictLOG1P); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::LOG1P, FloatVectorMaxTests::strictLOG1P); } static float LOG(float a) { @@ -4189,7 +4189,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOGFloatMaxVectorTests(IntFunction fa) { + static void LOGFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4200,7 +4200,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::LOG, FloatMaxVectorTests::strictLOG); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::LOG, FloatVectorMaxTests::strictLOG); } static float LOG10(float a) { @@ -4212,7 +4212,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void LOG10FloatMaxVectorTests(IntFunction fa) { + static void LOG10FloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4223,7 +4223,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::LOG10, FloatMaxVectorTests::strictLOG10); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::LOG10, FloatVectorMaxTests::strictLOG10); } static float EXPM1(float a) { @@ -4235,7 +4235,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void EXPM1FloatMaxVectorTests(IntFunction fa) { + static void EXPM1FloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4246,7 +4246,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::EXPM1, FloatMaxVectorTests::strictEXPM1); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::EXPM1, FloatVectorMaxTests::strictEXPM1); } static float COS(float a) { @@ -4258,7 +4258,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSFloatMaxVectorTests(IntFunction fa) { + static void COSFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4269,7 +4269,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::COS, FloatMaxVectorTests::strictCOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::COS, FloatVectorMaxTests::strictCOS); } static float TAN(float a) { @@ -4281,7 +4281,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANFloatMaxVectorTests(IntFunction fa) { + static void TANFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4292,7 +4292,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::TAN, FloatMaxVectorTests::strictTAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::TAN, FloatVectorMaxTests::strictTAN); } static float SINH(float a) { @@ -4304,7 +4304,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SINHFloatMaxVectorTests(IntFunction fa) { + static void SINHFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4315,7 +4315,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::SINH, FloatMaxVectorTests::strictSINH); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::SINH, FloatVectorMaxTests::strictSINH); } static float COSH(float a) { @@ -4327,7 +4327,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void COSHFloatMaxVectorTests(IntFunction fa) { + static void COSHFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4338,7 +4338,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::COSH, FloatMaxVectorTests::strictCOSH); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::COSH, FloatVectorMaxTests::strictCOSH); } static float TANH(float a) { @@ -4350,7 +4350,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void TANHFloatMaxVectorTests(IntFunction fa) { + static void TANHFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4361,7 +4361,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::TANH, FloatMaxVectorTests::strictTANH); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::TANH, FloatVectorMaxTests::strictTANH); } static float ASIN(float a) { @@ -4373,7 +4373,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ASINFloatMaxVectorTests(IntFunction fa) { + static void ASINFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4384,7 +4384,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::ASIN, FloatMaxVectorTests::strictASIN); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::ASIN, FloatVectorMaxTests::strictASIN); } static float ACOS(float a) { @@ -4396,7 +4396,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ACOSFloatMaxVectorTests(IntFunction fa) { + static void ACOSFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4407,7 +4407,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::ACOS, FloatMaxVectorTests::strictACOS); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::ACOS, FloatVectorMaxTests::strictACOS); } static float ATAN(float a) { @@ -4419,7 +4419,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ATANFloatMaxVectorTests(IntFunction fa) { + static void ATANFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4430,7 +4430,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::ATAN, FloatMaxVectorTests::strictATAN); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::ATAN, FloatVectorMaxTests::strictATAN); } static float CBRT(float a) { @@ -4442,7 +4442,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void CBRTFloatMaxVectorTests(IntFunction fa) { + static void CBRTFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4453,7 +4453,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::CBRT, FloatMaxVectorTests::strictCBRT); + assertArraysEqualsWithinOneUlp(r, a, FloatVectorMaxTests::CBRT, FloatVectorMaxTests::strictCBRT); } static float HYPOT(float a, float b) { @@ -4465,7 +4465,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void HYPOTFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void HYPOTFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4478,7 +4478,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::HYPOT, FloatMaxVectorTests::strictHYPOT); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVectorMaxTests::HYPOT, FloatVectorMaxTests::strictHYPOT); } @@ -4491,7 +4491,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void POWFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4504,7 +4504,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::POW, FloatMaxVectorTests::strictPOW); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVectorMaxTests::POW, FloatVectorMaxTests::strictPOW); } @@ -4517,7 +4517,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void powFloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4530,7 +4530,7 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::pow, FloatMaxVectorTests::strictpow); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVectorMaxTests::pow, FloatVectorMaxTests::strictpow); } @@ -4543,7 +4543,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpProvider") - static void ATAN2FloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ATAN2FloatVectorMaxTests(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4556,12 +4556,12 @@ relativeError)); } } - assertArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::ATAN2, FloatMaxVectorTests::strictATAN2); + assertArraysEqualsWithinOneUlp(r, a, b, FloatVectorMaxTests::ATAN2, FloatVectorMaxTests::strictATAN2); } @Test(dataProvider = "floatBinaryOpProvider") - static void POWFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void POWFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4571,12 +4571,12 @@ relativeError)); av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::POW, FloatMaxVectorTests::strictPOW); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVectorMaxTests::POW, FloatVectorMaxTests::strictPOW); } @Test(dataProvider = "floatBinaryOpProvider") - static void powFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void powFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4586,7 +4586,7 @@ relativeError)); av.pow(b[i]).intoArray(r, i); } - assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::pow, FloatMaxVectorTests::strictpow); + assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatVectorMaxTests::pow, FloatVectorMaxTests::strictpow); } @@ -4599,7 +4599,7 @@ relativeError)); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloatMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4614,11 +4614,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, FloatMaxVectorTests::FMA); + assertArraysEquals(r, a, b, c, FloatVectorMaxTests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloatMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4631,11 +4631,11 @@ relativeError)); av.fma(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, FloatMaxVectorTests::fma); + assertArraysEquals(r, a, b, c, FloatVectorMaxTests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void FMAFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4653,11 +4653,11 @@ relativeError)); } } - assertArraysEquals(r, a, b, c, mask, FloatMaxVectorTests::FMA); + assertArraysEquals(r, a, b, c, mask, FloatVectorMaxTests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4668,11 +4668,11 @@ relativeError)); FloatVector bv = FloatVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, FloatMaxVectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, FloatVectorMaxTests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloatMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4683,11 +4683,11 @@ relativeError)); FloatVector cv = FloatVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, FloatMaxVectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, FloatVectorMaxTests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4702,11 +4702,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, FloatMaxVectorTests::FMA); + assertBroadcastArraysEquals(r, a, b, c, mask, FloatVectorMaxTests::FMA); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloatMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVectorMaxTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4721,11 +4721,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, FloatMaxVectorTests::FMA); + assertAltBroadcastArraysEquals(r, a, b, c, mask, FloatVectorMaxTests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void FMAFloatMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void FMAFloatVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4736,11 +4736,11 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, FloatMaxVectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVectorMaxTests::FMA); } @Test(dataProvider = "floatTernaryOpProvider") - static void fmaFloatMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void fmaFloatVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] c = fc.apply(SPECIES.length()); @@ -4751,11 +4751,11 @@ relativeError)); av.fma(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, FloatMaxVectorTests::fma); + assertDoubleBroadcastArraysEquals(r, a, b, c, FloatVectorMaxTests::fma); } @Test(dataProvider = "floatTernaryOpMaskProvider") - static void FMAFloatMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void FMAFloatVectorMaxTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -4769,7 +4769,7 @@ relativeError)); av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FloatMaxVectorTests::FMA); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FloatVectorMaxTests::FMA); } static float NEG(float a) { @@ -4781,7 +4781,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void NEGFloatMaxVectorTests(IntFunction fa) { + static void NEGFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4792,11 +4792,11 @@ relativeError)); } } - assertArraysEquals(r, a, FloatMaxVectorTests::NEG); + assertArraysEquals(r, a, FloatVectorMaxTests::NEG); } @Test(dataProvider = "floatUnaryOpProvider") - static void negFloatMaxVectorTests(IntFunction fa) { + static void negFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4807,11 +4807,11 @@ relativeError)); } } - assertArraysEquals(r, a, FloatMaxVectorTests::neg); + assertArraysEquals(r, a, FloatVectorMaxTests::neg); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void NEGMaskedFloatMaxVectorTests(IntFunction fa, + static void NEGMaskedFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4825,7 +4825,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, FloatMaxVectorTests::NEG); + assertArraysEquals(r, a, mask, FloatVectorMaxTests::NEG); } static float ABS(float a) { @@ -4837,7 +4837,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ABSFloatMaxVectorTests(IntFunction fa) { + static void ABSFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4848,11 +4848,11 @@ relativeError)); } } - assertArraysEquals(r, a, FloatMaxVectorTests::ABS); + assertArraysEquals(r, a, FloatVectorMaxTests::ABS); } @Test(dataProvider = "floatUnaryOpProvider") - static void absFloatMaxVectorTests(IntFunction fa) { + static void absFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4863,11 +4863,11 @@ relativeError)); } } - assertArraysEquals(r, a, FloatMaxVectorTests::abs); + assertArraysEquals(r, a, FloatVectorMaxTests::abs); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ABSMaskedFloatMaxVectorTests(IntFunction fa, + static void ABSMaskedFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4881,7 +4881,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, FloatMaxVectorTests::ABS); + assertArraysEquals(r, a, mask, FloatVectorMaxTests::ABS); } static float SQRT(float a) { @@ -4893,7 +4893,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void SQRTFloatMaxVectorTests(IntFunction fa) { + static void SQRTFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4904,11 +4904,11 @@ relativeError)); } } - assertArraysEquals(r, a, FloatMaxVectorTests::SQRT); + assertArraysEquals(r, a, FloatVectorMaxTests::SQRT); } @Test(dataProvider = "floatUnaryOpProvider") - static void sqrtFloatMaxVectorTests(IntFunction fa) { + static void sqrtFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4919,11 +4919,11 @@ relativeError)); } } - assertArraysEquals(r, a, FloatMaxVectorTests::sqrt); + assertArraysEquals(r, a, FloatVectorMaxTests::sqrt); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void SQRTMaskedFloatMaxVectorTests(IntFunction fa, + static void SQRTMaskedFloatVectorMaxTests(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] r = fr.apply(SPECIES.length()); @@ -4937,7 +4937,7 @@ relativeError)); } } - assertArraysEquals(r, a, mask, FloatMaxVectorTests::SQRT); + assertArraysEquals(r, a, mask, FloatVectorMaxTests::SQRT); } static boolean band(boolean a, boolean b) { @@ -4945,7 +4945,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandFloatVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4958,7 +4958,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::band); + assertArraysEquals(r, a, b, FloatVectorMaxTests::band); } static boolean bor(boolean a, boolean b) { @@ -4966,7 +4966,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskorFloatVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -4979,7 +4979,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::bor); + assertArraysEquals(r, a, b, FloatVectorMaxTests::bor); } static boolean bxor(boolean a, boolean b) { @@ -4987,7 +4987,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskxorFloatVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5000,7 +5000,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::bxor); + assertArraysEquals(r, a, b, FloatVectorMaxTests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -5008,7 +5008,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotFloatVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5021,7 +5021,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::bandNot); + assertArraysEquals(r, a, b, FloatVectorMaxTests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -5029,7 +5029,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskeqFloatVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5042,7 +5042,7 @@ relativeError)); } } - assertArraysEquals(r, a, b, FloatMaxVectorTests::beq); + assertArraysEquals(r, a, b, FloatVectorMaxTests::beq); } static boolean unot(boolean a) { @@ -5050,7 +5050,7 @@ relativeError)); } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotFloatMaxVectorTests(IntFunction fa) { + static void masknotFloatVectorMaxTests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -5061,7 +5061,7 @@ relativeError)); } } - assertArraysEquals(r, a, FloatMaxVectorTests::unot); + assertArraysEquals(r, a, FloatVectorMaxTests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -5078,7 +5078,7 @@ relativeError)); } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongFloatMaxVectorTests(IntFunction fa) { + static void maskFromToLongFloatVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5092,7 +5092,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void ltFloatMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltFloatVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5108,7 +5108,7 @@ relativeError)); } @Test(dataProvider = "floatCompareOpProvider") - static void eqFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqFloatVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5124,7 +5124,7 @@ relativeError)); } @Test(dataProvider = "floattoIntUnaryOpProvider") - static void toIntArrayFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayFloatVectorMaxTestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5135,7 +5135,7 @@ relativeError)); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void toLongArrayFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayFloatVectorMaxTestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5146,7 +5146,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toDoubleArrayFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayFloatVectorMaxTestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5157,7 +5157,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void toStringFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void toStringFloatVectorMaxTestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5170,7 +5170,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void hashCodeFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void hashCodeFloatVectorMaxTestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5203,7 +5203,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpProvider") - static void ADDReduceLongFloatMaxVectorTests(IntFunction fa) { + static void ADDReduceLongFloatVectorMaxTests(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -5219,7 +5219,7 @@ relativeError)); } assertReductionLongArraysEquals(r, ra, a, - FloatMaxVectorTests::ADDReduceLong, FloatMaxVectorTests::ADDReduceAllLong); + FloatVectorMaxTests::ADDReduceLong, FloatVectorMaxTests::ADDReduceAllLong); } static long ADDReduceLongMasked(float[] a, int idx, boolean[] mask) { @@ -5242,7 +5242,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpMaskProvider") - static void ADDReduceLongFloatMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongFloatVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5260,11 +5260,11 @@ relativeError)); } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - FloatMaxVectorTests::ADDReduceLongMasked, FloatMaxVectorTests::ADDReduceAllLongMasked); + FloatVectorMaxTests::ADDReduceLongMasked, FloatVectorMaxTests::ADDReduceAllLongMasked); } @Test(dataProvider = "floattoLongUnaryOpProvider") - static void BroadcastLongFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongFloatVectorMaxTestsSmokeTest(IntFunction fa) { float[] a = fa.apply(SPECIES.length()); float[] r = new float[a.length]; @@ -5275,7 +5275,7 @@ relativeError)); } @Test(dataProvider = "floatBinaryOpMaskProvider") - static void blendFloatMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendFloatVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); @@ -5289,12 +5289,12 @@ relativeError)); av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, FloatMaxVectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, FloatVectorMaxTests::blend); } @Test(dataProvider = "floatUnaryOpSelectFromProvider") - static void SelectFromFloatMaxVectorTests(IntFunction fa, + static void SelectFromFloatVectorMaxTests(IntFunction fa, BiFunction fs) { float[] a = fa.apply(SPECIES.length()); float[] order = fs.apply(a.length, SPECIES.length()); @@ -5310,7 +5310,7 @@ relativeError)); } @Test(dataProvider = "floatSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorFloatMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorFloatVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { float[] a = fa.apply(SPECIES.length()); float[] b = fb.apply(SPECIES.length()); float[] idx = fc.apply(SPECIES.length()); @@ -5328,7 +5328,7 @@ relativeError)); } @Test(dataProvider = "floatUnaryOpSelectFromMaskProvider") - static void SelectFromFloatMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromFloatVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { float[] a = fa.apply(SPECIES.length()); @@ -5347,7 +5347,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousFloatMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousFloatVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5363,7 +5363,7 @@ relativeError)); } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringFloatMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringFloatVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5377,7 +5377,7 @@ relativeError)); } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsFloatMaxVectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsFloatVectorMaxTestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -5391,7 +5391,7 @@ relativeError)); } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsFloatMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsFloatVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -5407,7 +5407,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskHashCodeFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeFloatVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -5429,7 +5429,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskTrueCountFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountFloatVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5440,7 +5440,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, FloatMaxVectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, FloatVectorMaxTests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -5454,7 +5454,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskLastTrueFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueFloatVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5465,7 +5465,7 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, FloatMaxVectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, FloatVectorMaxTests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -5479,7 +5479,7 @@ relativeError)); } @Test(dataProvider = "maskProvider") - static void maskFirstTrueFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueFloatVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5490,11 +5490,11 @@ relativeError)); } } - assertMaskReductionArraysEquals(r, a, FloatMaxVectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, FloatVectorMaxTests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressFloatMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskCompressFloatVectorMaxTestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -5522,7 +5522,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeFloatMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeFloatVectorMaxTestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5536,7 +5536,7 @@ relativeError)); } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongFloatMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeLongFloatVectorMaxTestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -5563,14 +5563,14 @@ relativeError)); } @Test(dataProvider = "lengthProvider") - static void loopBoundFloatMaxVectorTestsSmokeTest(int length) { + static void loopBoundFloatVectorMaxTestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongFloatMaxVectorTestsSmokeTest(int _length) { + static void loopBoundLongFloatVectorMaxTestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -5578,21 +5578,21 @@ relativeError)); } @Test - static void ElementSizeFloatMaxVectorTestsSmokeTest() { + static void ElementSizeFloatVectorMaxTestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Float.SIZE); } @Test - static void VectorShapeFloatMaxVectorTestsSmokeTest() { + static void VectorShapeFloatVectorMaxTestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_Max_BIT)); } @Test - static void ShapeWithLanesFloatMaxVectorTestsSmokeTest() { + static void ShapeWithLanesFloatVectorMaxTestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(float.class); @@ -5600,32 +5600,32 @@ relativeError)); } @Test - static void ElementTypeFloatMaxVectorTestsSmokeTest() { + static void ElementTypeFloatVectorMaxTestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementType() == float.class); } @Test - static void SpeciesElementSizeFloatMaxVectorTestsSmokeTest() { + static void SpeciesElementSizeFloatVectorMaxTestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().elementSize() == Float.SIZE); } @Test - static void VectorTypeFloatMaxVectorTestsSmokeTest() { + static void VectorTypeFloatVectorMaxTestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesFloatMaxVectorTestsSmokeTest() { + static void WithLanesFloatVectorMaxTestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(float.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeFloatMaxVectorTestsSmokeTest() { + static void WithShapeFloatVectorMaxTestsSmokeTest() { FloatVector av = FloatVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -5633,7 +5633,7 @@ relativeError)); } @Test - static void MaskAllTrueFloatMaxVectorTestsSmokeTest() { + static void MaskAllTrueFloatVectorMaxTestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Int128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/IntVector128LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Int128VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/IntVector128LoadStoreTests.java index f6e640e9615..dd865141e08 100644 --- a/test/jdk/jdk/incubator/vector/Int128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/IntVector128LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Int128VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation IntVector128LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Int128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class IntVector128LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = IntVector.SPECIES_128; diff --git a/test/jdk/jdk/incubator/vector/Int128VectorTests.java b/test/jdk/jdk/incubator/vector/IntVector128Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Int128VectorTests.java rename to test/jdk/jdk/incubator/vector/IntVector128Tests.java index 1f254abbf0c..ecdb23eb40d 100644 --- a/test/jdk/jdk/incubator/vector/Int128VectorTests.java +++ b/test/jdk/jdk/incubator/vector/IntVector128Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Int128VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation IntVector128Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Int128VectorTests extends AbstractVectorTest { +public class IntVector128Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = IntVector.SPECIES_128; @@ -1667,7 +1667,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ADDInt128VectorTests(IntFunction fa, IntFunction fb) { + static void ADDIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1680,7 +1680,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::ADD); + assertArraysEquals(r, a, b, IntVector128Tests::ADD); } static int add(int a, int b) { @@ -1688,7 +1688,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void addInt128VectorTests(IntFunction fa, IntFunction fb) { + static void addIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1699,11 +1699,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int128VectorTests::add); + assertArraysEquals(r, a, b, IntVector128Tests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1719,11 +1719,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::ADD); + assertArraysEquals(r, a, b, mask, IntVector128Tests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1737,7 +1737,7 @@ public class Int128VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int128VectorTests::add); + assertArraysEquals(r, a, b, mask, IntVector128Tests::add); } static int SUB(int a, int b) { @@ -1745,7 +1745,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void SUBInt128VectorTests(IntFunction fa, IntFunction fb) { + static void SUBIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1758,7 +1758,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::SUB); + assertArraysEquals(r, a, b, IntVector128Tests::SUB); } static int sub(int a, int b) { @@ -1766,7 +1766,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void subInt128VectorTests(IntFunction fa, IntFunction fb) { + static void subIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1777,11 +1777,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int128VectorTests::sub); + assertArraysEquals(r, a, b, IntVector128Tests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void SUBInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1797,11 +1797,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::SUB); + assertArraysEquals(r, a, b, mask, IntVector128Tests::SUB); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1815,7 +1815,7 @@ public class Int128VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int128VectorTests::sub); + assertArraysEquals(r, a, b, mask, IntVector128Tests::sub); } static int MUL(int a, int b) { @@ -1823,7 +1823,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MULInt128VectorTests(IntFunction fa, IntFunction fb) { + static void MULIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1836,7 +1836,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::MUL); + assertArraysEquals(r, a, b, IntVector128Tests::MUL); } static int mul(int a, int b) { @@ -1844,7 +1844,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void mulInt128VectorTests(IntFunction fa, IntFunction fb) { + static void mulIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1855,11 +1855,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int128VectorTests::mul); + assertArraysEquals(r, a, b, IntVector128Tests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void MULInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1875,11 +1875,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::MUL); + assertArraysEquals(r, a, b, mask, IntVector128Tests::MUL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1893,7 +1893,7 @@ public class Int128VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int128VectorTests::mul); + assertArraysEquals(r, a, b, mask, IntVector128Tests::mul); } static int DIV(int a, int b) { @@ -1901,7 +1901,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void DIVInt128VectorTests(IntFunction fa, IntFunction fb) { + static void DIVIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1916,7 +1916,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::DIV); + assertArraysEquals(r, a, b, IntVector128Tests::DIV); } static int div(int a, int b) { @@ -1924,7 +1924,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void divInt128VectorTests(IntFunction fa, IntFunction fb) { + static void divIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1939,11 +1939,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::div); + assertArraysEquals(r, a, b, IntVector128Tests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void DIVInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1961,11 +1961,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::DIV); + assertArraysEquals(r, a, b, mask, IntVector128Tests::DIV); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1983,7 +1983,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::div); + assertArraysEquals(r, a, b, mask, IntVector128Tests::div); } static int FIRST_NONZERO(int a, int b) { @@ -1991,7 +1991,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void FIRST_NONZEROInt128VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2004,11 +2004,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, IntVector128Tests::FIRST_NONZERO); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void FIRST_NONZEROInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2024,7 +2024,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, IntVector128Tests::FIRST_NONZERO); } static int AND(int a, int b) { @@ -2032,7 +2032,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ANDInt128VectorTests(IntFunction fa, IntFunction fb) { + static void ANDIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2045,7 +2045,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::AND); + assertArraysEquals(r, a, b, IntVector128Tests::AND); } static int and(int a, int b) { @@ -2053,7 +2053,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void andInt128VectorTests(IntFunction fa, IntFunction fb) { + static void andIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2064,11 +2064,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int128VectorTests::and); + assertArraysEquals(r, a, b, IntVector128Tests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2084,7 +2084,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::AND); + assertArraysEquals(r, a, b, mask, IntVector128Tests::AND); } static int AND_NOT(int a, int b) { @@ -2092,7 +2092,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void AND_NOTInt128VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2105,11 +2105,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::AND_NOT); + assertArraysEquals(r, a, b, IntVector128Tests::AND_NOT); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void AND_NOTInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2125,7 +2125,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, IntVector128Tests::AND_NOT); } static int OR(int a, int b) { @@ -2133,7 +2133,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt128VectorTests(IntFunction fa, IntFunction fb) { + static void ORIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2146,7 +2146,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::OR); + assertArraysEquals(r, a, b, IntVector128Tests::OR); } static int or(int a, int b) { @@ -2154,7 +2154,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void orInt128VectorTests(IntFunction fa, IntFunction fb) { + static void orIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2165,11 +2165,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int128VectorTests::or); + assertArraysEquals(r, a, b, IntVector128Tests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2185,7 +2185,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::OR); + assertArraysEquals(r, a, b, mask, IntVector128Tests::OR); } static int XOR(int a, int b) { @@ -2193,7 +2193,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void XORInt128VectorTests(IntFunction fa, IntFunction fb) { + static void XORIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2206,11 +2206,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::XOR); + assertArraysEquals(r, a, b, IntVector128Tests::XOR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void XORInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2226,7 +2226,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::XOR); + assertArraysEquals(r, a, b, mask, IntVector128Tests::XOR); } static int COMPRESS_BITS(int a, int b) { @@ -2234,7 +2234,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void COMPRESS_BITSInt128VectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2247,11 +2247,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, IntVector128Tests::COMPRESS_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void COMPRESS_BITSInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2267,7 +2267,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, IntVector128Tests::COMPRESS_BITS); } static int EXPAND_BITS(int a, int b) { @@ -2275,7 +2275,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void EXPAND_BITSInt128VectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2288,11 +2288,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, IntVector128Tests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void EXPAND_BITSInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2308,11 +2308,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, IntVector128Tests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpProvider") - static void addInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2322,11 +2322,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2339,11 +2339,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, IntVector128Tests::add); } @Test(dataProvider = "intBinaryOpProvider") - static void subInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2353,11 +2353,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2370,11 +2370,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, IntVector128Tests::sub); } @Test(dataProvider = "intBinaryOpProvider") - static void mulInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2384,11 +2384,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2401,11 +2401,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, IntVector128Tests::mul); } @Test(dataProvider = "intBinaryOpProvider") - static void divInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2436,11 +2436,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, IntVector128Tests::div); } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2450,11 +2450,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void orInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2464,11 +2464,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::or); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2481,11 +2481,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, IntVector128Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ANDInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2495,11 +2495,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void andInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2509,11 +2509,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::and); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2526,11 +2526,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, IntVector128Tests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2540,11 +2540,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Int128VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, IntVector128Tests::OR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2557,11 +2557,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector128Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ADDInt128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDIntVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2571,11 +2571,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Int128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, IntVector128Tests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDInt128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDIntVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2588,7 +2588,7 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector128Tests::ADD); } static int LSHL(int a, int b) { @@ -2596,7 +2596,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLInt128VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2609,11 +2609,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::LSHL); + assertArraysEquals(r, a, b, IntVector128Tests::LSHL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2629,7 +2629,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, IntVector128Tests::LSHL); } static int ASHR(int a, int b) { @@ -2637,7 +2637,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRInt128VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2650,11 +2650,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::ASHR); + assertArraysEquals(r, a, b, IntVector128Tests::ASHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2670,7 +2670,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, IntVector128Tests::ASHR); } static int LSHR(int a, int b) { @@ -2678,7 +2678,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRInt128VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2691,11 +2691,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::LSHR); + assertArraysEquals(r, a, b, IntVector128Tests::LSHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2711,7 +2711,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, IntVector128Tests::LSHR); } static int LSHL_unary(int a, int b) { @@ -2719,7 +2719,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLInt128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLIntVector128TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2731,11 +2731,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int128VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, IntVector128Tests::LSHL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLInt128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2750,7 +2750,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector128Tests::LSHL_unary); } static int LSHR_unary(int a, int b) { @@ -2758,7 +2758,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRInt128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRIntVector128TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2770,11 +2770,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int128VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, IntVector128Tests::LSHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRInt128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2789,7 +2789,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector128Tests::LSHR_unary); } static int ASHR_unary(int a, int b) { @@ -2797,7 +2797,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRInt128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRIntVector128TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2809,11 +2809,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int128VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, IntVector128Tests::ASHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRInt128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2828,7 +2828,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector128Tests::ASHR_unary); } static int ROR(int a, int b) { @@ -2836,7 +2836,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORInt128VectorTests(IntFunction fa, IntFunction fb) { + static void RORIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2849,11 +2849,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::ROR); + assertArraysEquals(r, a, b, IntVector128Tests::ROR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2869,7 +2869,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::ROR); + assertArraysEquals(r, a, b, mask, IntVector128Tests::ROR); } static int ROL(int a, int b) { @@ -2877,7 +2877,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLInt128VectorTests(IntFunction fa, IntFunction fb) { + static void ROLIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2890,11 +2890,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::ROL); + assertArraysEquals(r, a, b, IntVector128Tests::ROL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2910,7 +2910,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::ROL); + assertArraysEquals(r, a, b, mask, IntVector128Tests::ROL); } static int ROR_unary(int a, int b) { @@ -2918,7 +2918,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORInt128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORIntVector128TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2930,11 +2930,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int128VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, IntVector128Tests::ROR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORInt128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORIntVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2949,7 +2949,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector128Tests::ROR_unary); } static int ROL_unary(int a, int b) { @@ -2957,7 +2957,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLInt128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLIntVector128TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2969,11 +2969,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int128VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, IntVector128Tests::ROL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLInt128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLIntVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2988,14 +2988,14 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector128Tests::ROL_unary); } static int LSHR_binary_const(int a) { return (int)((a >>> CONST_SHIFT)); } @Test(dataProvider = "intUnaryOpProvider") - static void LSHRInt128VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRIntVector128TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3006,11 +3006,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int128VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, IntVector128Tests::LSHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHRInt128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRIntVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3024,7 +3024,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int128VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector128Tests::LSHR_binary_const); } static int LSHL_binary_const(int a) { @@ -3032,7 +3032,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LSHLInt128VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLIntVector128TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3043,11 +3043,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int128VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, IntVector128Tests::LSHL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHLInt128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLIntVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3061,7 +3061,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int128VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, IntVector128Tests::LSHL_binary_const); } static int ASHR_binary_const(int a) { @@ -3069,7 +3069,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ASHRInt128VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRIntVector128TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3080,11 +3080,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int128VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, IntVector128Tests::ASHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ASHRInt128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRIntVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3098,7 +3098,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int128VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector128Tests::ASHR_binary_const); } static int ROR_binary_const(int a) { @@ -3106,7 +3106,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void RORInt128VectorTestsScalarShiftConst(IntFunction fa) { + static void RORIntVector128TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3117,11 +3117,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int128VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, IntVector128Tests::ROR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void RORInt128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORIntVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3135,7 +3135,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int128VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector128Tests::ROR_binary_const); } static int ROL_binary_const(int a) { @@ -3143,7 +3143,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ROLInt128VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLIntVector128TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3154,11 +3154,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int128VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, IntVector128Tests::ROL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ROLInt128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLIntVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3172,14 +3172,14 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int128VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, IntVector128Tests::ROL_binary_const); } static IntVector bv_MIN = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MINInt128VectorTestsWithMemOp(IntFunction fa) { + static void MINIntVector128TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3190,13 +3190,13 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int128VectorTests::MIN); + assertArraysEquals(r, a, (int)10, IntVector128Tests::MIN); } static IntVector bv_min = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void minInt128VectorTestsWithMemOp(IntFunction fa) { + static void minIntVector128TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3207,13 +3207,13 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int128VectorTests::min); + assertArraysEquals(r, a, (int)10, IntVector128Tests::min); } static IntVector bv_MIN_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINInt128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINIntVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3226,13 +3226,13 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, Int128VectorTests::MIN); + assertArraysEquals(r, a, (int)10, mask, IntVector128Tests::MIN); } static IntVector bv_MAX = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MAXInt128VectorTestsWithMemOp(IntFunction fa) { + static void MAXIntVector128TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3243,13 +3243,13 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int128VectorTests::MAX); + assertArraysEquals(r, a, (int)10, IntVector128Tests::MAX); } static IntVector bv_max = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void maxInt128VectorTestsWithMemOp(IntFunction fa) { + static void maxIntVector128TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3260,13 +3260,13 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int128VectorTests::max); + assertArraysEquals(r, a, (int)10, IntVector128Tests::max); } static IntVector bv_MAX_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXInt128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXIntVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3279,7 +3279,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, Int128VectorTests::MAX); + assertArraysEquals(r, a, (int)10, mask, IntVector128Tests::MAX); } static int MIN(int a, int b) { @@ -3287,7 +3287,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MINInt128VectorTests(IntFunction fa, IntFunction fb) { + static void MINIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3300,7 +3300,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::MIN); + assertArraysEquals(r, a, b, IntVector128Tests::MIN); } static int min(int a, int b) { @@ -3308,7 +3308,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void minInt128VectorTests(IntFunction fa, IntFunction fb) { + static void minIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3319,7 +3319,7 @@ public class Int128VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int128VectorTests::min); + assertArraysEquals(r, a, b, IntVector128Tests::min); } static int MAX(int a, int b) { @@ -3327,7 +3327,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MAXInt128VectorTests(IntFunction fa, IntFunction fb) { + static void MAXIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3340,7 +3340,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::MAX); + assertArraysEquals(r, a, b, IntVector128Tests::MAX); } static int max(int a, int b) { @@ -3348,7 +3348,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void maxInt128VectorTests(IntFunction fa, IntFunction fb) { + static void maxIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3359,7 +3359,7 @@ public class Int128VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int128VectorTests::max); + assertArraysEquals(r, a, b, IntVector128Tests::max); } static int UMIN(int a, int b) { @@ -3367,7 +3367,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMINInt128VectorTests(IntFunction fa, IntFunction fb) { + static void UMINIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3380,11 +3380,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::UMIN); + assertArraysEquals(r, a, b, IntVector128Tests::UMIN); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMINInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3400,7 +3400,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, IntVector128Tests::UMIN); } static int UMAX(int a, int b) { @@ -3408,7 +3408,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMAXInt128VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3421,11 +3421,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::UMAX); + assertArraysEquals(r, a, b, IntVector128Tests::UMAX); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMAXInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3441,7 +3441,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, IntVector128Tests::UMAX); } static int SADD(int a, int b) { @@ -3449,7 +3449,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SADDInt128VectorTests(IntFunction fa, IntFunction fb) { + static void SADDIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3462,11 +3462,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::SADD); + assertArraysEquals(r, a, b, IntVector128Tests::SADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SADDInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3482,7 +3482,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::SADD); + assertArraysEquals(r, a, b, mask, IntVector128Tests::SADD); } static int SSUB(int a, int b) { @@ -3490,7 +3490,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SSUBInt128VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3503,11 +3503,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::SSUB); + assertArraysEquals(r, a, b, IntVector128Tests::SSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SSUBInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3523,7 +3523,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, IntVector128Tests::SSUB); } static int SUADD(int a, int b) { @@ -3531,7 +3531,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUADDInt128VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3544,11 +3544,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::SUADD); + assertArraysEquals(r, a, b, IntVector128Tests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUADDInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3564,7 +3564,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, IntVector128Tests::SUADD); } static int SUSUB(int a, int b) { @@ -3572,7 +3572,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUSUBInt128VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3585,11 +3585,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::SUSUB); + assertArraysEquals(r, a, b, IntVector128Tests::SUSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUSUBInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3605,11 +3605,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, IntVector128Tests::SUSUB); } @Test(dataProvider = "intBinaryOpProvider") - static void MINInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3619,11 +3619,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::MIN); } @Test(dataProvider = "intBinaryOpProvider") - static void minInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3633,11 +3633,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::min); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::min); } @Test(dataProvider = "intBinaryOpProvider") - static void MAXInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3647,11 +3647,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::MAX); } @Test(dataProvider = "intBinaryOpProvider") - static void maxInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3661,10 +3661,10 @@ public class Int128VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int128VectorTests::max); + assertBroadcastArraysEquals(r, a, b, IntVector128Tests::max); } @Test(dataProvider = "intSaturatingBinaryOpAssocProvider") - static void SUADDAssocInt128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocIntVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -3681,11 +3681,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Int128VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, IntVector128Tests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3706,7 +3706,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Int128VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, IntVector128Tests::SUADD); } static int ANDReduce(int[] a, int idx) { @@ -3728,7 +3728,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ANDReduceInt128VectorTests(IntFunction fa) { + static void ANDReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3744,7 +3744,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::ANDReduce, Int128VectorTests::ANDReduceAll); + IntVector128Tests::ANDReduce, IntVector128Tests::ANDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3790,7 +3790,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ANDReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3808,7 +3808,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::ANDReduceMasked, Int128VectorTests::ANDReduceAllMasked); + IntVector128Tests::ANDReduceMasked, IntVector128Tests::ANDReduceAllMasked); } static int ORReduce(int[] a, int idx) { @@ -3830,7 +3830,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ORReduceInt128VectorTests(IntFunction fa) { + static void ORReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3846,7 +3846,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::ORReduce, Int128VectorTests::ORReduceAll); + IntVector128Tests::ORReduce, IntVector128Tests::ORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3892,7 +3892,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ORReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3910,7 +3910,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::ORReduceMasked, Int128VectorTests::ORReduceAllMasked); + IntVector128Tests::ORReduceMasked, IntVector128Tests::ORReduceAllMasked); } static int XORReduce(int[] a, int idx) { @@ -3932,7 +3932,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void XORReduceInt128VectorTests(IntFunction fa) { + static void XORReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3948,7 +3948,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::XORReduce, Int128VectorTests::XORReduceAll); + IntVector128Tests::XORReduce, IntVector128Tests::XORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3994,7 +3994,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void XORReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4012,7 +4012,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::XORReduceMasked, Int128VectorTests::XORReduceAllMasked); + IntVector128Tests::XORReduceMasked, IntVector128Tests::XORReduceAllMasked); } static int ADDReduce(int[] a, int idx) { @@ -4034,7 +4034,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceInt128VectorTests(IntFunction fa) { + static void ADDReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4050,7 +4050,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::ADDReduce, Int128VectorTests::ADDReduceAll); + IntVector128Tests::ADDReduce, IntVector128Tests::ADDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4096,7 +4096,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4114,7 +4114,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::ADDReduceMasked, Int128VectorTests::ADDReduceAllMasked); + IntVector128Tests::ADDReduceMasked, IntVector128Tests::ADDReduceAllMasked); } static int MULReduce(int[] a, int idx) { @@ -4136,7 +4136,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MULReduceInt128VectorTests(IntFunction fa) { + static void MULReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4152,7 +4152,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::MULReduce, Int128VectorTests::MULReduceAll); + IntVector128Tests::MULReduce, IntVector128Tests::MULReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4198,7 +4198,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MULReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4216,7 +4216,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::MULReduceMasked, Int128VectorTests::MULReduceAllMasked); + IntVector128Tests::MULReduceMasked, IntVector128Tests::MULReduceAllMasked); } static int MINReduce(int[] a, int idx) { @@ -4238,7 +4238,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MINReduceInt128VectorTests(IntFunction fa) { + static void MINReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4254,7 +4254,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::MINReduce, Int128VectorTests::MINReduceAll); + IntVector128Tests::MINReduce, IntVector128Tests::MINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4300,7 +4300,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4318,7 +4318,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::MINReduceMasked, Int128VectorTests::MINReduceAllMasked); + IntVector128Tests::MINReduceMasked, IntVector128Tests::MINReduceAllMasked); } static int MAXReduce(int[] a, int idx) { @@ -4340,7 +4340,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MAXReduceInt128VectorTests(IntFunction fa) { + static void MAXReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4356,7 +4356,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::MAXReduce, Int128VectorTests::MAXReduceAll); + IntVector128Tests::MAXReduce, IntVector128Tests::MAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4402,7 +4402,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4420,7 +4420,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::MAXReduceMasked, Int128VectorTests::MAXReduceAllMasked); + IntVector128Tests::MAXReduceMasked, IntVector128Tests::MAXReduceAllMasked); } static int UMINReduce(int[] a, int idx) { @@ -4442,7 +4442,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMINReduceInt128VectorTests(IntFunction fa) { + static void UMINReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4458,7 +4458,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::UMINReduce, Int128VectorTests::UMINReduceAll); + IntVector128Tests::UMINReduce, IntVector128Tests::UMINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4504,7 +4504,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMINReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4522,7 +4522,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::UMINReduceMasked, Int128VectorTests::UMINReduceAllMasked); + IntVector128Tests::UMINReduceMasked, IntVector128Tests::UMINReduceAllMasked); } static int UMAXReduce(int[] a, int idx) { @@ -4544,7 +4544,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMAXReduceInt128VectorTests(IntFunction fa) { + static void UMAXReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4560,7 +4560,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::UMAXReduce, Int128VectorTests::UMAXReduceAll); + IntVector128Tests::UMAXReduce, IntVector128Tests::UMAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4606,7 +4606,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMAXReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4624,7 +4624,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::UMAXReduceMasked, Int128VectorTests::UMAXReduceAllMasked); + IntVector128Tests::UMAXReduceMasked, IntVector128Tests::UMAXReduceAllMasked); } static int FIRST_NONZEROReduce(int[] a, int idx) { @@ -4646,7 +4646,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void FIRST_NONZEROReduceInt128VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4662,7 +4662,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::FIRST_NONZEROReduce, Int128VectorTests::FIRST_NONZEROReduceAll); + IntVector128Tests::FIRST_NONZEROReduce, IntVector128Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4708,7 +4708,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void FIRST_NONZEROReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4726,7 +4726,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::FIRST_NONZEROReduceMasked, Int128VectorTests::FIRST_NONZEROReduceAllMasked); + IntVector128Tests::FIRST_NONZEROReduceMasked, IntVector128Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4739,7 +4739,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueInt128VectorTests(IntFunction fm) { + static void anyTrueIntVector128Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4750,7 +4750,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Int128VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, IntVector128Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4763,7 +4763,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueInt128VectorTests(IntFunction fm) { + static void allTrueIntVector128Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4774,7 +4774,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Int128VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, IntVector128Tests::allTrue); } static int SUADDReduce(int[] a, int idx) { @@ -4796,7 +4796,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingUnaryOpProvider") - static void SUADDReduceInt128VectorTests(IntFunction fa) { + static void SUADDReduceIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4812,7 +4812,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int128VectorTests::SUADDReduce, Int128VectorTests::SUADDReduceAll); + IntVector128Tests::SUADDReduce, IntVector128Tests::SUADDReduceAll); } @Test(dataProvider = "intSaturatingUnaryOpProvider") @@ -4857,7 +4857,7 @@ public class Int128VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "intSaturatingUnaryOpMaskProvider") - static void SUADDReduceInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4875,11 +4875,11 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::SUADDReduceMasked, Int128VectorTests::SUADDReduceAllMasked); + IntVector128Tests::SUADDReduceMasked, IntVector128Tests::SUADDReduceAllMasked); } @Test(dataProvider = "intBinaryOpProvider") - static void withInt128VectorTests(IntFunction fa, IntFunction fb) { + static void withIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -4902,7 +4902,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_DEFAULTInt128VectorTests(IntFunction fa) { + static void IS_DEFAULTIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4919,7 +4919,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_DEFAULTMaskedInt128VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4943,7 +4943,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_NEGATIVEInt128VectorTests(IntFunction fa) { + static void IS_NEGATIVEIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4960,7 +4960,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_NEGATIVEMaskedInt128VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4980,7 +4980,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt128VectorTests(IntFunction fa, IntFunction fb) { + static void LTIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -4999,7 +4999,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltInt128VectorTests(IntFunction fa, IntFunction fb) { + static void ltIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5018,7 +5018,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5041,7 +5041,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GTInt128VectorTests(IntFunction fa, IntFunction fb) { + static void GTIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5060,7 +5060,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GTInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5083,7 +5083,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt128VectorTests(IntFunction fa, IntFunction fb) { + static void EQIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5102,7 +5102,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqInt128VectorTests(IntFunction fa, IntFunction fb) { + static void eqIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5121,7 +5121,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5144,7 +5144,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void NEInt128VectorTests(IntFunction fa, IntFunction fb) { + static void NEIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5163,7 +5163,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void NEInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5186,7 +5186,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LEInt128VectorTests(IntFunction fa, IntFunction fb) { + static void LEIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5205,7 +5205,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LEInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5228,7 +5228,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GEInt128VectorTests(IntFunction fa, IntFunction fb) { + static void GEIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5247,7 +5247,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GEInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5270,7 +5270,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULTInt128VectorTests(IntFunction fa, IntFunction fb) { + static void ULTIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5289,7 +5289,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULTInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5312,7 +5312,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGTInt128VectorTests(IntFunction fa, IntFunction fb) { + static void UGTIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5331,7 +5331,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGTInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5354,7 +5354,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULEInt128VectorTests(IntFunction fa, IntFunction fb) { + static void ULEIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5373,7 +5373,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULEInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5396,7 +5396,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGEInt128VectorTests(IntFunction fa, IntFunction fb) { + static void UGEIntVector128Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5415,7 +5415,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGEInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5438,7 +5438,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5454,7 +5454,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5474,7 +5474,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5490,7 +5490,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTIntVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5510,7 +5510,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5526,7 +5526,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5546,7 +5546,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5562,7 +5562,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQIntVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5586,7 +5586,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendInt128VectorTests(IntFunction fa, IntFunction fb, + static void blendIntVector128Tests(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5602,11 +5602,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int128VectorTests::blend); + assertArraysEquals(r, a, b, mask, IntVector128Tests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void RearrangeInt128VectorTests(IntFunction fa, + static void RearrangeIntVector128Tests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5623,7 +5623,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void RearrangeInt128VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeIntVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -5641,7 +5641,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void compressInt128VectorTests(IntFunction fa, + static void compressIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5659,7 +5659,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void expandInt128VectorTests(IntFunction fa, + static void expandIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5677,7 +5677,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void getInt128VectorTests(IntFunction fa) { + static void getIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5833,7 +5833,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastInt128VectorTests(IntFunction fa) { + static void BroadcastIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5847,7 +5847,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZeroInt128VectorTests(IntFunction fa) { + static void ZeroIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5872,7 +5872,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void sliceUnaryInt128VectorTests(IntFunction fa) { + static void sliceUnaryIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5883,7 +5883,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Int128VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, IntVector128Tests::sliceUnary); } static int[] sliceBinary(int[] a, int[] b, int origin, int idx) { @@ -5900,7 +5900,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void sliceBinaryInt128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryIntVector128TestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5913,7 +5913,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Int128VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, IntVector128Tests::sliceBinary); } static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) { @@ -5930,7 +5930,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void sliceInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5947,7 +5947,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Int128VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, IntVector128Tests::slice); } static int[] unsliceUnary(int[] a, int origin, int idx) { @@ -5964,7 +5964,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void unsliceUnaryInt128VectorTests(IntFunction fa) { + static void unsliceUnaryIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5975,7 +5975,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Int128VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, IntVector128Tests::unsliceUnary); } static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) { @@ -6001,7 +6001,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void unsliceBinaryInt128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryIntVector128TestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -6015,7 +6015,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Int128VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, IntVector128Tests::unsliceBinary); } static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) { @@ -6055,7 +6055,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void unsliceInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6072,7 +6072,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Int128VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, IntVector128Tests::unslice); } static int BITWISE_BLEND(int a, int b, int c) { @@ -6084,7 +6084,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6099,11 +6099,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, IntVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6116,11 +6116,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, IntVector128Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6138,11 +6138,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, IntVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6153,11 +6153,11 @@ public class Int128VectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, IntVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6168,11 +6168,11 @@ public class Int128VectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, IntVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6183,11 +6183,11 @@ public class Int128VectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, IntVector128Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class Int128VectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, IntVector128Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6217,11 +6217,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, IntVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt128VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector128TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6236,11 +6236,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, IntVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6251,11 +6251,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6266,11 +6266,11 @@ public class Int128VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVector128Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt128VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector128TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6284,7 +6284,7 @@ public class Int128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, IntVector128Tests::BITWISE_BLEND); } static int NEG(int a) { @@ -6296,7 +6296,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NEGInt128VectorTests(IntFunction fa) { + static void NEGIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6307,11 +6307,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::NEG); + assertArraysEquals(r, a, IntVector128Tests::NEG); } @Test(dataProvider = "intUnaryOpProvider") - static void negInt128VectorTests(IntFunction fa) { + static void negIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6322,11 +6322,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::neg); + assertArraysEquals(r, a, IntVector128Tests::neg); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NEGMaskedInt128VectorTests(IntFunction fa, + static void NEGMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6340,7 +6340,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::NEG); + assertArraysEquals(r, a, mask, IntVector128Tests::NEG); } static int ABS(int a) { @@ -6352,7 +6352,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ABSInt128VectorTests(IntFunction fa) { + static void ABSIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6363,11 +6363,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::ABS); + assertArraysEquals(r, a, IntVector128Tests::ABS); } @Test(dataProvider = "intUnaryOpProvider") - static void absInt128VectorTests(IntFunction fa) { + static void absIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6378,11 +6378,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::abs); + assertArraysEquals(r, a, IntVector128Tests::abs); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ABSMaskedInt128VectorTests(IntFunction fa, + static void ABSMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6396,7 +6396,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::ABS); + assertArraysEquals(r, a, mask, IntVector128Tests::ABS); } static int NOT(int a) { @@ -6408,7 +6408,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NOTInt128VectorTests(IntFunction fa) { + static void NOTIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6419,11 +6419,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::NOT); + assertArraysEquals(r, a, IntVector128Tests::NOT); } @Test(dataProvider = "intUnaryOpProvider") - static void notInt128VectorTests(IntFunction fa) { + static void notIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6434,11 +6434,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::not); + assertArraysEquals(r, a, IntVector128Tests::not); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NOTMaskedInt128VectorTests(IntFunction fa, + static void NOTMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6452,7 +6452,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::NOT); + assertArraysEquals(r, a, mask, IntVector128Tests::NOT); } static int ZOMO(int a) { @@ -6460,7 +6460,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZOMOInt128VectorTests(IntFunction fa) { + static void ZOMOIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6471,11 +6471,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::ZOMO); + assertArraysEquals(r, a, IntVector128Tests::ZOMO); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ZOMOMaskedInt128VectorTests(IntFunction fa, + static void ZOMOMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6489,7 +6489,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::ZOMO); + assertArraysEquals(r, a, mask, IntVector128Tests::ZOMO); } static int BIT_COUNT(int a) { @@ -6497,7 +6497,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BIT_COUNTInt128VectorTests(IntFunction fa) { + static void BIT_COUNTIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6508,11 +6508,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::BIT_COUNT); + assertArraysEquals(r, a, IntVector128Tests::BIT_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void BIT_COUNTMaskedInt128VectorTests(IntFunction fa, + static void BIT_COUNTMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6526,7 +6526,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, IntVector128Tests::BIT_COUNT); } static int TRAILING_ZEROS_COUNT(int a) { @@ -6534,7 +6534,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void TRAILING_ZEROS_COUNTInt128VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6545,11 +6545,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVector128Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedInt128VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6563,7 +6563,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVector128Tests::TRAILING_ZEROS_COUNT); } static int LEADING_ZEROS_COUNT(int a) { @@ -6571,7 +6571,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LEADING_ZEROS_COUNTInt128VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6582,11 +6582,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVector128Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedInt128VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6600,7 +6600,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVector128Tests::LEADING_ZEROS_COUNT); } static int REVERSE(int a) { @@ -6608,7 +6608,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSEInt128VectorTests(IntFunction fa) { + static void REVERSEIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6619,11 +6619,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::REVERSE); + assertArraysEquals(r, a, IntVector128Tests::REVERSE); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSEMaskedInt128VectorTests(IntFunction fa, + static void REVERSEMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6637,7 +6637,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::REVERSE); + assertArraysEquals(r, a, mask, IntVector128Tests::REVERSE); } static int REVERSE_BYTES(int a) { @@ -6645,7 +6645,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSE_BYTESInt128VectorTests(IntFunction fa) { + static void REVERSE_BYTESIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6656,11 +6656,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, IntVector128Tests::REVERSE_BYTES); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedInt128VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedIntVector128Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6674,7 +6674,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int128VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, IntVector128Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6682,7 +6682,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandInt128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandIntVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6695,7 +6695,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::band); + assertArraysEquals(r, a, b, IntVector128Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6703,7 +6703,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorInt128VectorTests(IntFunction fa, IntFunction fb) { + static void maskorIntVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6716,7 +6716,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::bor); + assertArraysEquals(r, a, b, IntVector128Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6724,7 +6724,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorInt128VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorIntVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6737,7 +6737,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::bxor); + assertArraysEquals(r, a, b, IntVector128Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6745,7 +6745,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotInt128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotIntVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6758,7 +6758,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::bandNot); + assertArraysEquals(r, a, b, IntVector128Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6766,7 +6766,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqInt128VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqIntVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6779,7 +6779,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int128VectorTests::beq); + assertArraysEquals(r, a, b, IntVector128Tests::beq); } static boolean unot(boolean a) { @@ -6787,7 +6787,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotInt128VectorTests(IntFunction fa) { + static void masknotIntVector128Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6798,7 +6798,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int128VectorTests::unot); + assertArraysEquals(r, a, IntVector128Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6815,7 +6815,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongInt128VectorTests(IntFunction fa) { + static void maskFromToLongIntVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6829,7 +6829,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltInt128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltIntVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6845,7 +6845,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqIntVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6861,7 +6861,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toIntArrayInt128VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayIntVector128TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6872,7 +6872,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toLongArrayInt128VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayIntVector128TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6883,7 +6883,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toDoubleArrayInt128VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayIntVector128TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6894,7 +6894,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toStringInt128VectorTestsSmokeTest(IntFunction fa) { + static void toStringIntVector128TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6907,7 +6907,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void hashCodeInt128VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeIntVector128TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6940,7 +6940,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceLongInt128VectorTests(IntFunction fa) { + static void ADDReduceLongIntVector128Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6956,7 +6956,7 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Int128VectorTests::ADDReduceLong, Int128VectorTests::ADDReduceAllLong); + IntVector128Tests::ADDReduceLong, IntVector128Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) { @@ -6979,7 +6979,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceLongInt128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongIntVector128TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6997,11 +6997,11 @@ public class Int128VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Int128VectorTests::ADDReduceLongMasked, Int128VectorTests::ADDReduceAllLongMasked); + IntVector128Tests::ADDReduceLongMasked, IntVector128Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastLongInt128VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongIntVector128TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7012,7 +7012,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendInt128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendIntVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -7026,12 +7026,12 @@ public class Int128VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector128Tests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void SelectFromInt128VectorTests(IntFunction fa, + static void SelectFromIntVector128Tests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -7047,7 +7047,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorInt128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorIntVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] idx = fc.apply(SPECIES.length()); @@ -7065,7 +7065,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void SelectFromInt128VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromIntVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -7084,7 +7084,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousInt128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousIntVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7100,7 +7100,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringInt128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringIntVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7114,7 +7114,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsInt128VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsIntVector128TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7128,7 +7128,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsInt128VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsIntVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7144,7 +7144,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeInt128VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeIntVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7166,7 +7166,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountInt128VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountIntVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7177,7 +7177,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int128VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, IntVector128Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7191,7 +7191,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueInt128VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueIntVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7202,7 +7202,7 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int128VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, IntVector128Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7216,7 +7216,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueInt128VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueIntVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7227,11 +7227,11 @@ public class Int128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int128VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, IntVector128Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressInt128VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressIntVector128TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7259,7 +7259,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeInt128VectorTestsSmokeTest(int offset) { + static void indexInRangeIntVector128TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7273,7 +7273,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongInt128VectorTestsSmokeTest(int offset) { + static void indexInRangeLongIntVector128TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7300,14 +7300,14 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundInt128VectorTestsSmokeTest(int length) { + static void loopBoundIntVector128TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongInt128VectorTestsSmokeTest(int _length) { + static void loopBoundLongIntVector128TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7315,21 +7315,21 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeInt128VectorTestsSmokeTest() { + static void ElementSizeIntVector128TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Integer.SIZE); } @Test - static void VectorShapeInt128VectorTestsSmokeTest() { + static void VectorShapeIntVector128TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_128_BIT)); } @Test - static void ShapeWithLanesInt128VectorTestsSmokeTest() { + static void ShapeWithLanesIntVector128TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(int.class); @@ -7337,32 +7337,32 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeInt128VectorTestsSmokeTest() { + static void ElementTypeIntVector128TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementType() == int.class); } @Test - static void SpeciesElementSizeInt128VectorTestsSmokeTest() { + static void SpeciesElementSizeIntVector128TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementSize() == Integer.SIZE); } @Test - static void VectorTypeInt128VectorTestsSmokeTest() { + static void VectorTypeIntVector128TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesInt128VectorTestsSmokeTest() { + static void WithLanesIntVector128TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(int.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeInt128VectorTestsSmokeTest() { + static void WithShapeIntVector128TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7370,7 +7370,7 @@ public class Int128VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueInt128VectorTestsSmokeTest() { + static void MaskAllTrueIntVector128TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Int256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/IntVector256LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Int256VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/IntVector256LoadStoreTests.java index 333757be0f8..ea98a287ded 100644 --- a/test/jdk/jdk/incubator/vector/Int256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/IntVector256LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Int256VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation IntVector256LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Int256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class IntVector256LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = IntVector.SPECIES_256; diff --git a/test/jdk/jdk/incubator/vector/Int256VectorTests.java b/test/jdk/jdk/incubator/vector/IntVector256Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Int256VectorTests.java rename to test/jdk/jdk/incubator/vector/IntVector256Tests.java index f9f0faad32b..7100ebd1693 100644 --- a/test/jdk/jdk/incubator/vector/Int256VectorTests.java +++ b/test/jdk/jdk/incubator/vector/IntVector256Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Int256VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation IntVector256Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Int256VectorTests extends AbstractVectorTest { +public class IntVector256Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = IntVector.SPECIES_256; @@ -1667,7 +1667,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ADDInt256VectorTests(IntFunction fa, IntFunction fb) { + static void ADDIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1680,7 +1680,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::ADD); + assertArraysEquals(r, a, b, IntVector256Tests::ADD); } static int add(int a, int b) { @@ -1688,7 +1688,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void addInt256VectorTests(IntFunction fa, IntFunction fb) { + static void addIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1699,11 +1699,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int256VectorTests::add); + assertArraysEquals(r, a, b, IntVector256Tests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1719,11 +1719,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::ADD); + assertArraysEquals(r, a, b, mask, IntVector256Tests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1737,7 +1737,7 @@ public class Int256VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int256VectorTests::add); + assertArraysEquals(r, a, b, mask, IntVector256Tests::add); } static int SUB(int a, int b) { @@ -1745,7 +1745,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void SUBInt256VectorTests(IntFunction fa, IntFunction fb) { + static void SUBIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1758,7 +1758,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::SUB); + assertArraysEquals(r, a, b, IntVector256Tests::SUB); } static int sub(int a, int b) { @@ -1766,7 +1766,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void subInt256VectorTests(IntFunction fa, IntFunction fb) { + static void subIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1777,11 +1777,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int256VectorTests::sub); + assertArraysEquals(r, a, b, IntVector256Tests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void SUBInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1797,11 +1797,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::SUB); + assertArraysEquals(r, a, b, mask, IntVector256Tests::SUB); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1815,7 +1815,7 @@ public class Int256VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int256VectorTests::sub); + assertArraysEquals(r, a, b, mask, IntVector256Tests::sub); } static int MUL(int a, int b) { @@ -1823,7 +1823,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MULInt256VectorTests(IntFunction fa, IntFunction fb) { + static void MULIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1836,7 +1836,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::MUL); + assertArraysEquals(r, a, b, IntVector256Tests::MUL); } static int mul(int a, int b) { @@ -1844,7 +1844,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void mulInt256VectorTests(IntFunction fa, IntFunction fb) { + static void mulIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1855,11 +1855,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int256VectorTests::mul); + assertArraysEquals(r, a, b, IntVector256Tests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void MULInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1875,11 +1875,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::MUL); + assertArraysEquals(r, a, b, mask, IntVector256Tests::MUL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1893,7 +1893,7 @@ public class Int256VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int256VectorTests::mul); + assertArraysEquals(r, a, b, mask, IntVector256Tests::mul); } static int DIV(int a, int b) { @@ -1901,7 +1901,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void DIVInt256VectorTests(IntFunction fa, IntFunction fb) { + static void DIVIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1916,7 +1916,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::DIV); + assertArraysEquals(r, a, b, IntVector256Tests::DIV); } static int div(int a, int b) { @@ -1924,7 +1924,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void divInt256VectorTests(IntFunction fa, IntFunction fb) { + static void divIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1939,11 +1939,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::div); + assertArraysEquals(r, a, b, IntVector256Tests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void DIVInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1961,11 +1961,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::DIV); + assertArraysEquals(r, a, b, mask, IntVector256Tests::DIV); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1983,7 +1983,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::div); + assertArraysEquals(r, a, b, mask, IntVector256Tests::div); } static int FIRST_NONZERO(int a, int b) { @@ -1991,7 +1991,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void FIRST_NONZEROInt256VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2004,11 +2004,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, IntVector256Tests::FIRST_NONZERO); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void FIRST_NONZEROInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2024,7 +2024,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, IntVector256Tests::FIRST_NONZERO); } static int AND(int a, int b) { @@ -2032,7 +2032,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ANDInt256VectorTests(IntFunction fa, IntFunction fb) { + static void ANDIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2045,7 +2045,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::AND); + assertArraysEquals(r, a, b, IntVector256Tests::AND); } static int and(int a, int b) { @@ -2053,7 +2053,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void andInt256VectorTests(IntFunction fa, IntFunction fb) { + static void andIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2064,11 +2064,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int256VectorTests::and); + assertArraysEquals(r, a, b, IntVector256Tests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2084,7 +2084,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::AND); + assertArraysEquals(r, a, b, mask, IntVector256Tests::AND); } static int AND_NOT(int a, int b) { @@ -2092,7 +2092,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void AND_NOTInt256VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2105,11 +2105,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::AND_NOT); + assertArraysEquals(r, a, b, IntVector256Tests::AND_NOT); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void AND_NOTInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2125,7 +2125,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, IntVector256Tests::AND_NOT); } static int OR(int a, int b) { @@ -2133,7 +2133,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt256VectorTests(IntFunction fa, IntFunction fb) { + static void ORIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2146,7 +2146,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::OR); + assertArraysEquals(r, a, b, IntVector256Tests::OR); } static int or(int a, int b) { @@ -2154,7 +2154,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void orInt256VectorTests(IntFunction fa, IntFunction fb) { + static void orIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2165,11 +2165,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int256VectorTests::or); + assertArraysEquals(r, a, b, IntVector256Tests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2185,7 +2185,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::OR); + assertArraysEquals(r, a, b, mask, IntVector256Tests::OR); } static int XOR(int a, int b) { @@ -2193,7 +2193,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void XORInt256VectorTests(IntFunction fa, IntFunction fb) { + static void XORIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2206,11 +2206,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::XOR); + assertArraysEquals(r, a, b, IntVector256Tests::XOR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void XORInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2226,7 +2226,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::XOR); + assertArraysEquals(r, a, b, mask, IntVector256Tests::XOR); } static int COMPRESS_BITS(int a, int b) { @@ -2234,7 +2234,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void COMPRESS_BITSInt256VectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2247,11 +2247,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, IntVector256Tests::COMPRESS_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void COMPRESS_BITSInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2267,7 +2267,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, IntVector256Tests::COMPRESS_BITS); } static int EXPAND_BITS(int a, int b) { @@ -2275,7 +2275,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void EXPAND_BITSInt256VectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2288,11 +2288,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, IntVector256Tests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void EXPAND_BITSInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2308,11 +2308,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, IntVector256Tests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpProvider") - static void addInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2322,11 +2322,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2339,11 +2339,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, IntVector256Tests::add); } @Test(dataProvider = "intBinaryOpProvider") - static void subInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2353,11 +2353,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2370,11 +2370,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, IntVector256Tests::sub); } @Test(dataProvider = "intBinaryOpProvider") - static void mulInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2384,11 +2384,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2401,11 +2401,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, IntVector256Tests::mul); } @Test(dataProvider = "intBinaryOpProvider") - static void divInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2436,11 +2436,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, IntVector256Tests::div); } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2450,11 +2450,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void orInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2464,11 +2464,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::or); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2481,11 +2481,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, IntVector256Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ANDInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2495,11 +2495,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void andInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2509,11 +2509,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::and); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2526,11 +2526,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int256VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, IntVector256Tests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2540,11 +2540,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Int256VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, IntVector256Tests::OR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2557,11 +2557,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Int256VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector256Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ADDInt256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDIntVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2571,11 +2571,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Int256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, IntVector256Tests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDInt256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDIntVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2588,7 +2588,7 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Int256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector256Tests::ADD); } static int LSHL(int a, int b) { @@ -2596,7 +2596,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLInt256VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2609,11 +2609,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::LSHL); + assertArraysEquals(r, a, b, IntVector256Tests::LSHL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2629,7 +2629,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, IntVector256Tests::LSHL); } static int ASHR(int a, int b) { @@ -2637,7 +2637,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRInt256VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2650,11 +2650,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::ASHR); + assertArraysEquals(r, a, b, IntVector256Tests::ASHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2670,7 +2670,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, IntVector256Tests::ASHR); } static int LSHR(int a, int b) { @@ -2678,7 +2678,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRInt256VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2691,11 +2691,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::LSHR); + assertArraysEquals(r, a, b, IntVector256Tests::LSHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2711,7 +2711,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, IntVector256Tests::LSHR); } static int LSHL_unary(int a, int b) { @@ -2719,7 +2719,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLInt256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLIntVector256TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2731,11 +2731,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int256VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, IntVector256Tests::LSHL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLInt256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2750,7 +2750,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector256Tests::LSHL_unary); } static int LSHR_unary(int a, int b) { @@ -2758,7 +2758,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRInt256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRIntVector256TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2770,11 +2770,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int256VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, IntVector256Tests::LSHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRInt256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2789,7 +2789,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector256Tests::LSHR_unary); } static int ASHR_unary(int a, int b) { @@ -2797,7 +2797,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRInt256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRIntVector256TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2809,11 +2809,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int256VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, IntVector256Tests::ASHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRInt256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2828,7 +2828,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector256Tests::ASHR_unary); } static int ROR(int a, int b) { @@ -2836,7 +2836,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORInt256VectorTests(IntFunction fa, IntFunction fb) { + static void RORIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2849,11 +2849,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::ROR); + assertArraysEquals(r, a, b, IntVector256Tests::ROR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2869,7 +2869,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::ROR); + assertArraysEquals(r, a, b, mask, IntVector256Tests::ROR); } static int ROL(int a, int b) { @@ -2877,7 +2877,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLInt256VectorTests(IntFunction fa, IntFunction fb) { + static void ROLIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2890,11 +2890,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::ROL); + assertArraysEquals(r, a, b, IntVector256Tests::ROL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2910,7 +2910,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::ROL); + assertArraysEquals(r, a, b, mask, IntVector256Tests::ROL); } static int ROR_unary(int a, int b) { @@ -2918,7 +2918,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORInt256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORIntVector256TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2930,11 +2930,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int256VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, IntVector256Tests::ROR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORInt256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORIntVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2949,7 +2949,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector256Tests::ROR_unary); } static int ROL_unary(int a, int b) { @@ -2957,7 +2957,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLInt256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLIntVector256TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2969,11 +2969,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int256VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, IntVector256Tests::ROL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLInt256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLIntVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2988,14 +2988,14 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int256VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector256Tests::ROL_unary); } static int LSHR_binary_const(int a) { return (int)((a >>> CONST_SHIFT)); } @Test(dataProvider = "intUnaryOpProvider") - static void LSHRInt256VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRIntVector256TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3006,11 +3006,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int256VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, IntVector256Tests::LSHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHRInt256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRIntVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3024,7 +3024,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int256VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector256Tests::LSHR_binary_const); } static int LSHL_binary_const(int a) { @@ -3032,7 +3032,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LSHLInt256VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLIntVector256TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3043,11 +3043,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int256VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, IntVector256Tests::LSHL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHLInt256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLIntVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3061,7 +3061,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int256VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, IntVector256Tests::LSHL_binary_const); } static int ASHR_binary_const(int a) { @@ -3069,7 +3069,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ASHRInt256VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRIntVector256TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3080,11 +3080,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int256VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, IntVector256Tests::ASHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ASHRInt256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRIntVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3098,7 +3098,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int256VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector256Tests::ASHR_binary_const); } static int ROR_binary_const(int a) { @@ -3106,7 +3106,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void RORInt256VectorTestsScalarShiftConst(IntFunction fa) { + static void RORIntVector256TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3117,11 +3117,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int256VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, IntVector256Tests::ROR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void RORInt256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORIntVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3135,7 +3135,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int256VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector256Tests::ROR_binary_const); } static int ROL_binary_const(int a) { @@ -3143,7 +3143,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ROLInt256VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLIntVector256TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3154,11 +3154,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int256VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, IntVector256Tests::ROL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ROLInt256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLIntVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3172,14 +3172,14 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int256VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, IntVector256Tests::ROL_binary_const); } static IntVector bv_MIN = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MINInt256VectorTestsWithMemOp(IntFunction fa) { + static void MINIntVector256TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3190,13 +3190,13 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int256VectorTests::MIN); + assertArraysEquals(r, a, (int)10, IntVector256Tests::MIN); } static IntVector bv_min = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void minInt256VectorTestsWithMemOp(IntFunction fa) { + static void minIntVector256TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3207,13 +3207,13 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int256VectorTests::min); + assertArraysEquals(r, a, (int)10, IntVector256Tests::min); } static IntVector bv_MIN_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINInt256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINIntVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3226,13 +3226,13 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, Int256VectorTests::MIN); + assertArraysEquals(r, a, (int)10, mask, IntVector256Tests::MIN); } static IntVector bv_MAX = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MAXInt256VectorTestsWithMemOp(IntFunction fa) { + static void MAXIntVector256TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3243,13 +3243,13 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int256VectorTests::MAX); + assertArraysEquals(r, a, (int)10, IntVector256Tests::MAX); } static IntVector bv_max = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void maxInt256VectorTestsWithMemOp(IntFunction fa) { + static void maxIntVector256TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3260,13 +3260,13 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int256VectorTests::max); + assertArraysEquals(r, a, (int)10, IntVector256Tests::max); } static IntVector bv_MAX_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXInt256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXIntVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3279,7 +3279,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, Int256VectorTests::MAX); + assertArraysEquals(r, a, (int)10, mask, IntVector256Tests::MAX); } static int MIN(int a, int b) { @@ -3287,7 +3287,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MINInt256VectorTests(IntFunction fa, IntFunction fb) { + static void MINIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3300,7 +3300,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::MIN); + assertArraysEquals(r, a, b, IntVector256Tests::MIN); } static int min(int a, int b) { @@ -3308,7 +3308,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void minInt256VectorTests(IntFunction fa, IntFunction fb) { + static void minIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3319,7 +3319,7 @@ public class Int256VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int256VectorTests::min); + assertArraysEquals(r, a, b, IntVector256Tests::min); } static int MAX(int a, int b) { @@ -3327,7 +3327,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MAXInt256VectorTests(IntFunction fa, IntFunction fb) { + static void MAXIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3340,7 +3340,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::MAX); + assertArraysEquals(r, a, b, IntVector256Tests::MAX); } static int max(int a, int b) { @@ -3348,7 +3348,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void maxInt256VectorTests(IntFunction fa, IntFunction fb) { + static void maxIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3359,7 +3359,7 @@ public class Int256VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int256VectorTests::max); + assertArraysEquals(r, a, b, IntVector256Tests::max); } static int UMIN(int a, int b) { @@ -3367,7 +3367,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMINInt256VectorTests(IntFunction fa, IntFunction fb) { + static void UMINIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3380,11 +3380,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::UMIN); + assertArraysEquals(r, a, b, IntVector256Tests::UMIN); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMINInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3400,7 +3400,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, IntVector256Tests::UMIN); } static int UMAX(int a, int b) { @@ -3408,7 +3408,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMAXInt256VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3421,11 +3421,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::UMAX); + assertArraysEquals(r, a, b, IntVector256Tests::UMAX); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMAXInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3441,7 +3441,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, IntVector256Tests::UMAX); } static int SADD(int a, int b) { @@ -3449,7 +3449,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SADDInt256VectorTests(IntFunction fa, IntFunction fb) { + static void SADDIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3462,11 +3462,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::SADD); + assertArraysEquals(r, a, b, IntVector256Tests::SADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SADDInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3482,7 +3482,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::SADD); + assertArraysEquals(r, a, b, mask, IntVector256Tests::SADD); } static int SSUB(int a, int b) { @@ -3490,7 +3490,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SSUBInt256VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3503,11 +3503,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::SSUB); + assertArraysEquals(r, a, b, IntVector256Tests::SSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SSUBInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3523,7 +3523,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, IntVector256Tests::SSUB); } static int SUADD(int a, int b) { @@ -3531,7 +3531,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUADDInt256VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3544,11 +3544,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::SUADD); + assertArraysEquals(r, a, b, IntVector256Tests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUADDInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3564,7 +3564,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, IntVector256Tests::SUADD); } static int SUSUB(int a, int b) { @@ -3572,7 +3572,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUSUBInt256VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3585,11 +3585,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::SUSUB); + assertArraysEquals(r, a, b, IntVector256Tests::SUSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUSUBInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3605,11 +3605,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, IntVector256Tests::SUSUB); } @Test(dataProvider = "intBinaryOpProvider") - static void MINInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3619,11 +3619,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::MIN); } @Test(dataProvider = "intBinaryOpProvider") - static void minInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3633,11 +3633,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::min); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::min); } @Test(dataProvider = "intBinaryOpProvider") - static void MAXInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3647,11 +3647,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::MAX); } @Test(dataProvider = "intBinaryOpProvider") - static void maxInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3661,10 +3661,10 @@ public class Int256VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int256VectorTests::max); + assertBroadcastArraysEquals(r, a, b, IntVector256Tests::max); } @Test(dataProvider = "intSaturatingBinaryOpAssocProvider") - static void SUADDAssocInt256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocIntVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -3681,11 +3681,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Int256VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, IntVector256Tests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3706,7 +3706,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Int256VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, IntVector256Tests::SUADD); } static int ANDReduce(int[] a, int idx) { @@ -3728,7 +3728,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ANDReduceInt256VectorTests(IntFunction fa) { + static void ANDReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3744,7 +3744,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::ANDReduce, Int256VectorTests::ANDReduceAll); + IntVector256Tests::ANDReduce, IntVector256Tests::ANDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3790,7 +3790,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ANDReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3808,7 +3808,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::ANDReduceMasked, Int256VectorTests::ANDReduceAllMasked); + IntVector256Tests::ANDReduceMasked, IntVector256Tests::ANDReduceAllMasked); } static int ORReduce(int[] a, int idx) { @@ -3830,7 +3830,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ORReduceInt256VectorTests(IntFunction fa) { + static void ORReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3846,7 +3846,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::ORReduce, Int256VectorTests::ORReduceAll); + IntVector256Tests::ORReduce, IntVector256Tests::ORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3892,7 +3892,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ORReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3910,7 +3910,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::ORReduceMasked, Int256VectorTests::ORReduceAllMasked); + IntVector256Tests::ORReduceMasked, IntVector256Tests::ORReduceAllMasked); } static int XORReduce(int[] a, int idx) { @@ -3932,7 +3932,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void XORReduceInt256VectorTests(IntFunction fa) { + static void XORReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3948,7 +3948,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::XORReduce, Int256VectorTests::XORReduceAll); + IntVector256Tests::XORReduce, IntVector256Tests::XORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3994,7 +3994,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void XORReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4012,7 +4012,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::XORReduceMasked, Int256VectorTests::XORReduceAllMasked); + IntVector256Tests::XORReduceMasked, IntVector256Tests::XORReduceAllMasked); } static int ADDReduce(int[] a, int idx) { @@ -4034,7 +4034,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceInt256VectorTests(IntFunction fa) { + static void ADDReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4050,7 +4050,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::ADDReduce, Int256VectorTests::ADDReduceAll); + IntVector256Tests::ADDReduce, IntVector256Tests::ADDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4096,7 +4096,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4114,7 +4114,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::ADDReduceMasked, Int256VectorTests::ADDReduceAllMasked); + IntVector256Tests::ADDReduceMasked, IntVector256Tests::ADDReduceAllMasked); } static int MULReduce(int[] a, int idx) { @@ -4136,7 +4136,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MULReduceInt256VectorTests(IntFunction fa) { + static void MULReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4152,7 +4152,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::MULReduce, Int256VectorTests::MULReduceAll); + IntVector256Tests::MULReduce, IntVector256Tests::MULReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4198,7 +4198,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MULReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4216,7 +4216,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::MULReduceMasked, Int256VectorTests::MULReduceAllMasked); + IntVector256Tests::MULReduceMasked, IntVector256Tests::MULReduceAllMasked); } static int MINReduce(int[] a, int idx) { @@ -4238,7 +4238,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MINReduceInt256VectorTests(IntFunction fa) { + static void MINReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4254,7 +4254,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::MINReduce, Int256VectorTests::MINReduceAll); + IntVector256Tests::MINReduce, IntVector256Tests::MINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4300,7 +4300,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4318,7 +4318,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::MINReduceMasked, Int256VectorTests::MINReduceAllMasked); + IntVector256Tests::MINReduceMasked, IntVector256Tests::MINReduceAllMasked); } static int MAXReduce(int[] a, int idx) { @@ -4340,7 +4340,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MAXReduceInt256VectorTests(IntFunction fa) { + static void MAXReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4356,7 +4356,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::MAXReduce, Int256VectorTests::MAXReduceAll); + IntVector256Tests::MAXReduce, IntVector256Tests::MAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4402,7 +4402,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4420,7 +4420,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::MAXReduceMasked, Int256VectorTests::MAXReduceAllMasked); + IntVector256Tests::MAXReduceMasked, IntVector256Tests::MAXReduceAllMasked); } static int UMINReduce(int[] a, int idx) { @@ -4442,7 +4442,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMINReduceInt256VectorTests(IntFunction fa) { + static void UMINReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4458,7 +4458,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::UMINReduce, Int256VectorTests::UMINReduceAll); + IntVector256Tests::UMINReduce, IntVector256Tests::UMINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4504,7 +4504,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMINReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4522,7 +4522,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::UMINReduceMasked, Int256VectorTests::UMINReduceAllMasked); + IntVector256Tests::UMINReduceMasked, IntVector256Tests::UMINReduceAllMasked); } static int UMAXReduce(int[] a, int idx) { @@ -4544,7 +4544,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMAXReduceInt256VectorTests(IntFunction fa) { + static void UMAXReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4560,7 +4560,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::UMAXReduce, Int256VectorTests::UMAXReduceAll); + IntVector256Tests::UMAXReduce, IntVector256Tests::UMAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4606,7 +4606,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMAXReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4624,7 +4624,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::UMAXReduceMasked, Int256VectorTests::UMAXReduceAllMasked); + IntVector256Tests::UMAXReduceMasked, IntVector256Tests::UMAXReduceAllMasked); } static int FIRST_NONZEROReduce(int[] a, int idx) { @@ -4646,7 +4646,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void FIRST_NONZEROReduceInt256VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4662,7 +4662,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::FIRST_NONZEROReduce, Int256VectorTests::FIRST_NONZEROReduceAll); + IntVector256Tests::FIRST_NONZEROReduce, IntVector256Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4708,7 +4708,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void FIRST_NONZEROReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4726,7 +4726,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::FIRST_NONZEROReduceMasked, Int256VectorTests::FIRST_NONZEROReduceAllMasked); + IntVector256Tests::FIRST_NONZEROReduceMasked, IntVector256Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4739,7 +4739,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueInt256VectorTests(IntFunction fm) { + static void anyTrueIntVector256Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4750,7 +4750,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Int256VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, IntVector256Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4763,7 +4763,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueInt256VectorTests(IntFunction fm) { + static void allTrueIntVector256Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4774,7 +4774,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Int256VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, IntVector256Tests::allTrue); } static int SUADDReduce(int[] a, int idx) { @@ -4796,7 +4796,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingUnaryOpProvider") - static void SUADDReduceInt256VectorTests(IntFunction fa) { + static void SUADDReduceIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4812,7 +4812,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int256VectorTests::SUADDReduce, Int256VectorTests::SUADDReduceAll); + IntVector256Tests::SUADDReduce, IntVector256Tests::SUADDReduceAll); } @Test(dataProvider = "intSaturatingUnaryOpProvider") @@ -4857,7 +4857,7 @@ public class Int256VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "intSaturatingUnaryOpMaskProvider") - static void SUADDReduceInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4875,11 +4875,11 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::SUADDReduceMasked, Int256VectorTests::SUADDReduceAllMasked); + IntVector256Tests::SUADDReduceMasked, IntVector256Tests::SUADDReduceAllMasked); } @Test(dataProvider = "intBinaryOpProvider") - static void withInt256VectorTests(IntFunction fa, IntFunction fb) { + static void withIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -4902,7 +4902,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_DEFAULTInt256VectorTests(IntFunction fa) { + static void IS_DEFAULTIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4919,7 +4919,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_DEFAULTMaskedInt256VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4943,7 +4943,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_NEGATIVEInt256VectorTests(IntFunction fa) { + static void IS_NEGATIVEIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4960,7 +4960,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_NEGATIVEMaskedInt256VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4980,7 +4980,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt256VectorTests(IntFunction fa, IntFunction fb) { + static void LTIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -4999,7 +4999,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltInt256VectorTests(IntFunction fa, IntFunction fb) { + static void ltIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5018,7 +5018,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5041,7 +5041,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GTInt256VectorTests(IntFunction fa, IntFunction fb) { + static void GTIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5060,7 +5060,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GTInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5083,7 +5083,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt256VectorTests(IntFunction fa, IntFunction fb) { + static void EQIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5102,7 +5102,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqInt256VectorTests(IntFunction fa, IntFunction fb) { + static void eqIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5121,7 +5121,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5144,7 +5144,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void NEInt256VectorTests(IntFunction fa, IntFunction fb) { + static void NEIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5163,7 +5163,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void NEInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5186,7 +5186,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LEInt256VectorTests(IntFunction fa, IntFunction fb) { + static void LEIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5205,7 +5205,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LEInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5228,7 +5228,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GEInt256VectorTests(IntFunction fa, IntFunction fb) { + static void GEIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5247,7 +5247,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GEInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5270,7 +5270,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULTInt256VectorTests(IntFunction fa, IntFunction fb) { + static void ULTIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5289,7 +5289,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULTInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5312,7 +5312,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGTInt256VectorTests(IntFunction fa, IntFunction fb) { + static void UGTIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5331,7 +5331,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGTInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5354,7 +5354,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULEInt256VectorTests(IntFunction fa, IntFunction fb) { + static void ULEIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5373,7 +5373,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULEInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5396,7 +5396,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGEInt256VectorTests(IntFunction fa, IntFunction fb) { + static void UGEIntVector256Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5415,7 +5415,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGEInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5438,7 +5438,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5454,7 +5454,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5474,7 +5474,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5490,7 +5490,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTIntVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5510,7 +5510,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5526,7 +5526,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5546,7 +5546,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5562,7 +5562,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQIntVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5586,7 +5586,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendInt256VectorTests(IntFunction fa, IntFunction fb, + static void blendIntVector256Tests(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5602,11 +5602,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int256VectorTests::blend); + assertArraysEquals(r, a, b, mask, IntVector256Tests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void RearrangeInt256VectorTests(IntFunction fa, + static void RearrangeIntVector256Tests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5623,7 +5623,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void RearrangeInt256VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeIntVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -5641,7 +5641,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void compressInt256VectorTests(IntFunction fa, + static void compressIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5659,7 +5659,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void expandInt256VectorTests(IntFunction fa, + static void expandIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5677,7 +5677,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void getInt256VectorTests(IntFunction fa) { + static void getIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5833,7 +5833,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastInt256VectorTests(IntFunction fa) { + static void BroadcastIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5847,7 +5847,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZeroInt256VectorTests(IntFunction fa) { + static void ZeroIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5872,7 +5872,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void sliceUnaryInt256VectorTests(IntFunction fa) { + static void sliceUnaryIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5883,7 +5883,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Int256VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, IntVector256Tests::sliceUnary); } static int[] sliceBinary(int[] a, int[] b, int origin, int idx) { @@ -5900,7 +5900,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void sliceBinaryInt256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryIntVector256TestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5913,7 +5913,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Int256VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, IntVector256Tests::sliceBinary); } static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) { @@ -5930,7 +5930,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void sliceInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5947,7 +5947,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Int256VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, IntVector256Tests::slice); } static int[] unsliceUnary(int[] a, int origin, int idx) { @@ -5964,7 +5964,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void unsliceUnaryInt256VectorTests(IntFunction fa) { + static void unsliceUnaryIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5975,7 +5975,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Int256VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, IntVector256Tests::unsliceUnary); } static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) { @@ -6001,7 +6001,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void unsliceBinaryInt256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryIntVector256TestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -6015,7 +6015,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Int256VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, IntVector256Tests::unsliceBinary); } static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) { @@ -6055,7 +6055,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void unsliceInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6072,7 +6072,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Int256VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, IntVector256Tests::unslice); } static int BITWISE_BLEND(int a, int b, int c) { @@ -6084,7 +6084,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6099,11 +6099,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Int256VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, IntVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6116,11 +6116,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Int256VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, IntVector256Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6138,11 +6138,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Int256VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, IntVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6153,11 +6153,11 @@ public class Int256VectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Int256VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, IntVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6168,11 +6168,11 @@ public class Int256VectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Int256VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, IntVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6183,11 +6183,11 @@ public class Int256VectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Int256VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, IntVector256Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class Int256VectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Int256VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, IntVector256Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6217,11 +6217,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Int256VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, IntVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector256TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6236,11 +6236,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Int256VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, IntVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6251,11 +6251,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Int256VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6266,11 +6266,11 @@ public class Int256VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Int256VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVector256Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector256TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6284,7 +6284,7 @@ public class Int256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int256VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, IntVector256Tests::BITWISE_BLEND); } static int NEG(int a) { @@ -6296,7 +6296,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NEGInt256VectorTests(IntFunction fa) { + static void NEGIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6307,11 +6307,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::NEG); + assertArraysEquals(r, a, IntVector256Tests::NEG); } @Test(dataProvider = "intUnaryOpProvider") - static void negInt256VectorTests(IntFunction fa) { + static void negIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6322,11 +6322,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::neg); + assertArraysEquals(r, a, IntVector256Tests::neg); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NEGMaskedInt256VectorTests(IntFunction fa, + static void NEGMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6340,7 +6340,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::NEG); + assertArraysEquals(r, a, mask, IntVector256Tests::NEG); } static int ABS(int a) { @@ -6352,7 +6352,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ABSInt256VectorTests(IntFunction fa) { + static void ABSIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6363,11 +6363,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::ABS); + assertArraysEquals(r, a, IntVector256Tests::ABS); } @Test(dataProvider = "intUnaryOpProvider") - static void absInt256VectorTests(IntFunction fa) { + static void absIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6378,11 +6378,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::abs); + assertArraysEquals(r, a, IntVector256Tests::abs); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ABSMaskedInt256VectorTests(IntFunction fa, + static void ABSMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6396,7 +6396,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::ABS); + assertArraysEquals(r, a, mask, IntVector256Tests::ABS); } static int NOT(int a) { @@ -6408,7 +6408,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NOTInt256VectorTests(IntFunction fa) { + static void NOTIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6419,11 +6419,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::NOT); + assertArraysEquals(r, a, IntVector256Tests::NOT); } @Test(dataProvider = "intUnaryOpProvider") - static void notInt256VectorTests(IntFunction fa) { + static void notIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6434,11 +6434,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::not); + assertArraysEquals(r, a, IntVector256Tests::not); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NOTMaskedInt256VectorTests(IntFunction fa, + static void NOTMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6452,7 +6452,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::NOT); + assertArraysEquals(r, a, mask, IntVector256Tests::NOT); } static int ZOMO(int a) { @@ -6460,7 +6460,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZOMOInt256VectorTests(IntFunction fa) { + static void ZOMOIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6471,11 +6471,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::ZOMO); + assertArraysEquals(r, a, IntVector256Tests::ZOMO); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ZOMOMaskedInt256VectorTests(IntFunction fa, + static void ZOMOMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6489,7 +6489,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::ZOMO); + assertArraysEquals(r, a, mask, IntVector256Tests::ZOMO); } static int BIT_COUNT(int a) { @@ -6497,7 +6497,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BIT_COUNTInt256VectorTests(IntFunction fa) { + static void BIT_COUNTIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6508,11 +6508,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::BIT_COUNT); + assertArraysEquals(r, a, IntVector256Tests::BIT_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void BIT_COUNTMaskedInt256VectorTests(IntFunction fa, + static void BIT_COUNTMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6526,7 +6526,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, IntVector256Tests::BIT_COUNT); } static int TRAILING_ZEROS_COUNT(int a) { @@ -6534,7 +6534,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void TRAILING_ZEROS_COUNTInt256VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6545,11 +6545,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVector256Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedInt256VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6563,7 +6563,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVector256Tests::TRAILING_ZEROS_COUNT); } static int LEADING_ZEROS_COUNT(int a) { @@ -6571,7 +6571,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LEADING_ZEROS_COUNTInt256VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6582,11 +6582,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVector256Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedInt256VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6600,7 +6600,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVector256Tests::LEADING_ZEROS_COUNT); } static int REVERSE(int a) { @@ -6608,7 +6608,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSEInt256VectorTests(IntFunction fa) { + static void REVERSEIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6619,11 +6619,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::REVERSE); + assertArraysEquals(r, a, IntVector256Tests::REVERSE); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSEMaskedInt256VectorTests(IntFunction fa, + static void REVERSEMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6637,7 +6637,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::REVERSE); + assertArraysEquals(r, a, mask, IntVector256Tests::REVERSE); } static int REVERSE_BYTES(int a) { @@ -6645,7 +6645,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSE_BYTESInt256VectorTests(IntFunction fa) { + static void REVERSE_BYTESIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6656,11 +6656,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, IntVector256Tests::REVERSE_BYTES); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedInt256VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedIntVector256Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6674,7 +6674,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int256VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, IntVector256Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6682,7 +6682,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandInt256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandIntVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6695,7 +6695,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::band); + assertArraysEquals(r, a, b, IntVector256Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6703,7 +6703,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorInt256VectorTests(IntFunction fa, IntFunction fb) { + static void maskorIntVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6716,7 +6716,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::bor); + assertArraysEquals(r, a, b, IntVector256Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6724,7 +6724,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorInt256VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorIntVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6737,7 +6737,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::bxor); + assertArraysEquals(r, a, b, IntVector256Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6745,7 +6745,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotInt256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotIntVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6758,7 +6758,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::bandNot); + assertArraysEquals(r, a, b, IntVector256Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6766,7 +6766,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqInt256VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqIntVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6779,7 +6779,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int256VectorTests::beq); + assertArraysEquals(r, a, b, IntVector256Tests::beq); } static boolean unot(boolean a) { @@ -6787,7 +6787,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotInt256VectorTests(IntFunction fa) { + static void masknotIntVector256Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6798,7 +6798,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int256VectorTests::unot); + assertArraysEquals(r, a, IntVector256Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6815,7 +6815,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongInt256VectorTests(IntFunction fa) { + static void maskFromToLongIntVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6829,7 +6829,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltInt256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltIntVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6845,7 +6845,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqInt256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqIntVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6861,7 +6861,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toIntArrayInt256VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayIntVector256TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6872,7 +6872,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toLongArrayInt256VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayIntVector256TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6883,7 +6883,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toDoubleArrayInt256VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayIntVector256TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6894,7 +6894,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toStringInt256VectorTestsSmokeTest(IntFunction fa) { + static void toStringIntVector256TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6907,7 +6907,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void hashCodeInt256VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeIntVector256TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6940,7 +6940,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceLongInt256VectorTests(IntFunction fa) { + static void ADDReduceLongIntVector256Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6956,7 +6956,7 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Int256VectorTests::ADDReduceLong, Int256VectorTests::ADDReduceAllLong); + IntVector256Tests::ADDReduceLong, IntVector256Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) { @@ -6979,7 +6979,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceLongInt256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongIntVector256TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6997,11 +6997,11 @@ public class Int256VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Int256VectorTests::ADDReduceLongMasked, Int256VectorTests::ADDReduceAllLongMasked); + IntVector256Tests::ADDReduceLongMasked, IntVector256Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastLongInt256VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongIntVector256TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7012,7 +7012,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendInt256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendIntVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -7026,12 +7026,12 @@ public class Int256VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Int256VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector256Tests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void SelectFromInt256VectorTests(IntFunction fa, + static void SelectFromIntVector256Tests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -7047,7 +7047,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorInt256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorIntVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] idx = fc.apply(SPECIES.length()); @@ -7065,7 +7065,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void SelectFromInt256VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromIntVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -7084,7 +7084,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousInt256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousIntVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7100,7 +7100,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringInt256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringIntVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7114,7 +7114,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsInt256VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsIntVector256TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7128,7 +7128,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsInt256VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsIntVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7144,7 +7144,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeInt256VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeIntVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7166,7 +7166,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountInt256VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountIntVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7177,7 +7177,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int256VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, IntVector256Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7191,7 +7191,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueInt256VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueIntVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7202,7 +7202,7 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int256VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, IntVector256Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7216,7 +7216,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueInt256VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueIntVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7227,11 +7227,11 @@ public class Int256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int256VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, IntVector256Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressInt256VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressIntVector256TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7259,7 +7259,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeInt256VectorTestsSmokeTest(int offset) { + static void indexInRangeIntVector256TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7273,7 +7273,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongInt256VectorTestsSmokeTest(int offset) { + static void indexInRangeLongIntVector256TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7300,14 +7300,14 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundInt256VectorTestsSmokeTest(int length) { + static void loopBoundIntVector256TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongInt256VectorTestsSmokeTest(int _length) { + static void loopBoundLongIntVector256TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7315,21 +7315,21 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeInt256VectorTestsSmokeTest() { + static void ElementSizeIntVector256TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Integer.SIZE); } @Test - static void VectorShapeInt256VectorTestsSmokeTest() { + static void VectorShapeIntVector256TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_256_BIT)); } @Test - static void ShapeWithLanesInt256VectorTestsSmokeTest() { + static void ShapeWithLanesIntVector256TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(int.class); @@ -7337,32 +7337,32 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeInt256VectorTestsSmokeTest() { + static void ElementTypeIntVector256TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementType() == int.class); } @Test - static void SpeciesElementSizeInt256VectorTestsSmokeTest() { + static void SpeciesElementSizeIntVector256TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementSize() == Integer.SIZE); } @Test - static void VectorTypeInt256VectorTestsSmokeTest() { + static void VectorTypeIntVector256TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesInt256VectorTestsSmokeTest() { + static void WithLanesIntVector256TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(int.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeInt256VectorTestsSmokeTest() { + static void WithShapeIntVector256TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7370,7 +7370,7 @@ public class Int256VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueInt256VectorTestsSmokeTest() { + static void MaskAllTrueIntVector256TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Int512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/IntVector512LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Int512VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/IntVector512LoadStoreTests.java index 1479dc57df5..189a5540f7d 100644 --- a/test/jdk/jdk/incubator/vector/Int512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/IntVector512LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Int512VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation IntVector512LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Int512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class IntVector512LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = IntVector.SPECIES_512; diff --git a/test/jdk/jdk/incubator/vector/Int512VectorTests.java b/test/jdk/jdk/incubator/vector/IntVector512Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Int512VectorTests.java rename to test/jdk/jdk/incubator/vector/IntVector512Tests.java index d2eda11e6f5..468d3b15efe 100644 --- a/test/jdk/jdk/incubator/vector/Int512VectorTests.java +++ b/test/jdk/jdk/incubator/vector/IntVector512Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Int512VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation IntVector512Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Int512VectorTests extends AbstractVectorTest { +public class IntVector512Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = IntVector.SPECIES_512; @@ -1667,7 +1667,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ADDInt512VectorTests(IntFunction fa, IntFunction fb) { + static void ADDIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1680,7 +1680,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::ADD); + assertArraysEquals(r, a, b, IntVector512Tests::ADD); } static int add(int a, int b) { @@ -1688,7 +1688,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void addInt512VectorTests(IntFunction fa, IntFunction fb) { + static void addIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1699,11 +1699,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int512VectorTests::add); + assertArraysEquals(r, a, b, IntVector512Tests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1719,11 +1719,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::ADD); + assertArraysEquals(r, a, b, mask, IntVector512Tests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1737,7 +1737,7 @@ public class Int512VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int512VectorTests::add); + assertArraysEquals(r, a, b, mask, IntVector512Tests::add); } static int SUB(int a, int b) { @@ -1745,7 +1745,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void SUBInt512VectorTests(IntFunction fa, IntFunction fb) { + static void SUBIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1758,7 +1758,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::SUB); + assertArraysEquals(r, a, b, IntVector512Tests::SUB); } static int sub(int a, int b) { @@ -1766,7 +1766,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void subInt512VectorTests(IntFunction fa, IntFunction fb) { + static void subIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1777,11 +1777,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int512VectorTests::sub); + assertArraysEquals(r, a, b, IntVector512Tests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void SUBInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1797,11 +1797,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::SUB); + assertArraysEquals(r, a, b, mask, IntVector512Tests::SUB); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1815,7 +1815,7 @@ public class Int512VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int512VectorTests::sub); + assertArraysEquals(r, a, b, mask, IntVector512Tests::sub); } static int MUL(int a, int b) { @@ -1823,7 +1823,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MULInt512VectorTests(IntFunction fa, IntFunction fb) { + static void MULIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1836,7 +1836,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::MUL); + assertArraysEquals(r, a, b, IntVector512Tests::MUL); } static int mul(int a, int b) { @@ -1844,7 +1844,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void mulInt512VectorTests(IntFunction fa, IntFunction fb) { + static void mulIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1855,11 +1855,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int512VectorTests::mul); + assertArraysEquals(r, a, b, IntVector512Tests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void MULInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1875,11 +1875,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::MUL); + assertArraysEquals(r, a, b, mask, IntVector512Tests::MUL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1893,7 +1893,7 @@ public class Int512VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int512VectorTests::mul); + assertArraysEquals(r, a, b, mask, IntVector512Tests::mul); } static int DIV(int a, int b) { @@ -1901,7 +1901,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void DIVInt512VectorTests(IntFunction fa, IntFunction fb) { + static void DIVIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1916,7 +1916,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::DIV); + assertArraysEquals(r, a, b, IntVector512Tests::DIV); } static int div(int a, int b) { @@ -1924,7 +1924,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void divInt512VectorTests(IntFunction fa, IntFunction fb) { + static void divIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1939,11 +1939,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::div); + assertArraysEquals(r, a, b, IntVector512Tests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void DIVInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1961,11 +1961,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::DIV); + assertArraysEquals(r, a, b, mask, IntVector512Tests::DIV); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1983,7 +1983,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::div); + assertArraysEquals(r, a, b, mask, IntVector512Tests::div); } static int FIRST_NONZERO(int a, int b) { @@ -1991,7 +1991,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void FIRST_NONZEROInt512VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2004,11 +2004,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, IntVector512Tests::FIRST_NONZERO); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void FIRST_NONZEROInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2024,7 +2024,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, IntVector512Tests::FIRST_NONZERO); } static int AND(int a, int b) { @@ -2032,7 +2032,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ANDInt512VectorTests(IntFunction fa, IntFunction fb) { + static void ANDIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2045,7 +2045,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::AND); + assertArraysEquals(r, a, b, IntVector512Tests::AND); } static int and(int a, int b) { @@ -2053,7 +2053,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void andInt512VectorTests(IntFunction fa, IntFunction fb) { + static void andIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2064,11 +2064,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int512VectorTests::and); + assertArraysEquals(r, a, b, IntVector512Tests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2084,7 +2084,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::AND); + assertArraysEquals(r, a, b, mask, IntVector512Tests::AND); } static int AND_NOT(int a, int b) { @@ -2092,7 +2092,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void AND_NOTInt512VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2105,11 +2105,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::AND_NOT); + assertArraysEquals(r, a, b, IntVector512Tests::AND_NOT); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void AND_NOTInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2125,7 +2125,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, IntVector512Tests::AND_NOT); } static int OR(int a, int b) { @@ -2133,7 +2133,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt512VectorTests(IntFunction fa, IntFunction fb) { + static void ORIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2146,7 +2146,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::OR); + assertArraysEquals(r, a, b, IntVector512Tests::OR); } static int or(int a, int b) { @@ -2154,7 +2154,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void orInt512VectorTests(IntFunction fa, IntFunction fb) { + static void orIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2165,11 +2165,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int512VectorTests::or); + assertArraysEquals(r, a, b, IntVector512Tests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2185,7 +2185,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::OR); + assertArraysEquals(r, a, b, mask, IntVector512Tests::OR); } static int XOR(int a, int b) { @@ -2193,7 +2193,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void XORInt512VectorTests(IntFunction fa, IntFunction fb) { + static void XORIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2206,11 +2206,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::XOR); + assertArraysEquals(r, a, b, IntVector512Tests::XOR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void XORInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2226,7 +2226,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::XOR); + assertArraysEquals(r, a, b, mask, IntVector512Tests::XOR); } static int COMPRESS_BITS(int a, int b) { @@ -2234,7 +2234,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void COMPRESS_BITSInt512VectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2247,11 +2247,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, IntVector512Tests::COMPRESS_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void COMPRESS_BITSInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2267,7 +2267,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, IntVector512Tests::COMPRESS_BITS); } static int EXPAND_BITS(int a, int b) { @@ -2275,7 +2275,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void EXPAND_BITSInt512VectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2288,11 +2288,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, IntVector512Tests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void EXPAND_BITSInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2308,11 +2308,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, IntVector512Tests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpProvider") - static void addInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2322,11 +2322,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2339,11 +2339,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, IntVector512Tests::add); } @Test(dataProvider = "intBinaryOpProvider") - static void subInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2353,11 +2353,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2370,11 +2370,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, IntVector512Tests::sub); } @Test(dataProvider = "intBinaryOpProvider") - static void mulInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2384,11 +2384,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2401,11 +2401,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, IntVector512Tests::mul); } @Test(dataProvider = "intBinaryOpProvider") - static void divInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2436,11 +2436,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, IntVector512Tests::div); } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2450,11 +2450,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void orInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2464,11 +2464,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::or); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2481,11 +2481,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int512VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, IntVector512Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ANDInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2495,11 +2495,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void andInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2509,11 +2509,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::and); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2526,11 +2526,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int512VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, IntVector512Tests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2540,11 +2540,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Int512VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, IntVector512Tests::OR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2557,11 +2557,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Int512VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector512Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ADDInt512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDIntVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2571,11 +2571,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Int512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, IntVector512Tests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDInt512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDIntVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2588,7 +2588,7 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Int512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector512Tests::ADD); } static int LSHL(int a, int b) { @@ -2596,7 +2596,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLInt512VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2609,11 +2609,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::LSHL); + assertArraysEquals(r, a, b, IntVector512Tests::LSHL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2629,7 +2629,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, IntVector512Tests::LSHL); } static int ASHR(int a, int b) { @@ -2637,7 +2637,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRInt512VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2650,11 +2650,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::ASHR); + assertArraysEquals(r, a, b, IntVector512Tests::ASHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2670,7 +2670,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, IntVector512Tests::ASHR); } static int LSHR(int a, int b) { @@ -2678,7 +2678,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRInt512VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2691,11 +2691,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::LSHR); + assertArraysEquals(r, a, b, IntVector512Tests::LSHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2711,7 +2711,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, IntVector512Tests::LSHR); } static int LSHL_unary(int a, int b) { @@ -2719,7 +2719,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLInt512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLIntVector512TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2731,11 +2731,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int512VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, IntVector512Tests::LSHL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLInt512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2750,7 +2750,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int512VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector512Tests::LSHL_unary); } static int LSHR_unary(int a, int b) { @@ -2758,7 +2758,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRInt512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRIntVector512TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2770,11 +2770,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int512VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, IntVector512Tests::LSHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRInt512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2789,7 +2789,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int512VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector512Tests::LSHR_unary); } static int ASHR_unary(int a, int b) { @@ -2797,7 +2797,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRInt512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRIntVector512TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2809,11 +2809,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int512VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, IntVector512Tests::ASHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRInt512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2828,7 +2828,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int512VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector512Tests::ASHR_unary); } static int ROR(int a, int b) { @@ -2836,7 +2836,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORInt512VectorTests(IntFunction fa, IntFunction fb) { + static void RORIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2849,11 +2849,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::ROR); + assertArraysEquals(r, a, b, IntVector512Tests::ROR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2869,7 +2869,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::ROR); + assertArraysEquals(r, a, b, mask, IntVector512Tests::ROR); } static int ROL(int a, int b) { @@ -2877,7 +2877,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLInt512VectorTests(IntFunction fa, IntFunction fb) { + static void ROLIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2890,11 +2890,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::ROL); + assertArraysEquals(r, a, b, IntVector512Tests::ROL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2910,7 +2910,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::ROL); + assertArraysEquals(r, a, b, mask, IntVector512Tests::ROL); } static int ROR_unary(int a, int b) { @@ -2918,7 +2918,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORInt512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORIntVector512TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2930,11 +2930,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int512VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, IntVector512Tests::ROR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORInt512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORIntVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2949,7 +2949,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int512VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector512Tests::ROR_unary); } static int ROL_unary(int a, int b) { @@ -2957,7 +2957,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLInt512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLIntVector512TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2969,11 +2969,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int512VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, IntVector512Tests::ROL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLInt512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLIntVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2988,14 +2988,14 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int512VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector512Tests::ROL_unary); } static int LSHR_binary_const(int a) { return (int)((a >>> CONST_SHIFT)); } @Test(dataProvider = "intUnaryOpProvider") - static void LSHRInt512VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRIntVector512TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3006,11 +3006,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int512VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, IntVector512Tests::LSHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHRInt512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRIntVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3024,7 +3024,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int512VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector512Tests::LSHR_binary_const); } static int LSHL_binary_const(int a) { @@ -3032,7 +3032,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LSHLInt512VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLIntVector512TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3043,11 +3043,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int512VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, IntVector512Tests::LSHL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHLInt512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLIntVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3061,7 +3061,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int512VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, IntVector512Tests::LSHL_binary_const); } static int ASHR_binary_const(int a) { @@ -3069,7 +3069,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ASHRInt512VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRIntVector512TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3080,11 +3080,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int512VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, IntVector512Tests::ASHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ASHRInt512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRIntVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3098,7 +3098,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int512VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector512Tests::ASHR_binary_const); } static int ROR_binary_const(int a) { @@ -3106,7 +3106,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void RORInt512VectorTestsScalarShiftConst(IntFunction fa) { + static void RORIntVector512TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3117,11 +3117,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int512VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, IntVector512Tests::ROR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void RORInt512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORIntVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3135,7 +3135,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int512VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector512Tests::ROR_binary_const); } static int ROL_binary_const(int a) { @@ -3143,7 +3143,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ROLInt512VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLIntVector512TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3154,11 +3154,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int512VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, IntVector512Tests::ROL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ROLInt512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLIntVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3172,14 +3172,14 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int512VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, IntVector512Tests::ROL_binary_const); } static IntVector bv_MIN = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MINInt512VectorTestsWithMemOp(IntFunction fa) { + static void MINIntVector512TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3190,13 +3190,13 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int512VectorTests::MIN); + assertArraysEquals(r, a, (int)10, IntVector512Tests::MIN); } static IntVector bv_min = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void minInt512VectorTestsWithMemOp(IntFunction fa) { + static void minIntVector512TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3207,13 +3207,13 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int512VectorTests::min); + assertArraysEquals(r, a, (int)10, IntVector512Tests::min); } static IntVector bv_MIN_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINInt512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINIntVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3226,13 +3226,13 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, Int512VectorTests::MIN); + assertArraysEquals(r, a, (int)10, mask, IntVector512Tests::MIN); } static IntVector bv_MAX = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MAXInt512VectorTestsWithMemOp(IntFunction fa) { + static void MAXIntVector512TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3243,13 +3243,13 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int512VectorTests::MAX); + assertArraysEquals(r, a, (int)10, IntVector512Tests::MAX); } static IntVector bv_max = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void maxInt512VectorTestsWithMemOp(IntFunction fa) { + static void maxIntVector512TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3260,13 +3260,13 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int512VectorTests::max); + assertArraysEquals(r, a, (int)10, IntVector512Tests::max); } static IntVector bv_MAX_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXInt512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXIntVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3279,7 +3279,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, Int512VectorTests::MAX); + assertArraysEquals(r, a, (int)10, mask, IntVector512Tests::MAX); } static int MIN(int a, int b) { @@ -3287,7 +3287,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MINInt512VectorTests(IntFunction fa, IntFunction fb) { + static void MINIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3300,7 +3300,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::MIN); + assertArraysEquals(r, a, b, IntVector512Tests::MIN); } static int min(int a, int b) { @@ -3308,7 +3308,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void minInt512VectorTests(IntFunction fa, IntFunction fb) { + static void minIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3319,7 +3319,7 @@ public class Int512VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int512VectorTests::min); + assertArraysEquals(r, a, b, IntVector512Tests::min); } static int MAX(int a, int b) { @@ -3327,7 +3327,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MAXInt512VectorTests(IntFunction fa, IntFunction fb) { + static void MAXIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3340,7 +3340,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::MAX); + assertArraysEquals(r, a, b, IntVector512Tests::MAX); } static int max(int a, int b) { @@ -3348,7 +3348,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void maxInt512VectorTests(IntFunction fa, IntFunction fb) { + static void maxIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3359,7 +3359,7 @@ public class Int512VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int512VectorTests::max); + assertArraysEquals(r, a, b, IntVector512Tests::max); } static int UMIN(int a, int b) { @@ -3367,7 +3367,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMINInt512VectorTests(IntFunction fa, IntFunction fb) { + static void UMINIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3380,11 +3380,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::UMIN); + assertArraysEquals(r, a, b, IntVector512Tests::UMIN); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMINInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3400,7 +3400,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, IntVector512Tests::UMIN); } static int UMAX(int a, int b) { @@ -3408,7 +3408,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMAXInt512VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3421,11 +3421,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::UMAX); + assertArraysEquals(r, a, b, IntVector512Tests::UMAX); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMAXInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3441,7 +3441,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, IntVector512Tests::UMAX); } static int SADD(int a, int b) { @@ -3449,7 +3449,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SADDInt512VectorTests(IntFunction fa, IntFunction fb) { + static void SADDIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3462,11 +3462,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::SADD); + assertArraysEquals(r, a, b, IntVector512Tests::SADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SADDInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3482,7 +3482,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::SADD); + assertArraysEquals(r, a, b, mask, IntVector512Tests::SADD); } static int SSUB(int a, int b) { @@ -3490,7 +3490,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SSUBInt512VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3503,11 +3503,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::SSUB); + assertArraysEquals(r, a, b, IntVector512Tests::SSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SSUBInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3523,7 +3523,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, IntVector512Tests::SSUB); } static int SUADD(int a, int b) { @@ -3531,7 +3531,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUADDInt512VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3544,11 +3544,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::SUADD); + assertArraysEquals(r, a, b, IntVector512Tests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUADDInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3564,7 +3564,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, IntVector512Tests::SUADD); } static int SUSUB(int a, int b) { @@ -3572,7 +3572,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUSUBInt512VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3585,11 +3585,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::SUSUB); + assertArraysEquals(r, a, b, IntVector512Tests::SUSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUSUBInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3605,11 +3605,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, IntVector512Tests::SUSUB); } @Test(dataProvider = "intBinaryOpProvider") - static void MINInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3619,11 +3619,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::MIN); } @Test(dataProvider = "intBinaryOpProvider") - static void minInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3633,11 +3633,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::min); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::min); } @Test(dataProvider = "intBinaryOpProvider") - static void MAXInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3647,11 +3647,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::MAX); } @Test(dataProvider = "intBinaryOpProvider") - static void maxInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3661,10 +3661,10 @@ public class Int512VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int512VectorTests::max); + assertBroadcastArraysEquals(r, a, b, IntVector512Tests::max); } @Test(dataProvider = "intSaturatingBinaryOpAssocProvider") - static void SUADDAssocInt512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocIntVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -3681,11 +3681,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Int512VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, IntVector512Tests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3706,7 +3706,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Int512VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, IntVector512Tests::SUADD); } static int ANDReduce(int[] a, int idx) { @@ -3728,7 +3728,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ANDReduceInt512VectorTests(IntFunction fa) { + static void ANDReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3744,7 +3744,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::ANDReduce, Int512VectorTests::ANDReduceAll); + IntVector512Tests::ANDReduce, IntVector512Tests::ANDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3790,7 +3790,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ANDReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3808,7 +3808,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::ANDReduceMasked, Int512VectorTests::ANDReduceAllMasked); + IntVector512Tests::ANDReduceMasked, IntVector512Tests::ANDReduceAllMasked); } static int ORReduce(int[] a, int idx) { @@ -3830,7 +3830,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ORReduceInt512VectorTests(IntFunction fa) { + static void ORReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3846,7 +3846,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::ORReduce, Int512VectorTests::ORReduceAll); + IntVector512Tests::ORReduce, IntVector512Tests::ORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3892,7 +3892,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ORReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3910,7 +3910,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::ORReduceMasked, Int512VectorTests::ORReduceAllMasked); + IntVector512Tests::ORReduceMasked, IntVector512Tests::ORReduceAllMasked); } static int XORReduce(int[] a, int idx) { @@ -3932,7 +3932,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void XORReduceInt512VectorTests(IntFunction fa) { + static void XORReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3948,7 +3948,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::XORReduce, Int512VectorTests::XORReduceAll); + IntVector512Tests::XORReduce, IntVector512Tests::XORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3994,7 +3994,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void XORReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4012,7 +4012,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::XORReduceMasked, Int512VectorTests::XORReduceAllMasked); + IntVector512Tests::XORReduceMasked, IntVector512Tests::XORReduceAllMasked); } static int ADDReduce(int[] a, int idx) { @@ -4034,7 +4034,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceInt512VectorTests(IntFunction fa) { + static void ADDReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4050,7 +4050,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::ADDReduce, Int512VectorTests::ADDReduceAll); + IntVector512Tests::ADDReduce, IntVector512Tests::ADDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4096,7 +4096,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4114,7 +4114,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::ADDReduceMasked, Int512VectorTests::ADDReduceAllMasked); + IntVector512Tests::ADDReduceMasked, IntVector512Tests::ADDReduceAllMasked); } static int MULReduce(int[] a, int idx) { @@ -4136,7 +4136,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MULReduceInt512VectorTests(IntFunction fa) { + static void MULReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4152,7 +4152,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::MULReduce, Int512VectorTests::MULReduceAll); + IntVector512Tests::MULReduce, IntVector512Tests::MULReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4198,7 +4198,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MULReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4216,7 +4216,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::MULReduceMasked, Int512VectorTests::MULReduceAllMasked); + IntVector512Tests::MULReduceMasked, IntVector512Tests::MULReduceAllMasked); } static int MINReduce(int[] a, int idx) { @@ -4238,7 +4238,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MINReduceInt512VectorTests(IntFunction fa) { + static void MINReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4254,7 +4254,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::MINReduce, Int512VectorTests::MINReduceAll); + IntVector512Tests::MINReduce, IntVector512Tests::MINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4300,7 +4300,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4318,7 +4318,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::MINReduceMasked, Int512VectorTests::MINReduceAllMasked); + IntVector512Tests::MINReduceMasked, IntVector512Tests::MINReduceAllMasked); } static int MAXReduce(int[] a, int idx) { @@ -4340,7 +4340,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MAXReduceInt512VectorTests(IntFunction fa) { + static void MAXReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4356,7 +4356,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::MAXReduce, Int512VectorTests::MAXReduceAll); + IntVector512Tests::MAXReduce, IntVector512Tests::MAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4402,7 +4402,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4420,7 +4420,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::MAXReduceMasked, Int512VectorTests::MAXReduceAllMasked); + IntVector512Tests::MAXReduceMasked, IntVector512Tests::MAXReduceAllMasked); } static int UMINReduce(int[] a, int idx) { @@ -4442,7 +4442,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMINReduceInt512VectorTests(IntFunction fa) { + static void UMINReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4458,7 +4458,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::UMINReduce, Int512VectorTests::UMINReduceAll); + IntVector512Tests::UMINReduce, IntVector512Tests::UMINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4504,7 +4504,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMINReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4522,7 +4522,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::UMINReduceMasked, Int512VectorTests::UMINReduceAllMasked); + IntVector512Tests::UMINReduceMasked, IntVector512Tests::UMINReduceAllMasked); } static int UMAXReduce(int[] a, int idx) { @@ -4544,7 +4544,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMAXReduceInt512VectorTests(IntFunction fa) { + static void UMAXReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4560,7 +4560,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::UMAXReduce, Int512VectorTests::UMAXReduceAll); + IntVector512Tests::UMAXReduce, IntVector512Tests::UMAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4606,7 +4606,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMAXReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4624,7 +4624,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::UMAXReduceMasked, Int512VectorTests::UMAXReduceAllMasked); + IntVector512Tests::UMAXReduceMasked, IntVector512Tests::UMAXReduceAllMasked); } static int FIRST_NONZEROReduce(int[] a, int idx) { @@ -4646,7 +4646,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void FIRST_NONZEROReduceInt512VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4662,7 +4662,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::FIRST_NONZEROReduce, Int512VectorTests::FIRST_NONZEROReduceAll); + IntVector512Tests::FIRST_NONZEROReduce, IntVector512Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4708,7 +4708,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void FIRST_NONZEROReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4726,7 +4726,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::FIRST_NONZEROReduceMasked, Int512VectorTests::FIRST_NONZEROReduceAllMasked); + IntVector512Tests::FIRST_NONZEROReduceMasked, IntVector512Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4739,7 +4739,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueInt512VectorTests(IntFunction fm) { + static void anyTrueIntVector512Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4750,7 +4750,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Int512VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, IntVector512Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4763,7 +4763,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueInt512VectorTests(IntFunction fm) { + static void allTrueIntVector512Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4774,7 +4774,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Int512VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, IntVector512Tests::allTrue); } static int SUADDReduce(int[] a, int idx) { @@ -4796,7 +4796,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingUnaryOpProvider") - static void SUADDReduceInt512VectorTests(IntFunction fa) { + static void SUADDReduceIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4812,7 +4812,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int512VectorTests::SUADDReduce, Int512VectorTests::SUADDReduceAll); + IntVector512Tests::SUADDReduce, IntVector512Tests::SUADDReduceAll); } @Test(dataProvider = "intSaturatingUnaryOpProvider") @@ -4857,7 +4857,7 @@ public class Int512VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "intSaturatingUnaryOpMaskProvider") - static void SUADDReduceInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4875,11 +4875,11 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::SUADDReduceMasked, Int512VectorTests::SUADDReduceAllMasked); + IntVector512Tests::SUADDReduceMasked, IntVector512Tests::SUADDReduceAllMasked); } @Test(dataProvider = "intBinaryOpProvider") - static void withInt512VectorTests(IntFunction fa, IntFunction fb) { + static void withIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -4902,7 +4902,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_DEFAULTInt512VectorTests(IntFunction fa) { + static void IS_DEFAULTIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4919,7 +4919,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_DEFAULTMaskedInt512VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4943,7 +4943,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_NEGATIVEInt512VectorTests(IntFunction fa) { + static void IS_NEGATIVEIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4960,7 +4960,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_NEGATIVEMaskedInt512VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4980,7 +4980,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt512VectorTests(IntFunction fa, IntFunction fb) { + static void LTIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -4999,7 +4999,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltInt512VectorTests(IntFunction fa, IntFunction fb) { + static void ltIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5018,7 +5018,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5041,7 +5041,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GTInt512VectorTests(IntFunction fa, IntFunction fb) { + static void GTIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5060,7 +5060,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GTInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5083,7 +5083,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt512VectorTests(IntFunction fa, IntFunction fb) { + static void EQIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5102,7 +5102,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqInt512VectorTests(IntFunction fa, IntFunction fb) { + static void eqIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5121,7 +5121,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5144,7 +5144,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void NEInt512VectorTests(IntFunction fa, IntFunction fb) { + static void NEIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5163,7 +5163,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void NEInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5186,7 +5186,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LEInt512VectorTests(IntFunction fa, IntFunction fb) { + static void LEIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5205,7 +5205,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LEInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5228,7 +5228,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GEInt512VectorTests(IntFunction fa, IntFunction fb) { + static void GEIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5247,7 +5247,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GEInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5270,7 +5270,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULTInt512VectorTests(IntFunction fa, IntFunction fb) { + static void ULTIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5289,7 +5289,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULTInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5312,7 +5312,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGTInt512VectorTests(IntFunction fa, IntFunction fb) { + static void UGTIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5331,7 +5331,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGTInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5354,7 +5354,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULEInt512VectorTests(IntFunction fa, IntFunction fb) { + static void ULEIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5373,7 +5373,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULEInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5396,7 +5396,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGEInt512VectorTests(IntFunction fa, IntFunction fb) { + static void UGEIntVector512Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5415,7 +5415,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGEInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5438,7 +5438,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5454,7 +5454,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5474,7 +5474,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5490,7 +5490,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTIntVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5510,7 +5510,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5526,7 +5526,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5546,7 +5546,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5562,7 +5562,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQIntVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5586,7 +5586,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendInt512VectorTests(IntFunction fa, IntFunction fb, + static void blendIntVector512Tests(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5602,11 +5602,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int512VectorTests::blend); + assertArraysEquals(r, a, b, mask, IntVector512Tests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void RearrangeInt512VectorTests(IntFunction fa, + static void RearrangeIntVector512Tests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5623,7 +5623,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void RearrangeInt512VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeIntVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -5641,7 +5641,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void compressInt512VectorTests(IntFunction fa, + static void compressIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5659,7 +5659,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void expandInt512VectorTests(IntFunction fa, + static void expandIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5677,7 +5677,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void getInt512VectorTests(IntFunction fa) { + static void getIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5833,7 +5833,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastInt512VectorTests(IntFunction fa) { + static void BroadcastIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5847,7 +5847,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZeroInt512VectorTests(IntFunction fa) { + static void ZeroIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5872,7 +5872,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void sliceUnaryInt512VectorTests(IntFunction fa) { + static void sliceUnaryIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5883,7 +5883,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Int512VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, IntVector512Tests::sliceUnary); } static int[] sliceBinary(int[] a, int[] b, int origin, int idx) { @@ -5900,7 +5900,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void sliceBinaryInt512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryIntVector512TestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5913,7 +5913,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Int512VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, IntVector512Tests::sliceBinary); } static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) { @@ -5930,7 +5930,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void sliceInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5947,7 +5947,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Int512VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, IntVector512Tests::slice); } static int[] unsliceUnary(int[] a, int origin, int idx) { @@ -5964,7 +5964,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void unsliceUnaryInt512VectorTests(IntFunction fa) { + static void unsliceUnaryIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5975,7 +5975,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Int512VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, IntVector512Tests::unsliceUnary); } static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) { @@ -6001,7 +6001,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void unsliceBinaryInt512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryIntVector512TestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -6015,7 +6015,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Int512VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, IntVector512Tests::unsliceBinary); } static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) { @@ -6055,7 +6055,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void unsliceInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6072,7 +6072,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Int512VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, IntVector512Tests::unslice); } static int BITWISE_BLEND(int a, int b, int c) { @@ -6084,7 +6084,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6099,11 +6099,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Int512VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, IntVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6116,11 +6116,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Int512VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, IntVector512Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6138,11 +6138,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Int512VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, IntVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6153,11 +6153,11 @@ public class Int512VectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Int512VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, IntVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6168,11 +6168,11 @@ public class Int512VectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Int512VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, IntVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6183,11 +6183,11 @@ public class Int512VectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Int512VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, IntVector512Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class Int512VectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Int512VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, IntVector512Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6217,11 +6217,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Int512VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, IntVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt512VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector512TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6236,11 +6236,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Int512VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, IntVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6251,11 +6251,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Int512VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6266,11 +6266,11 @@ public class Int512VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Int512VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVector512Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt512VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector512TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6284,7 +6284,7 @@ public class Int512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int512VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, IntVector512Tests::BITWISE_BLEND); } static int NEG(int a) { @@ -6296,7 +6296,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NEGInt512VectorTests(IntFunction fa) { + static void NEGIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6307,11 +6307,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::NEG); + assertArraysEquals(r, a, IntVector512Tests::NEG); } @Test(dataProvider = "intUnaryOpProvider") - static void negInt512VectorTests(IntFunction fa) { + static void negIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6322,11 +6322,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::neg); + assertArraysEquals(r, a, IntVector512Tests::neg); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NEGMaskedInt512VectorTests(IntFunction fa, + static void NEGMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6340,7 +6340,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::NEG); + assertArraysEquals(r, a, mask, IntVector512Tests::NEG); } static int ABS(int a) { @@ -6352,7 +6352,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ABSInt512VectorTests(IntFunction fa) { + static void ABSIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6363,11 +6363,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::ABS); + assertArraysEquals(r, a, IntVector512Tests::ABS); } @Test(dataProvider = "intUnaryOpProvider") - static void absInt512VectorTests(IntFunction fa) { + static void absIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6378,11 +6378,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::abs); + assertArraysEquals(r, a, IntVector512Tests::abs); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ABSMaskedInt512VectorTests(IntFunction fa, + static void ABSMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6396,7 +6396,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::ABS); + assertArraysEquals(r, a, mask, IntVector512Tests::ABS); } static int NOT(int a) { @@ -6408,7 +6408,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NOTInt512VectorTests(IntFunction fa) { + static void NOTIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6419,11 +6419,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::NOT); + assertArraysEquals(r, a, IntVector512Tests::NOT); } @Test(dataProvider = "intUnaryOpProvider") - static void notInt512VectorTests(IntFunction fa) { + static void notIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6434,11 +6434,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::not); + assertArraysEquals(r, a, IntVector512Tests::not); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NOTMaskedInt512VectorTests(IntFunction fa, + static void NOTMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6452,7 +6452,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::NOT); + assertArraysEquals(r, a, mask, IntVector512Tests::NOT); } static int ZOMO(int a) { @@ -6460,7 +6460,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZOMOInt512VectorTests(IntFunction fa) { + static void ZOMOIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6471,11 +6471,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::ZOMO); + assertArraysEquals(r, a, IntVector512Tests::ZOMO); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ZOMOMaskedInt512VectorTests(IntFunction fa, + static void ZOMOMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6489,7 +6489,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::ZOMO); + assertArraysEquals(r, a, mask, IntVector512Tests::ZOMO); } static int BIT_COUNT(int a) { @@ -6497,7 +6497,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BIT_COUNTInt512VectorTests(IntFunction fa) { + static void BIT_COUNTIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6508,11 +6508,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::BIT_COUNT); + assertArraysEquals(r, a, IntVector512Tests::BIT_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void BIT_COUNTMaskedInt512VectorTests(IntFunction fa, + static void BIT_COUNTMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6526,7 +6526,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, IntVector512Tests::BIT_COUNT); } static int TRAILING_ZEROS_COUNT(int a) { @@ -6534,7 +6534,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void TRAILING_ZEROS_COUNTInt512VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6545,11 +6545,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVector512Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedInt512VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6563,7 +6563,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVector512Tests::TRAILING_ZEROS_COUNT); } static int LEADING_ZEROS_COUNT(int a) { @@ -6571,7 +6571,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LEADING_ZEROS_COUNTInt512VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6582,11 +6582,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVector512Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedInt512VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6600,7 +6600,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVector512Tests::LEADING_ZEROS_COUNT); } static int REVERSE(int a) { @@ -6608,7 +6608,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSEInt512VectorTests(IntFunction fa) { + static void REVERSEIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6619,11 +6619,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::REVERSE); + assertArraysEquals(r, a, IntVector512Tests::REVERSE); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSEMaskedInt512VectorTests(IntFunction fa, + static void REVERSEMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6637,7 +6637,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::REVERSE); + assertArraysEquals(r, a, mask, IntVector512Tests::REVERSE); } static int REVERSE_BYTES(int a) { @@ -6645,7 +6645,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSE_BYTESInt512VectorTests(IntFunction fa) { + static void REVERSE_BYTESIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6656,11 +6656,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, IntVector512Tests::REVERSE_BYTES); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedInt512VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedIntVector512Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6674,7 +6674,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int512VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, IntVector512Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6682,7 +6682,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandInt512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandIntVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6695,7 +6695,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::band); + assertArraysEquals(r, a, b, IntVector512Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6703,7 +6703,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorInt512VectorTests(IntFunction fa, IntFunction fb) { + static void maskorIntVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6716,7 +6716,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::bor); + assertArraysEquals(r, a, b, IntVector512Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6724,7 +6724,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorInt512VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorIntVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6737,7 +6737,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::bxor); + assertArraysEquals(r, a, b, IntVector512Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6745,7 +6745,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotInt512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotIntVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6758,7 +6758,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::bandNot); + assertArraysEquals(r, a, b, IntVector512Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6766,7 +6766,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqInt512VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqIntVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6779,7 +6779,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int512VectorTests::beq); + assertArraysEquals(r, a, b, IntVector512Tests::beq); } static boolean unot(boolean a) { @@ -6787,7 +6787,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotInt512VectorTests(IntFunction fa) { + static void masknotIntVector512Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6798,7 +6798,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int512VectorTests::unot); + assertArraysEquals(r, a, IntVector512Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6815,7 +6815,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongInt512VectorTests(IntFunction fa) { + static void maskFromToLongIntVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6829,7 +6829,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltInt512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltIntVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6845,7 +6845,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqInt512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqIntVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6861,7 +6861,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toIntArrayInt512VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayIntVector512TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6872,7 +6872,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toLongArrayInt512VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayIntVector512TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6883,7 +6883,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toDoubleArrayInt512VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayIntVector512TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6894,7 +6894,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toStringInt512VectorTestsSmokeTest(IntFunction fa) { + static void toStringIntVector512TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6907,7 +6907,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void hashCodeInt512VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeIntVector512TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6940,7 +6940,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceLongInt512VectorTests(IntFunction fa) { + static void ADDReduceLongIntVector512Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6956,7 +6956,7 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Int512VectorTests::ADDReduceLong, Int512VectorTests::ADDReduceAllLong); + IntVector512Tests::ADDReduceLong, IntVector512Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) { @@ -6979,7 +6979,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceLongInt512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongIntVector512TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6997,11 +6997,11 @@ public class Int512VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Int512VectorTests::ADDReduceLongMasked, Int512VectorTests::ADDReduceAllLongMasked); + IntVector512Tests::ADDReduceLongMasked, IntVector512Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastLongInt512VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongIntVector512TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7012,7 +7012,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendInt512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendIntVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -7026,12 +7026,12 @@ public class Int512VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Int512VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector512Tests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void SelectFromInt512VectorTests(IntFunction fa, + static void SelectFromIntVector512Tests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -7047,7 +7047,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorInt512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorIntVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] idx = fc.apply(SPECIES.length()); @@ -7065,7 +7065,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void SelectFromInt512VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromIntVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -7084,7 +7084,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousInt512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousIntVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7100,7 +7100,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringInt512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringIntVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7114,7 +7114,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsInt512VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsIntVector512TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7128,7 +7128,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsInt512VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsIntVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7144,7 +7144,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeInt512VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeIntVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7166,7 +7166,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountInt512VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountIntVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7177,7 +7177,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int512VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, IntVector512Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7191,7 +7191,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueInt512VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueIntVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7202,7 +7202,7 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int512VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, IntVector512Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7216,7 +7216,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueInt512VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueIntVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7227,11 +7227,11 @@ public class Int512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int512VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, IntVector512Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressInt512VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressIntVector512TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7259,7 +7259,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeInt512VectorTestsSmokeTest(int offset) { + static void indexInRangeIntVector512TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7273,7 +7273,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongInt512VectorTestsSmokeTest(int offset) { + static void indexInRangeLongIntVector512TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7300,14 +7300,14 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundInt512VectorTestsSmokeTest(int length) { + static void loopBoundIntVector512TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongInt512VectorTestsSmokeTest(int _length) { + static void loopBoundLongIntVector512TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7315,21 +7315,21 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeInt512VectorTestsSmokeTest() { + static void ElementSizeIntVector512TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Integer.SIZE); } @Test - static void VectorShapeInt512VectorTestsSmokeTest() { + static void VectorShapeIntVector512TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_512_BIT)); } @Test - static void ShapeWithLanesInt512VectorTestsSmokeTest() { + static void ShapeWithLanesIntVector512TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(int.class); @@ -7337,32 +7337,32 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeInt512VectorTestsSmokeTest() { + static void ElementTypeIntVector512TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementType() == int.class); } @Test - static void SpeciesElementSizeInt512VectorTestsSmokeTest() { + static void SpeciesElementSizeIntVector512TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementSize() == Integer.SIZE); } @Test - static void VectorTypeInt512VectorTestsSmokeTest() { + static void VectorTypeIntVector512TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesInt512VectorTestsSmokeTest() { + static void WithLanesIntVector512TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(int.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeInt512VectorTestsSmokeTest() { + static void WithShapeIntVector512TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7370,7 +7370,7 @@ public class Int512VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueInt512VectorTestsSmokeTest() { + static void MaskAllTrueIntVector512TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Int64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/IntVector64LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Int64VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/IntVector64LoadStoreTests.java index 5dfc0ac2f4f..418a8bb8581 100644 --- a/test/jdk/jdk/incubator/vector/Int64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/IntVector64LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Int64VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation IntVector64LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Int64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class IntVector64LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = IntVector.SPECIES_64; diff --git a/test/jdk/jdk/incubator/vector/Int64VectorTests.java b/test/jdk/jdk/incubator/vector/IntVector64Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Int64VectorTests.java rename to test/jdk/jdk/incubator/vector/IntVector64Tests.java index 6eb6322ba2b..0715981e050 100644 --- a/test/jdk/jdk/incubator/vector/Int64VectorTests.java +++ b/test/jdk/jdk/incubator/vector/IntVector64Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Int64VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation IntVector64Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Int64VectorTests extends AbstractVectorTest { +public class IntVector64Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = IntVector.SPECIES_64; @@ -1667,7 +1667,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ADDInt64VectorTests(IntFunction fa, IntFunction fb) { + static void ADDIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1680,7 +1680,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::ADD); + assertArraysEquals(r, a, b, IntVector64Tests::ADD); } static int add(int a, int b) { @@ -1688,7 +1688,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void addInt64VectorTests(IntFunction fa, IntFunction fb) { + static void addIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1699,11 +1699,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int64VectorTests::add); + assertArraysEquals(r, a, b, IntVector64Tests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1719,11 +1719,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::ADD); + assertArraysEquals(r, a, b, mask, IntVector64Tests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1737,7 +1737,7 @@ public class Int64VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int64VectorTests::add); + assertArraysEquals(r, a, b, mask, IntVector64Tests::add); } static int SUB(int a, int b) { @@ -1745,7 +1745,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void SUBInt64VectorTests(IntFunction fa, IntFunction fb) { + static void SUBIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1758,7 +1758,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::SUB); + assertArraysEquals(r, a, b, IntVector64Tests::SUB); } static int sub(int a, int b) { @@ -1766,7 +1766,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void subInt64VectorTests(IntFunction fa, IntFunction fb) { + static void subIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1777,11 +1777,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int64VectorTests::sub); + assertArraysEquals(r, a, b, IntVector64Tests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void SUBInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1797,11 +1797,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::SUB); + assertArraysEquals(r, a, b, mask, IntVector64Tests::SUB); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1815,7 +1815,7 @@ public class Int64VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int64VectorTests::sub); + assertArraysEquals(r, a, b, mask, IntVector64Tests::sub); } static int MUL(int a, int b) { @@ -1823,7 +1823,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MULInt64VectorTests(IntFunction fa, IntFunction fb) { + static void MULIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1836,7 +1836,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::MUL); + assertArraysEquals(r, a, b, IntVector64Tests::MUL); } static int mul(int a, int b) { @@ -1844,7 +1844,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void mulInt64VectorTests(IntFunction fa, IntFunction fb) { + static void mulIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1855,11 +1855,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int64VectorTests::mul); + assertArraysEquals(r, a, b, IntVector64Tests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void MULInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1875,11 +1875,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::MUL); + assertArraysEquals(r, a, b, mask, IntVector64Tests::MUL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1893,7 +1893,7 @@ public class Int64VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Int64VectorTests::mul); + assertArraysEquals(r, a, b, mask, IntVector64Tests::mul); } static int DIV(int a, int b) { @@ -1901,7 +1901,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void DIVInt64VectorTests(IntFunction fa, IntFunction fb) { + static void DIVIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1916,7 +1916,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::DIV); + assertArraysEquals(r, a, b, IntVector64Tests::DIV); } static int div(int a, int b) { @@ -1924,7 +1924,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void divInt64VectorTests(IntFunction fa, IntFunction fb) { + static void divIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1939,11 +1939,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::div); + assertArraysEquals(r, a, b, IntVector64Tests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void DIVInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1961,11 +1961,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::DIV); + assertArraysEquals(r, a, b, mask, IntVector64Tests::DIV); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1983,7 +1983,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::div); + assertArraysEquals(r, a, b, mask, IntVector64Tests::div); } static int FIRST_NONZERO(int a, int b) { @@ -1991,7 +1991,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void FIRST_NONZEROInt64VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2004,11 +2004,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, IntVector64Tests::FIRST_NONZERO); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void FIRST_NONZEROInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2024,7 +2024,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, IntVector64Tests::FIRST_NONZERO); } static int AND(int a, int b) { @@ -2032,7 +2032,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ANDInt64VectorTests(IntFunction fa, IntFunction fb) { + static void ANDIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2045,7 +2045,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::AND); + assertArraysEquals(r, a, b, IntVector64Tests::AND); } static int and(int a, int b) { @@ -2053,7 +2053,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void andInt64VectorTests(IntFunction fa, IntFunction fb) { + static void andIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2064,11 +2064,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int64VectorTests::and); + assertArraysEquals(r, a, b, IntVector64Tests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2084,7 +2084,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::AND); + assertArraysEquals(r, a, b, mask, IntVector64Tests::AND); } static int AND_NOT(int a, int b) { @@ -2092,7 +2092,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void AND_NOTInt64VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2105,11 +2105,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::AND_NOT); + assertArraysEquals(r, a, b, IntVector64Tests::AND_NOT); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void AND_NOTInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2125,7 +2125,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, IntVector64Tests::AND_NOT); } static int OR(int a, int b) { @@ -2133,7 +2133,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt64VectorTests(IntFunction fa, IntFunction fb) { + static void ORIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2146,7 +2146,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::OR); + assertArraysEquals(r, a, b, IntVector64Tests::OR); } static int or(int a, int b) { @@ -2154,7 +2154,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void orInt64VectorTests(IntFunction fa, IntFunction fb) { + static void orIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2165,11 +2165,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int64VectorTests::or); + assertArraysEquals(r, a, b, IntVector64Tests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2185,7 +2185,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::OR); + assertArraysEquals(r, a, b, mask, IntVector64Tests::OR); } static int XOR(int a, int b) { @@ -2193,7 +2193,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void XORInt64VectorTests(IntFunction fa, IntFunction fb) { + static void XORIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2206,11 +2206,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::XOR); + assertArraysEquals(r, a, b, IntVector64Tests::XOR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void XORInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2226,7 +2226,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::XOR); + assertArraysEquals(r, a, b, mask, IntVector64Tests::XOR); } static int COMPRESS_BITS(int a, int b) { @@ -2234,7 +2234,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void COMPRESS_BITSInt64VectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2247,11 +2247,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, IntVector64Tests::COMPRESS_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void COMPRESS_BITSInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2267,7 +2267,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, IntVector64Tests::COMPRESS_BITS); } static int EXPAND_BITS(int a, int b) { @@ -2275,7 +2275,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void EXPAND_BITSInt64VectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2288,11 +2288,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, IntVector64Tests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void EXPAND_BITSInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2308,11 +2308,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, IntVector64Tests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpProvider") - static void addInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2322,11 +2322,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2339,11 +2339,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, IntVector64Tests::add); } @Test(dataProvider = "intBinaryOpProvider") - static void subInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2353,11 +2353,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2370,11 +2370,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, IntVector64Tests::sub); } @Test(dataProvider = "intBinaryOpProvider") - static void mulInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2384,11 +2384,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2401,11 +2401,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, IntVector64Tests::mul); } @Test(dataProvider = "intBinaryOpProvider") - static void divInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2436,11 +2436,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, IntVector64Tests::div); } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2450,11 +2450,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void orInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2464,11 +2464,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::or); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2481,11 +2481,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, IntVector64Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ANDInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2495,11 +2495,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void andInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2509,11 +2509,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::and); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2526,11 +2526,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, IntVector64Tests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void ORInt64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2540,11 +2540,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Int64VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, IntVector64Tests::OR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORInt64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2557,11 +2557,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector64Tests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ADDInt64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDIntVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2571,11 +2571,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Int64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, IntVector64Tests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDInt64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDIntVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2588,7 +2588,7 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector64Tests::ADD); } static int LSHL(int a, int b) { @@ -2596,7 +2596,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLInt64VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2609,11 +2609,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::LSHL); + assertArraysEquals(r, a, b, IntVector64Tests::LSHL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2629,7 +2629,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, IntVector64Tests::LSHL); } static int ASHR(int a, int b) { @@ -2637,7 +2637,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRInt64VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2650,11 +2650,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::ASHR); + assertArraysEquals(r, a, b, IntVector64Tests::ASHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2670,7 +2670,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, IntVector64Tests::ASHR); } static int LSHR(int a, int b) { @@ -2678,7 +2678,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRInt64VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2691,11 +2691,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::LSHR); + assertArraysEquals(r, a, b, IntVector64Tests::LSHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2711,7 +2711,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, IntVector64Tests::LSHR); } static int LSHL_unary(int a, int b) { @@ -2719,7 +2719,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLInt64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLIntVector64TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2731,11 +2731,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int64VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, IntVector64Tests::LSHL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLInt64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2750,7 +2750,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector64Tests::LSHL_unary); } static int LSHR_unary(int a, int b) { @@ -2758,7 +2758,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRInt64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRIntVector64TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2770,11 +2770,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int64VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, IntVector64Tests::LSHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRInt64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2789,7 +2789,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector64Tests::LSHR_unary); } static int ASHR_unary(int a, int b) { @@ -2797,7 +2797,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRInt64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRIntVector64TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2809,11 +2809,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int64VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, IntVector64Tests::ASHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRInt64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2828,7 +2828,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector64Tests::ASHR_unary); } static int ROR(int a, int b) { @@ -2836,7 +2836,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORInt64VectorTests(IntFunction fa, IntFunction fb) { + static void RORIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2849,11 +2849,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::ROR); + assertArraysEquals(r, a, b, IntVector64Tests::ROR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2869,7 +2869,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::ROR); + assertArraysEquals(r, a, b, mask, IntVector64Tests::ROR); } static int ROL(int a, int b) { @@ -2877,7 +2877,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLInt64VectorTests(IntFunction fa, IntFunction fb) { + static void ROLIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2890,11 +2890,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::ROL); + assertArraysEquals(r, a, b, IntVector64Tests::ROL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2910,7 +2910,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::ROL); + assertArraysEquals(r, a, b, mask, IntVector64Tests::ROL); } static int ROR_unary(int a, int b) { @@ -2918,7 +2918,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORInt64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORIntVector64TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2930,11 +2930,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int64VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, IntVector64Tests::ROR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORInt64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORIntVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2949,7 +2949,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector64Tests::ROR_unary); } static int ROL_unary(int a, int b) { @@ -2957,7 +2957,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLInt64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLIntVector64TestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2969,11 +2969,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Int64VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, IntVector64Tests::ROL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLInt64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLIntVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2988,14 +2988,14 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVector64Tests::ROL_unary); } static int LSHR_binary_const(int a) { return (int)((a >>> CONST_SHIFT)); } @Test(dataProvider = "intUnaryOpProvider") - static void LSHRInt64VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRIntVector64TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3006,11 +3006,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int64VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, IntVector64Tests::LSHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHRInt64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRIntVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3024,7 +3024,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int64VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector64Tests::LSHR_binary_const); } static int LSHL_binary_const(int a) { @@ -3032,7 +3032,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LSHLInt64VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLIntVector64TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3043,11 +3043,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int64VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, IntVector64Tests::LSHL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHLInt64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLIntVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3061,7 +3061,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int64VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, IntVector64Tests::LSHL_binary_const); } static int ASHR_binary_const(int a) { @@ -3069,7 +3069,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ASHRInt64VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRIntVector64TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3080,11 +3080,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int64VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, IntVector64Tests::ASHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ASHRInt64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRIntVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3098,7 +3098,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int64VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector64Tests::ASHR_binary_const); } static int ROR_binary_const(int a) { @@ -3106,7 +3106,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void RORInt64VectorTestsScalarShiftConst(IntFunction fa) { + static void RORIntVector64TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3117,11 +3117,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int64VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, IntVector64Tests::ROR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void RORInt64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORIntVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3135,7 +3135,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int64VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, IntVector64Tests::ROR_binary_const); } static int ROL_binary_const(int a) { @@ -3143,7 +3143,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ROLInt64VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLIntVector64TestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3154,11 +3154,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Int64VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, IntVector64Tests::ROL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ROLInt64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLIntVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3172,14 +3172,14 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Int64VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, IntVector64Tests::ROL_binary_const); } static IntVector bv_MIN = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MINInt64VectorTestsWithMemOp(IntFunction fa) { + static void MINIntVector64TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3190,13 +3190,13 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int64VectorTests::MIN); + assertArraysEquals(r, a, (int)10, IntVector64Tests::MIN); } static IntVector bv_min = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void minInt64VectorTestsWithMemOp(IntFunction fa) { + static void minIntVector64TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3207,13 +3207,13 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int64VectorTests::min); + assertArraysEquals(r, a, (int)10, IntVector64Tests::min); } static IntVector bv_MIN_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINInt64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINIntVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3226,13 +3226,13 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, Int64VectorTests::MIN); + assertArraysEquals(r, a, (int)10, mask, IntVector64Tests::MIN); } static IntVector bv_MAX = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MAXInt64VectorTestsWithMemOp(IntFunction fa) { + static void MAXIntVector64TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3243,13 +3243,13 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int64VectorTests::MAX); + assertArraysEquals(r, a, (int)10, IntVector64Tests::MAX); } static IntVector bv_max = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void maxInt64VectorTestsWithMemOp(IntFunction fa) { + static void maxIntVector64TestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3260,13 +3260,13 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, Int64VectorTests::max); + assertArraysEquals(r, a, (int)10, IntVector64Tests::max); } static IntVector bv_MAX_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXInt64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXIntVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3279,7 +3279,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, Int64VectorTests::MAX); + assertArraysEquals(r, a, (int)10, mask, IntVector64Tests::MAX); } static int MIN(int a, int b) { @@ -3287,7 +3287,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MINInt64VectorTests(IntFunction fa, IntFunction fb) { + static void MINIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3300,7 +3300,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::MIN); + assertArraysEquals(r, a, b, IntVector64Tests::MIN); } static int min(int a, int b) { @@ -3308,7 +3308,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void minInt64VectorTests(IntFunction fa, IntFunction fb) { + static void minIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3319,7 +3319,7 @@ public class Int64VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int64VectorTests::min); + assertArraysEquals(r, a, b, IntVector64Tests::min); } static int MAX(int a, int b) { @@ -3327,7 +3327,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MAXInt64VectorTests(IntFunction fa, IntFunction fb) { + static void MAXIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3340,7 +3340,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::MAX); + assertArraysEquals(r, a, b, IntVector64Tests::MAX); } static int max(int a, int b) { @@ -3348,7 +3348,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void maxInt64VectorTests(IntFunction fa, IntFunction fb) { + static void maxIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3359,7 +3359,7 @@ public class Int64VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Int64VectorTests::max); + assertArraysEquals(r, a, b, IntVector64Tests::max); } static int UMIN(int a, int b) { @@ -3367,7 +3367,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMINInt64VectorTests(IntFunction fa, IntFunction fb) { + static void UMINIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3380,11 +3380,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::UMIN); + assertArraysEquals(r, a, b, IntVector64Tests::UMIN); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMINInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3400,7 +3400,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, IntVector64Tests::UMIN); } static int UMAX(int a, int b) { @@ -3408,7 +3408,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMAXInt64VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3421,11 +3421,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::UMAX); + assertArraysEquals(r, a, b, IntVector64Tests::UMAX); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMAXInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3441,7 +3441,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, IntVector64Tests::UMAX); } static int SADD(int a, int b) { @@ -3449,7 +3449,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SADDInt64VectorTests(IntFunction fa, IntFunction fb) { + static void SADDIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3462,11 +3462,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::SADD); + assertArraysEquals(r, a, b, IntVector64Tests::SADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SADDInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3482,7 +3482,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::SADD); + assertArraysEquals(r, a, b, mask, IntVector64Tests::SADD); } static int SSUB(int a, int b) { @@ -3490,7 +3490,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SSUBInt64VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3503,11 +3503,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::SSUB); + assertArraysEquals(r, a, b, IntVector64Tests::SSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SSUBInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3523,7 +3523,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, IntVector64Tests::SSUB); } static int SUADD(int a, int b) { @@ -3531,7 +3531,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUADDInt64VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3544,11 +3544,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::SUADD); + assertArraysEquals(r, a, b, IntVector64Tests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUADDInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3564,7 +3564,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, IntVector64Tests::SUADD); } static int SUSUB(int a, int b) { @@ -3572,7 +3572,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUSUBInt64VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3585,11 +3585,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::SUSUB); + assertArraysEquals(r, a, b, IntVector64Tests::SUSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUSUBInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3605,11 +3605,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, IntVector64Tests::SUSUB); } @Test(dataProvider = "intBinaryOpProvider") - static void MINInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3619,11 +3619,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::MIN); } @Test(dataProvider = "intBinaryOpProvider") - static void minInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3633,11 +3633,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::min); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::min); } @Test(dataProvider = "intBinaryOpProvider") - static void MAXInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3647,11 +3647,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::MAX); } @Test(dataProvider = "intBinaryOpProvider") - static void maxInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3661,10 +3661,10 @@ public class Int64VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Int64VectorTests::max); + assertBroadcastArraysEquals(r, a, b, IntVector64Tests::max); } @Test(dataProvider = "intSaturatingBinaryOpAssocProvider") - static void SUADDAssocInt64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocIntVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -3681,11 +3681,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Int64VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, IntVector64Tests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3706,7 +3706,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Int64VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, IntVector64Tests::SUADD); } static int ANDReduce(int[] a, int idx) { @@ -3728,7 +3728,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ANDReduceInt64VectorTests(IntFunction fa) { + static void ANDReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3744,7 +3744,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::ANDReduce, Int64VectorTests::ANDReduceAll); + IntVector64Tests::ANDReduce, IntVector64Tests::ANDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3790,7 +3790,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ANDReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3808,7 +3808,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::ANDReduceMasked, Int64VectorTests::ANDReduceAllMasked); + IntVector64Tests::ANDReduceMasked, IntVector64Tests::ANDReduceAllMasked); } static int ORReduce(int[] a, int idx) { @@ -3830,7 +3830,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ORReduceInt64VectorTests(IntFunction fa) { + static void ORReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3846,7 +3846,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::ORReduce, Int64VectorTests::ORReduceAll); + IntVector64Tests::ORReduce, IntVector64Tests::ORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3892,7 +3892,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ORReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3910,7 +3910,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::ORReduceMasked, Int64VectorTests::ORReduceAllMasked); + IntVector64Tests::ORReduceMasked, IntVector64Tests::ORReduceAllMasked); } static int XORReduce(int[] a, int idx) { @@ -3932,7 +3932,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void XORReduceInt64VectorTests(IntFunction fa) { + static void XORReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3948,7 +3948,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::XORReduce, Int64VectorTests::XORReduceAll); + IntVector64Tests::XORReduce, IntVector64Tests::XORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3994,7 +3994,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void XORReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4012,7 +4012,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::XORReduceMasked, Int64VectorTests::XORReduceAllMasked); + IntVector64Tests::XORReduceMasked, IntVector64Tests::XORReduceAllMasked); } static int ADDReduce(int[] a, int idx) { @@ -4034,7 +4034,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceInt64VectorTests(IntFunction fa) { + static void ADDReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4050,7 +4050,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::ADDReduce, Int64VectorTests::ADDReduceAll); + IntVector64Tests::ADDReduce, IntVector64Tests::ADDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4096,7 +4096,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4114,7 +4114,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::ADDReduceMasked, Int64VectorTests::ADDReduceAllMasked); + IntVector64Tests::ADDReduceMasked, IntVector64Tests::ADDReduceAllMasked); } static int MULReduce(int[] a, int idx) { @@ -4136,7 +4136,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MULReduceInt64VectorTests(IntFunction fa) { + static void MULReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4152,7 +4152,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::MULReduce, Int64VectorTests::MULReduceAll); + IntVector64Tests::MULReduce, IntVector64Tests::MULReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4198,7 +4198,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MULReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4216,7 +4216,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::MULReduceMasked, Int64VectorTests::MULReduceAllMasked); + IntVector64Tests::MULReduceMasked, IntVector64Tests::MULReduceAllMasked); } static int MINReduce(int[] a, int idx) { @@ -4238,7 +4238,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MINReduceInt64VectorTests(IntFunction fa) { + static void MINReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4254,7 +4254,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::MINReduce, Int64VectorTests::MINReduceAll); + IntVector64Tests::MINReduce, IntVector64Tests::MINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4300,7 +4300,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4318,7 +4318,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::MINReduceMasked, Int64VectorTests::MINReduceAllMasked); + IntVector64Tests::MINReduceMasked, IntVector64Tests::MINReduceAllMasked); } static int MAXReduce(int[] a, int idx) { @@ -4340,7 +4340,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MAXReduceInt64VectorTests(IntFunction fa) { + static void MAXReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4356,7 +4356,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::MAXReduce, Int64VectorTests::MAXReduceAll); + IntVector64Tests::MAXReduce, IntVector64Tests::MAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4402,7 +4402,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4420,7 +4420,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::MAXReduceMasked, Int64VectorTests::MAXReduceAllMasked); + IntVector64Tests::MAXReduceMasked, IntVector64Tests::MAXReduceAllMasked); } static int UMINReduce(int[] a, int idx) { @@ -4442,7 +4442,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMINReduceInt64VectorTests(IntFunction fa) { + static void UMINReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4458,7 +4458,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::UMINReduce, Int64VectorTests::UMINReduceAll); + IntVector64Tests::UMINReduce, IntVector64Tests::UMINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4504,7 +4504,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMINReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4522,7 +4522,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::UMINReduceMasked, Int64VectorTests::UMINReduceAllMasked); + IntVector64Tests::UMINReduceMasked, IntVector64Tests::UMINReduceAllMasked); } static int UMAXReduce(int[] a, int idx) { @@ -4544,7 +4544,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMAXReduceInt64VectorTests(IntFunction fa) { + static void UMAXReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4560,7 +4560,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::UMAXReduce, Int64VectorTests::UMAXReduceAll); + IntVector64Tests::UMAXReduce, IntVector64Tests::UMAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4606,7 +4606,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMAXReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4624,7 +4624,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::UMAXReduceMasked, Int64VectorTests::UMAXReduceAllMasked); + IntVector64Tests::UMAXReduceMasked, IntVector64Tests::UMAXReduceAllMasked); } static int FIRST_NONZEROReduce(int[] a, int idx) { @@ -4646,7 +4646,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void FIRST_NONZEROReduceInt64VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4662,7 +4662,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::FIRST_NONZEROReduce, Int64VectorTests::FIRST_NONZEROReduceAll); + IntVector64Tests::FIRST_NONZEROReduce, IntVector64Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4708,7 +4708,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void FIRST_NONZEROReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4726,7 +4726,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::FIRST_NONZEROReduceMasked, Int64VectorTests::FIRST_NONZEROReduceAllMasked); + IntVector64Tests::FIRST_NONZEROReduceMasked, IntVector64Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4739,7 +4739,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueInt64VectorTests(IntFunction fm) { + static void anyTrueIntVector64Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4750,7 +4750,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Int64VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, IntVector64Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4763,7 +4763,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueInt64VectorTests(IntFunction fm) { + static void allTrueIntVector64Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4774,7 +4774,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Int64VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, IntVector64Tests::allTrue); } static int SUADDReduce(int[] a, int idx) { @@ -4796,7 +4796,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingUnaryOpProvider") - static void SUADDReduceInt64VectorTests(IntFunction fa) { + static void SUADDReduceIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4812,7 +4812,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Int64VectorTests::SUADDReduce, Int64VectorTests::SUADDReduceAll); + IntVector64Tests::SUADDReduce, IntVector64Tests::SUADDReduceAll); } @Test(dataProvider = "intSaturatingUnaryOpProvider") @@ -4857,7 +4857,7 @@ public class Int64VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "intSaturatingUnaryOpMaskProvider") - static void SUADDReduceInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4875,11 +4875,11 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::SUADDReduceMasked, Int64VectorTests::SUADDReduceAllMasked); + IntVector64Tests::SUADDReduceMasked, IntVector64Tests::SUADDReduceAllMasked); } @Test(dataProvider = "intBinaryOpProvider") - static void withInt64VectorTests(IntFunction fa, IntFunction fb) { + static void withIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -4902,7 +4902,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_DEFAULTInt64VectorTests(IntFunction fa) { + static void IS_DEFAULTIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4919,7 +4919,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_DEFAULTMaskedInt64VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4943,7 +4943,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_NEGATIVEInt64VectorTests(IntFunction fa) { + static void IS_NEGATIVEIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4960,7 +4960,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_NEGATIVEMaskedInt64VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4980,7 +4980,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt64VectorTests(IntFunction fa, IntFunction fb) { + static void LTIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -4999,7 +4999,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltInt64VectorTests(IntFunction fa, IntFunction fb) { + static void ltIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5018,7 +5018,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5041,7 +5041,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GTInt64VectorTests(IntFunction fa, IntFunction fb) { + static void GTIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5060,7 +5060,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GTInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5083,7 +5083,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt64VectorTests(IntFunction fa, IntFunction fb) { + static void EQIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5102,7 +5102,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqInt64VectorTests(IntFunction fa, IntFunction fb) { + static void eqIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5121,7 +5121,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5144,7 +5144,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void NEInt64VectorTests(IntFunction fa, IntFunction fb) { + static void NEIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5163,7 +5163,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void NEInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5186,7 +5186,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LEInt64VectorTests(IntFunction fa, IntFunction fb) { + static void LEIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5205,7 +5205,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LEInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5228,7 +5228,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GEInt64VectorTests(IntFunction fa, IntFunction fb) { + static void GEIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5247,7 +5247,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GEInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5270,7 +5270,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULTInt64VectorTests(IntFunction fa, IntFunction fb) { + static void ULTIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5289,7 +5289,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULTInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5312,7 +5312,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGTInt64VectorTests(IntFunction fa, IntFunction fb) { + static void UGTIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5331,7 +5331,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGTInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5354,7 +5354,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULEInt64VectorTests(IntFunction fa, IntFunction fb) { + static void ULEIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5373,7 +5373,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULEInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5396,7 +5396,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGEInt64VectorTests(IntFunction fa, IntFunction fb) { + static void UGEIntVector64Tests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5415,7 +5415,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGEInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5438,7 +5438,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5454,7 +5454,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5474,7 +5474,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTInt64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5490,7 +5490,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTInt64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTIntVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5510,7 +5510,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5526,7 +5526,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5546,7 +5546,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQInt64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5562,7 +5562,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQInt64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQIntVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5586,7 +5586,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendInt64VectorTests(IntFunction fa, IntFunction fb, + static void blendIntVector64Tests(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5602,11 +5602,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Int64VectorTests::blend); + assertArraysEquals(r, a, b, mask, IntVector64Tests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void RearrangeInt64VectorTests(IntFunction fa, + static void RearrangeIntVector64Tests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5623,7 +5623,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void RearrangeInt64VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeIntVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -5641,7 +5641,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void compressInt64VectorTests(IntFunction fa, + static void compressIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5659,7 +5659,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void expandInt64VectorTests(IntFunction fa, + static void expandIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5677,7 +5677,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void getInt64VectorTests(IntFunction fa) { + static void getIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5833,7 +5833,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastInt64VectorTests(IntFunction fa) { + static void BroadcastIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5847,7 +5847,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZeroInt64VectorTests(IntFunction fa) { + static void ZeroIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5872,7 +5872,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void sliceUnaryInt64VectorTests(IntFunction fa) { + static void sliceUnaryIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5883,7 +5883,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Int64VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, IntVector64Tests::sliceUnary); } static int[] sliceBinary(int[] a, int[] b, int origin, int idx) { @@ -5900,7 +5900,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void sliceBinaryInt64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryIntVector64TestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5913,7 +5913,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Int64VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, IntVector64Tests::sliceBinary); } static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) { @@ -5930,7 +5930,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void sliceInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5947,7 +5947,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Int64VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, IntVector64Tests::slice); } static int[] unsliceUnary(int[] a, int origin, int idx) { @@ -5964,7 +5964,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void unsliceUnaryInt64VectorTests(IntFunction fa) { + static void unsliceUnaryIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5975,7 +5975,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Int64VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, IntVector64Tests::unsliceUnary); } static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) { @@ -6001,7 +6001,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void unsliceBinaryInt64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryIntVector64TestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -6015,7 +6015,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Int64VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, IntVector64Tests::unsliceBinary); } static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) { @@ -6055,7 +6055,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void unsliceInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6072,7 +6072,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Int64VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, IntVector64Tests::unslice); } static int BITWISE_BLEND(int a, int b, int c) { @@ -6084,7 +6084,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6099,11 +6099,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, IntVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6116,11 +6116,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, IntVector64Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6138,11 +6138,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, IntVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6153,11 +6153,11 @@ public class Int64VectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, IntVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6168,11 +6168,11 @@ public class Int64VectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, IntVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6183,11 +6183,11 @@ public class Int64VectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, IntVector64Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class Int64VectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, IntVector64Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6217,11 +6217,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, IntVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt64VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector64TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6236,11 +6236,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, IntVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDInt64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6251,11 +6251,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendInt64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6266,11 +6266,11 @@ public class Int64VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVector64Tests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDInt64VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVector64TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6284,7 +6284,7 @@ public class Int64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, IntVector64Tests::BITWISE_BLEND); } static int NEG(int a) { @@ -6296,7 +6296,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NEGInt64VectorTests(IntFunction fa) { + static void NEGIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6307,11 +6307,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::NEG); + assertArraysEquals(r, a, IntVector64Tests::NEG); } @Test(dataProvider = "intUnaryOpProvider") - static void negInt64VectorTests(IntFunction fa) { + static void negIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6322,11 +6322,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::neg); + assertArraysEquals(r, a, IntVector64Tests::neg); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NEGMaskedInt64VectorTests(IntFunction fa, + static void NEGMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6340,7 +6340,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::NEG); + assertArraysEquals(r, a, mask, IntVector64Tests::NEG); } static int ABS(int a) { @@ -6352,7 +6352,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ABSInt64VectorTests(IntFunction fa) { + static void ABSIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6363,11 +6363,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::ABS); + assertArraysEquals(r, a, IntVector64Tests::ABS); } @Test(dataProvider = "intUnaryOpProvider") - static void absInt64VectorTests(IntFunction fa) { + static void absIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6378,11 +6378,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::abs); + assertArraysEquals(r, a, IntVector64Tests::abs); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ABSMaskedInt64VectorTests(IntFunction fa, + static void ABSMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6396,7 +6396,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::ABS); + assertArraysEquals(r, a, mask, IntVector64Tests::ABS); } static int NOT(int a) { @@ -6408,7 +6408,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NOTInt64VectorTests(IntFunction fa) { + static void NOTIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6419,11 +6419,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::NOT); + assertArraysEquals(r, a, IntVector64Tests::NOT); } @Test(dataProvider = "intUnaryOpProvider") - static void notInt64VectorTests(IntFunction fa) { + static void notIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6434,11 +6434,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::not); + assertArraysEquals(r, a, IntVector64Tests::not); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NOTMaskedInt64VectorTests(IntFunction fa, + static void NOTMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6452,7 +6452,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::NOT); + assertArraysEquals(r, a, mask, IntVector64Tests::NOT); } static int ZOMO(int a) { @@ -6460,7 +6460,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZOMOInt64VectorTests(IntFunction fa) { + static void ZOMOIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6471,11 +6471,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::ZOMO); + assertArraysEquals(r, a, IntVector64Tests::ZOMO); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ZOMOMaskedInt64VectorTests(IntFunction fa, + static void ZOMOMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6489,7 +6489,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::ZOMO); + assertArraysEquals(r, a, mask, IntVector64Tests::ZOMO); } static int BIT_COUNT(int a) { @@ -6497,7 +6497,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BIT_COUNTInt64VectorTests(IntFunction fa) { + static void BIT_COUNTIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6508,11 +6508,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::BIT_COUNT); + assertArraysEquals(r, a, IntVector64Tests::BIT_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void BIT_COUNTMaskedInt64VectorTests(IntFunction fa, + static void BIT_COUNTMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6526,7 +6526,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, IntVector64Tests::BIT_COUNT); } static int TRAILING_ZEROS_COUNT(int a) { @@ -6534,7 +6534,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void TRAILING_ZEROS_COUNTInt64VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6545,11 +6545,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVector64Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedInt64VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6563,7 +6563,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVector64Tests::TRAILING_ZEROS_COUNT); } static int LEADING_ZEROS_COUNT(int a) { @@ -6571,7 +6571,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LEADING_ZEROS_COUNTInt64VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6582,11 +6582,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVector64Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedInt64VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6600,7 +6600,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVector64Tests::LEADING_ZEROS_COUNT); } static int REVERSE(int a) { @@ -6608,7 +6608,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSEInt64VectorTests(IntFunction fa) { + static void REVERSEIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6619,11 +6619,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::REVERSE); + assertArraysEquals(r, a, IntVector64Tests::REVERSE); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSEMaskedInt64VectorTests(IntFunction fa, + static void REVERSEMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6637,7 +6637,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::REVERSE); + assertArraysEquals(r, a, mask, IntVector64Tests::REVERSE); } static int REVERSE_BYTES(int a) { @@ -6645,7 +6645,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSE_BYTESInt64VectorTests(IntFunction fa) { + static void REVERSE_BYTESIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6656,11 +6656,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, IntVector64Tests::REVERSE_BYTES); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedInt64VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedIntVector64Tests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6674,7 +6674,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Int64VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, IntVector64Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6682,7 +6682,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandInt64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandIntVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6695,7 +6695,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::band); + assertArraysEquals(r, a, b, IntVector64Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6703,7 +6703,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorInt64VectorTests(IntFunction fa, IntFunction fb) { + static void maskorIntVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6716,7 +6716,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::bor); + assertArraysEquals(r, a, b, IntVector64Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6724,7 +6724,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorInt64VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorIntVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6737,7 +6737,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::bxor); + assertArraysEquals(r, a, b, IntVector64Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6745,7 +6745,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotInt64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotIntVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6758,7 +6758,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::bandNot); + assertArraysEquals(r, a, b, IntVector64Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6766,7 +6766,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqInt64VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqIntVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6779,7 +6779,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Int64VectorTests::beq); + assertArraysEquals(r, a, b, IntVector64Tests::beq); } static boolean unot(boolean a) { @@ -6787,7 +6787,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotInt64VectorTests(IntFunction fa) { + static void masknotIntVector64Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6798,7 +6798,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Int64VectorTests::unot); + assertArraysEquals(r, a, IntVector64Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6815,7 +6815,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongInt64VectorTests(IntFunction fa) { + static void maskFromToLongIntVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6829,7 +6829,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltInt64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltIntVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6845,7 +6845,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqIntVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6861,7 +6861,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toIntArrayInt64VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayIntVector64TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6872,7 +6872,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toLongArrayInt64VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayIntVector64TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6883,7 +6883,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toDoubleArrayInt64VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayIntVector64TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6894,7 +6894,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toStringInt64VectorTestsSmokeTest(IntFunction fa) { + static void toStringIntVector64TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6907,7 +6907,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void hashCodeInt64VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeIntVector64TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6940,7 +6940,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceLongInt64VectorTests(IntFunction fa) { + static void ADDReduceLongIntVector64Tests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6956,7 +6956,7 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Int64VectorTests::ADDReduceLong, Int64VectorTests::ADDReduceAllLong); + IntVector64Tests::ADDReduceLong, IntVector64Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) { @@ -6979,7 +6979,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceLongInt64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongIntVector64TestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6997,11 +6997,11 @@ public class Int64VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Int64VectorTests::ADDReduceLongMasked, Int64VectorTests::ADDReduceAllLongMasked); + IntVector64Tests::ADDReduceLongMasked, IntVector64Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastLongInt64VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongIntVector64TestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7012,7 +7012,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendInt64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendIntVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -7026,12 +7026,12 @@ public class Int64VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVector64Tests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void SelectFromInt64VectorTests(IntFunction fa, + static void SelectFromIntVector64Tests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -7047,7 +7047,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorInt64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorIntVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] idx = fc.apply(SPECIES.length()); @@ -7065,7 +7065,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void SelectFromInt64VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromIntVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -7084,7 +7084,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousInt64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousIntVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7100,7 +7100,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringInt64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringIntVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7114,7 +7114,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsInt64VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsIntVector64TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7128,7 +7128,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsInt64VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsIntVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7144,7 +7144,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeInt64VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeIntVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7166,7 +7166,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountInt64VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountIntVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7177,7 +7177,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, IntVector64Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7191,7 +7191,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueInt64VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueIntVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7202,7 +7202,7 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, IntVector64Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7216,7 +7216,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueInt64VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueIntVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7227,11 +7227,11 @@ public class Int64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, IntVector64Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressInt64VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressIntVector64TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7259,7 +7259,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeInt64VectorTestsSmokeTest(int offset) { + static void indexInRangeIntVector64TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7273,7 +7273,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongInt64VectorTestsSmokeTest(int offset) { + static void indexInRangeLongIntVector64TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7300,14 +7300,14 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundInt64VectorTestsSmokeTest(int length) { + static void loopBoundIntVector64TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongInt64VectorTestsSmokeTest(int _length) { + static void loopBoundLongIntVector64TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7315,21 +7315,21 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeInt64VectorTestsSmokeTest() { + static void ElementSizeIntVector64TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Integer.SIZE); } @Test - static void VectorShapeInt64VectorTestsSmokeTest() { + static void VectorShapeIntVector64TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_64_BIT)); } @Test - static void ShapeWithLanesInt64VectorTestsSmokeTest() { + static void ShapeWithLanesIntVector64TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(int.class); @@ -7337,32 +7337,32 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeInt64VectorTestsSmokeTest() { + static void ElementTypeIntVector64TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementType() == int.class); } @Test - static void SpeciesElementSizeInt64VectorTestsSmokeTest() { + static void SpeciesElementSizeIntVector64TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementSize() == Integer.SIZE); } @Test - static void VectorTypeInt64VectorTestsSmokeTest() { + static void VectorTypeIntVector64TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesInt64VectorTestsSmokeTest() { + static void WithLanesIntVector64TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(int.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeInt64VectorTestsSmokeTest() { + static void WithShapeIntVector64TestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7370,7 +7370,7 @@ public class Int64VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueInt64VectorTestsSmokeTest() { + static void MaskAllTrueIntVector64TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/IntMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/IntVectorMaxLoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/IntMaxVectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/IntVectorMaxLoadStoreTests.java index d72c428659f..c9adfe802b6 100644 --- a/test/jdk/jdk/incubator/vector/IntMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/IntVectorMaxLoadStoreTests.java @@ -28,7 +28,7 @@ * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation * @run testng/othervm --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED - * -XX:-TieredCompilation IntMaxVectorLoadStoreTests + * -XX:-TieredCompilation IntVectorMaxLoadStoreTests * */ @@ -52,7 +52,7 @@ import java.util.List; import java.util.function.*; @Test -public class IntMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class IntVectorMaxLoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = IntVector.SPECIES_MAX; diff --git a/test/jdk/jdk/incubator/vector/IntMaxVectorTests.java b/test/jdk/jdk/incubator/vector/IntVectorMaxTests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/IntMaxVectorTests.java rename to test/jdk/jdk/incubator/vector/IntVectorMaxTests.java index fc4cf4ea21e..ad519b36dc9 100644 --- a/test/jdk/jdk/incubator/vector/IntMaxVectorTests.java +++ b/test/jdk/jdk/incubator/vector/IntVectorMaxTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation IntMaxVectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation IntVectorMaxTests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class IntMaxVectorTests extends AbstractVectorTest { +public class IntVectorMaxTests extends AbstractVectorTest { static final VectorSpecies SPECIES = IntVector.SPECIES_MAX; @@ -1673,7 +1673,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ADDIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ADDIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1686,7 +1686,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::ADD); + assertArraysEquals(r, a, b, IntVectorMaxTests::ADD); } static int add(int a, int b) { @@ -1694,7 +1694,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void addIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void addIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1705,11 +1705,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, IntMaxVectorTests::add); + assertArraysEquals(r, a, b, IntVectorMaxTests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1725,11 +1725,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::ADD); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void addIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1743,7 +1743,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::add); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::add); } static int SUB(int a, int b) { @@ -1751,7 +1751,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void SUBIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUBIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1764,7 +1764,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::SUB); + assertArraysEquals(r, a, b, IntVectorMaxTests::SUB); } static int sub(int a, int b) { @@ -1772,7 +1772,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void subIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void subIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1783,11 +1783,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, IntMaxVectorTests::sub); + assertArraysEquals(r, a, b, IntVectorMaxTests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void SUBIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1803,11 +1803,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SUB); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::SUB); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void subIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1821,7 +1821,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::sub); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::sub); } static int MUL(int a, int b) { @@ -1829,7 +1829,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MULIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MULIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1842,7 +1842,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::MUL); + assertArraysEquals(r, a, b, IntVectorMaxTests::MUL); } static int mul(int a, int b) { @@ -1850,7 +1850,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void mulIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void mulIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1861,11 +1861,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, IntMaxVectorTests::mul); + assertArraysEquals(r, a, b, IntVectorMaxTests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void MULIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1881,11 +1881,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::MUL); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::MUL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1899,7 +1899,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::mul); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::mul); } static int DIV(int a, int b) { @@ -1907,7 +1907,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void DIVIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void DIVIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1922,7 +1922,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::DIV); + assertArraysEquals(r, a, b, IntVectorMaxTests::DIV); } static int div(int a, int b) { @@ -1930,7 +1930,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void divIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void divIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -1945,11 +1945,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::div); + assertArraysEquals(r, a, b, IntVectorMaxTests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void DIVIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1967,11 +1967,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::DIV); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::DIV); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void divIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -1989,7 +1989,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::div); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::div); } static int FIRST_NONZERO(int a, int b) { @@ -1997,7 +1997,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void FIRST_NONZEROIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2010,11 +2010,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, IntVectorMaxTests::FIRST_NONZERO); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void FIRST_NONZEROIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2030,7 +2030,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::FIRST_NONZERO); } static int AND(int a, int b) { @@ -2038,7 +2038,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ANDIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ANDIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2051,7 +2051,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::AND); + assertArraysEquals(r, a, b, IntVectorMaxTests::AND); } static int and(int a, int b) { @@ -2059,7 +2059,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void andIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void andIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2070,11 +2070,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, IntMaxVectorTests::and); + assertArraysEquals(r, a, b, IntVectorMaxTests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2090,7 +2090,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::AND); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::AND); } static int AND_NOT(int a, int b) { @@ -2098,7 +2098,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void AND_NOTIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2111,11 +2111,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::AND_NOT); + assertArraysEquals(r, a, b, IntVectorMaxTests::AND_NOT); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void AND_NOTIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2131,7 +2131,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::AND_NOT); } static int OR(int a, int b) { @@ -2139,7 +2139,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ORIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ORIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2152,7 +2152,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::OR); + assertArraysEquals(r, a, b, IntVectorMaxTests::OR); } static int or(int a, int b) { @@ -2160,7 +2160,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void orIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void orIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2171,11 +2171,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, IntMaxVectorTests::or); + assertArraysEquals(r, a, b, IntVectorMaxTests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2191,7 +2191,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::OR); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::OR); } static int XOR(int a, int b) { @@ -2199,7 +2199,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void XORIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void XORIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2212,11 +2212,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::XOR); + assertArraysEquals(r, a, b, IntVectorMaxTests::XOR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void XORIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2232,7 +2232,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::XOR); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::XOR); } static int COMPRESS_BITS(int a, int b) { @@ -2240,7 +2240,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void COMPRESS_BITSIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2253,11 +2253,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, IntVectorMaxTests::COMPRESS_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void COMPRESS_BITSIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2273,7 +2273,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::COMPRESS_BITS); } static int EXPAND_BITS(int a, int b) { @@ -2281,7 +2281,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void EXPAND_BITSIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2294,11 +2294,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, IntVectorMaxTests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void EXPAND_BITSIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2314,11 +2314,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::EXPAND_BITS); } @Test(dataProvider = "intBinaryOpProvider") - static void addIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2328,11 +2328,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::add); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void addIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2345,11 +2345,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, IntVectorMaxTests::add); } @Test(dataProvider = "intBinaryOpProvider") - static void subIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2359,11 +2359,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::sub); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void subIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2376,11 +2376,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, IntVectorMaxTests::sub); } @Test(dataProvider = "intBinaryOpProvider") - static void mulIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2390,11 +2390,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::mul); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void mulIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2407,11 +2407,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, IntVectorMaxTests::mul); } @Test(dataProvider = "intBinaryOpProvider") - static void divIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2423,11 +2423,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::div); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void divIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2442,11 +2442,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, IntVectorMaxTests::div); } @Test(dataProvider = "intBinaryOpProvider") - static void ORIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2456,11 +2456,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::OR); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void orIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2470,11 +2470,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::or); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::or); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2487,11 +2487,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, IntVectorMaxTests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ANDIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2501,11 +2501,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::AND); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void andIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2515,11 +2515,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::and); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::and); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ANDIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2532,11 +2532,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, IntVectorMaxTests::AND); } @Test(dataProvider = "intBinaryOpProvider") - static void ORIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORIntVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2546,11 +2546,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, IntMaxVectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, IntVectorMaxTests::OR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ORIntMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORIntVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2563,11 +2563,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, IntMaxVectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVectorMaxTests::OR); } @Test(dataProvider = "intBinaryOpProvider") - static void ADDIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDIntVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2577,11 +2577,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, IntMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, IntVectorMaxTests::ADD); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ADDIntMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDIntVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2594,7 +2594,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, IntMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVectorMaxTests::ADD); } static int LSHL(int a, int b) { @@ -2602,7 +2602,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LSHLIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2615,11 +2615,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::LSHL); + assertArraysEquals(r, a, b, IntVectorMaxTests::LSHL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2635,7 +2635,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::LSHL); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::LSHL); } static int ASHR(int a, int b) { @@ -2643,7 +2643,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ASHRIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2656,11 +2656,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::ASHR); + assertArraysEquals(r, a, b, IntVectorMaxTests::ASHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2676,7 +2676,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::ASHR); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::ASHR); } static int LSHR(int a, int b) { @@ -2684,7 +2684,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LSHRIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2697,11 +2697,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::LSHR); + assertArraysEquals(r, a, b, IntVectorMaxTests::LSHR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2717,7 +2717,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::LSHR); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::LSHR); } static int LSHL_unary(int a, int b) { @@ -2725,7 +2725,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHLIntMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLIntVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2737,11 +2737,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, IntMaxVectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, IntVectorMaxTests::LSHL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHLIntMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLIntVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2756,7 +2756,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVectorMaxTests::LSHL_unary); } static int LSHR_unary(int a, int b) { @@ -2764,7 +2764,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void LSHRIntMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRIntVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2776,11 +2776,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, IntMaxVectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, IntVectorMaxTests::LSHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void LSHRIntMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRIntVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2795,7 +2795,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVectorMaxTests::LSHR_unary); } static int ASHR_unary(int a, int b) { @@ -2803,7 +2803,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ASHRIntMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRIntVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2815,11 +2815,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, IntMaxVectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, IntVectorMaxTests::ASHR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ASHRIntMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRIntVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2834,7 +2834,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVectorMaxTests::ASHR_unary); } static int ROR(int a, int b) { @@ -2842,7 +2842,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void RORIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2855,11 +2855,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::ROR); + assertArraysEquals(r, a, b, IntVectorMaxTests::ROR); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2875,7 +2875,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::ROR); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::ROR); } static int ROL(int a, int b) { @@ -2883,7 +2883,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ROLIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2896,11 +2896,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::ROL); + assertArraysEquals(r, a, b, IntVectorMaxTests::ROL); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2916,7 +2916,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::ROL); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::ROL); } static int ROR_unary(int a, int b) { @@ -2924,7 +2924,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void RORIntMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORIntVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2936,11 +2936,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, IntMaxVectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, IntVectorMaxTests::ROR_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void RORIntMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORIntVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2955,7 +2955,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, IntVectorMaxTests::ROR_unary); } static int ROL_unary(int a, int b) { @@ -2963,7 +2963,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void ROLIntMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLIntVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -2975,11 +2975,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, IntMaxVectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, IntVectorMaxTests::ROL_unary); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void ROLIntMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLIntVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -2994,14 +2994,14 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, IntVectorMaxTests::ROL_unary); } static int LSHR_binary_const(int a) { return (int)((a >>> CONST_SHIFT)); } @Test(dataProvider = "intUnaryOpProvider") - static void LSHRIntMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRIntVectorMaxTestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3012,11 +3012,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, IntMaxVectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, IntVectorMaxTests::LSHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHRIntMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRIntVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3030,7 +3030,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, IntMaxVectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVectorMaxTests::LSHR_binary_const); } static int LSHL_binary_const(int a) { @@ -3038,7 +3038,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LSHLIntMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLIntVectorMaxTestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3049,11 +3049,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, IntMaxVectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, IntVectorMaxTests::LSHL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LSHLIntMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLIntVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3067,7 +3067,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, IntMaxVectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, IntVectorMaxTests::LSHL_binary_const); } static int ASHR_binary_const(int a) { @@ -3075,7 +3075,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ASHRIntMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRIntVectorMaxTestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3086,11 +3086,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, IntMaxVectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, IntVectorMaxTests::ASHR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ASHRIntMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRIntVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3104,7 +3104,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, IntMaxVectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, IntVectorMaxTests::ASHR_binary_const); } static int ROR_binary_const(int a) { @@ -3112,7 +3112,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void RORIntMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void RORIntVectorMaxTestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3123,11 +3123,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, IntMaxVectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, IntVectorMaxTests::ROR_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void RORIntMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORIntVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3141,7 +3141,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, IntMaxVectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, IntVectorMaxTests::ROR_binary_const); } static int ROL_binary_const(int a) { @@ -3149,7 +3149,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ROLIntMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void ROLIntVectorMaxTestsScalarShiftConst(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3160,11 +3160,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, IntMaxVectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, IntVectorMaxTests::ROL_binary_const); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ROLIntMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLIntVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3178,14 +3178,14 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, IntMaxVectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, IntVectorMaxTests::ROL_binary_const); } static IntVector bv_MIN = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MINIntMaxVectorTestsWithMemOp(IntFunction fa) { + static void MINIntVectorMaxTestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3196,13 +3196,13 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, IntMaxVectorTests::MIN); + assertArraysEquals(r, a, (int)10, IntVectorMaxTests::MIN); } static IntVector bv_min = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void minIntMaxVectorTestsWithMemOp(IntFunction fa) { + static void minIntVectorMaxTestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3213,13 +3213,13 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, IntMaxVectorTests::min); + assertArraysEquals(r, a, (int)10, IntVectorMaxTests::min); } static IntVector bv_MIN_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINIntMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINIntVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3232,13 +3232,13 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, IntMaxVectorTests::MIN); + assertArraysEquals(r, a, (int)10, mask, IntVectorMaxTests::MIN); } static IntVector bv_MAX = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void MAXIntMaxVectorTestsWithMemOp(IntFunction fa) { + static void MAXIntVectorMaxTestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3249,13 +3249,13 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, IntMaxVectorTests::MAX); + assertArraysEquals(r, a, (int)10, IntVectorMaxTests::MAX); } static IntVector bv_max = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpProvider") - static void maxIntMaxVectorTestsWithMemOp(IntFunction fa) { + static void maxIntVectorMaxTestsWithMemOp(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3266,13 +3266,13 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, IntMaxVectorTests::max); + assertArraysEquals(r, a, (int)10, IntVectorMaxTests::max); } static IntVector bv_MAX_M = IntVector.broadcast(SPECIES, (int)10); @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXIntMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXIntVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3285,7 +3285,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (int)10, mask, IntMaxVectorTests::MAX); + assertArraysEquals(r, a, (int)10, mask, IntVectorMaxTests::MAX); } static int MIN(int a, int b) { @@ -3293,7 +3293,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MINIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MINIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3306,7 +3306,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::MIN); + assertArraysEquals(r, a, b, IntVectorMaxTests::MIN); } static int min(int a, int b) { @@ -3314,7 +3314,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void minIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void minIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3325,7 +3325,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, IntMaxVectorTests::min); + assertArraysEquals(r, a, b, IntVectorMaxTests::min); } static int MAX(int a, int b) { @@ -3333,7 +3333,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void MAXIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MAXIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3346,7 +3346,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::MAX); + assertArraysEquals(r, a, b, IntVectorMaxTests::MAX); } static int max(int a, int b) { @@ -3354,7 +3354,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void maxIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maxIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3365,7 +3365,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, IntMaxVectorTests::max); + assertArraysEquals(r, a, b, IntVectorMaxTests::max); } static int UMIN(int a, int b) { @@ -3373,7 +3373,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMINIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UMINIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3386,11 +3386,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::UMIN); + assertArraysEquals(r, a, b, IntVectorMaxTests::UMIN); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMINIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3406,7 +3406,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::UMIN); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::UMIN); } static int UMAX(int a, int b) { @@ -3414,7 +3414,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void UMAXIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UMAXIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3427,11 +3427,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::UMAX); + assertArraysEquals(r, a, b, IntVectorMaxTests::UMAX); } @Test(dataProvider = "intBinaryOpMaskProvider") - static void UMAXIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3447,7 +3447,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::UMAX); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::UMAX); } static int SADD(int a, int b) { @@ -3455,7 +3455,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SADDIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SADDIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3468,11 +3468,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::SADD); + assertArraysEquals(r, a, b, IntVectorMaxTests::SADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SADDIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3488,7 +3488,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SADD); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::SADD); } static int SSUB(int a, int b) { @@ -3496,7 +3496,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SSUBIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SSUBIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3509,11 +3509,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::SSUB); + assertArraysEquals(r, a, b, IntVectorMaxTests::SSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SSUBIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3529,7 +3529,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SSUB); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::SSUB); } static int SUADD(int a, int b) { @@ -3537,7 +3537,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUADDIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUADDIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3550,11 +3550,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::SUADD); + assertArraysEquals(r, a, b, IntVectorMaxTests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUADDIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3570,7 +3570,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SUADD); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::SUADD); } static int SUSUB(int a, int b) { @@ -3578,7 +3578,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingBinaryOpProvider") - static void SUSUBIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3591,11 +3591,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::SUSUB); + assertArraysEquals(r, a, b, IntVectorMaxTests::SUSUB); } @Test(dataProvider = "intSaturatingBinaryOpMaskProvider") - static void SUSUBIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3611,11 +3611,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::SUSUB); } @Test(dataProvider = "intBinaryOpProvider") - static void MINIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3625,11 +3625,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::MIN); } @Test(dataProvider = "intBinaryOpProvider") - static void minIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3639,11 +3639,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::min); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::min); } @Test(dataProvider = "intBinaryOpProvider") - static void MAXIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3653,11 +3653,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::MAX); } @Test(dataProvider = "intBinaryOpProvider") - static void maxIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -3667,10 +3667,10 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::max); + assertBroadcastArraysEquals(r, a, b, IntVectorMaxTests::max); } @Test(dataProvider = "intSaturatingBinaryOpAssocProvider") - static void SUADDAssocIntMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocIntVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -3687,11 +3687,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, IntMaxVectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, IntVectorMaxTests::SUADD); } @Test(dataProvider = "intSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -3712,7 +3712,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, IntMaxVectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, IntVectorMaxTests::SUADD); } static int ANDReduce(int[] a, int idx) { @@ -3734,7 +3734,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ANDReduceIntMaxVectorTests(IntFunction fa) { + static void ANDReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3750,7 +3750,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::ANDReduce, IntMaxVectorTests::ANDReduceAll); + IntVectorMaxTests::ANDReduce, IntVectorMaxTests::ANDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3796,7 +3796,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ANDReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3814,7 +3814,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::ANDReduceMasked, IntMaxVectorTests::ANDReduceAllMasked); + IntVectorMaxTests::ANDReduceMasked, IntVectorMaxTests::ANDReduceAllMasked); } static int ORReduce(int[] a, int idx) { @@ -3836,7 +3836,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ORReduceIntMaxVectorTests(IntFunction fa) { + static void ORReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3852,7 +3852,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::ORReduce, IntMaxVectorTests::ORReduceAll); + IntVectorMaxTests::ORReduce, IntVectorMaxTests::ORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -3898,7 +3898,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ORReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3916,7 +3916,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::ORReduceMasked, IntMaxVectorTests::ORReduceAllMasked); + IntVectorMaxTests::ORReduceMasked, IntVectorMaxTests::ORReduceAllMasked); } static int XORReduce(int[] a, int idx) { @@ -3938,7 +3938,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void XORReduceIntMaxVectorTests(IntFunction fa) { + static void XORReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -3954,7 +3954,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::XORReduce, IntMaxVectorTests::XORReduceAll); + IntVectorMaxTests::XORReduce, IntVectorMaxTests::XORReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4000,7 +4000,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void XORReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4018,7 +4018,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::XORReduceMasked, IntMaxVectorTests::XORReduceAllMasked); + IntVectorMaxTests::XORReduceMasked, IntVectorMaxTests::XORReduceAllMasked); } static int ADDReduce(int[] a, int idx) { @@ -4040,7 +4040,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceIntMaxVectorTests(IntFunction fa) { + static void ADDReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4056,7 +4056,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::ADDReduce, IntMaxVectorTests::ADDReduceAll); + IntVectorMaxTests::ADDReduce, IntVectorMaxTests::ADDReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4102,7 +4102,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4120,7 +4120,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::ADDReduceMasked, IntMaxVectorTests::ADDReduceAllMasked); + IntVectorMaxTests::ADDReduceMasked, IntVectorMaxTests::ADDReduceAllMasked); } static int MULReduce(int[] a, int idx) { @@ -4142,7 +4142,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MULReduceIntMaxVectorTests(IntFunction fa) { + static void MULReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4158,7 +4158,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::MULReduce, IntMaxVectorTests::MULReduceAll); + IntVectorMaxTests::MULReduce, IntVectorMaxTests::MULReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4204,7 +4204,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MULReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4222,7 +4222,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::MULReduceMasked, IntMaxVectorTests::MULReduceAllMasked); + IntVectorMaxTests::MULReduceMasked, IntVectorMaxTests::MULReduceAllMasked); } static int MINReduce(int[] a, int idx) { @@ -4244,7 +4244,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MINReduceIntMaxVectorTests(IntFunction fa) { + static void MINReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4260,7 +4260,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::MINReduce, IntMaxVectorTests::MINReduceAll); + IntVectorMaxTests::MINReduce, IntVectorMaxTests::MINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4306,7 +4306,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MINReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4324,7 +4324,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::MINReduceMasked, IntMaxVectorTests::MINReduceAllMasked); + IntVectorMaxTests::MINReduceMasked, IntVectorMaxTests::MINReduceAllMasked); } static int MAXReduce(int[] a, int idx) { @@ -4346,7 +4346,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void MAXReduceIntMaxVectorTests(IntFunction fa) { + static void MAXReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4362,7 +4362,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::MAXReduce, IntMaxVectorTests::MAXReduceAll); + IntVectorMaxTests::MAXReduce, IntVectorMaxTests::MAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4408,7 +4408,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void MAXReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4426,7 +4426,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::MAXReduceMasked, IntMaxVectorTests::MAXReduceAllMasked); + IntVectorMaxTests::MAXReduceMasked, IntVectorMaxTests::MAXReduceAllMasked); } static int UMINReduce(int[] a, int idx) { @@ -4448,7 +4448,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMINReduceIntMaxVectorTests(IntFunction fa) { + static void UMINReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4464,7 +4464,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::UMINReduce, IntMaxVectorTests::UMINReduceAll); + IntVectorMaxTests::UMINReduce, IntVectorMaxTests::UMINReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4510,7 +4510,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMINReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4528,7 +4528,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::UMINReduceMasked, IntMaxVectorTests::UMINReduceAllMasked); + IntVectorMaxTests::UMINReduceMasked, IntVectorMaxTests::UMINReduceAllMasked); } static int UMAXReduce(int[] a, int idx) { @@ -4550,7 +4550,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void UMAXReduceIntMaxVectorTests(IntFunction fa) { + static void UMAXReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4566,7 +4566,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::UMAXReduce, IntMaxVectorTests::UMAXReduceAll); + IntVectorMaxTests::UMAXReduce, IntVectorMaxTests::UMAXReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4612,7 +4612,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void UMAXReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4630,7 +4630,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::UMAXReduceMasked, IntMaxVectorTests::UMAXReduceAllMasked); + IntVectorMaxTests::UMAXReduceMasked, IntVectorMaxTests::UMAXReduceAllMasked); } static int FIRST_NONZEROReduce(int[] a, int idx) { @@ -4652,7 +4652,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void FIRST_NONZEROReduceIntMaxVectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4668,7 +4668,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::FIRST_NONZEROReduce, IntMaxVectorTests::FIRST_NONZEROReduceAll); + IntVectorMaxTests::FIRST_NONZEROReduce, IntVectorMaxTests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "intUnaryOpProvider") @@ -4714,7 +4714,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void FIRST_NONZEROReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4732,7 +4732,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::FIRST_NONZEROReduceMasked, IntMaxVectorTests::FIRST_NONZEROReduceAllMasked); + IntVectorMaxTests::FIRST_NONZEROReduceMasked, IntVectorMaxTests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4745,7 +4745,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueIntMaxVectorTests(IntFunction fm) { + static void anyTrueIntVectorMaxTests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4756,7 +4756,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, IntMaxVectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, IntVectorMaxTests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4769,7 +4769,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueIntMaxVectorTests(IntFunction fm) { + static void allTrueIntVectorMaxTests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4780,7 +4780,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, IntMaxVectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, IntVectorMaxTests::allTrue); } static int SUADDReduce(int[] a, int idx) { @@ -4802,7 +4802,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSaturatingUnaryOpProvider") - static void SUADDReduceIntMaxVectorTests(IntFunction fa) { + static void SUADDReduceIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); int ra = 0; @@ -4818,7 +4818,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - IntMaxVectorTests::SUADDReduce, IntMaxVectorTests::SUADDReduceAll); + IntVectorMaxTests::SUADDReduce, IntVectorMaxTests::SUADDReduceAll); } @Test(dataProvider = "intSaturatingUnaryOpProvider") @@ -4863,7 +4863,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "intSaturatingUnaryOpMaskProvider") - static void SUADDReduceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4881,11 +4881,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::SUADDReduceMasked, IntMaxVectorTests::SUADDReduceAllMasked); + IntVectorMaxTests::SUADDReduceMasked, IntVectorMaxTests::SUADDReduceAllMasked); } @Test(dataProvider = "intBinaryOpProvider") - static void withIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void withIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -4908,7 +4908,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_DEFAULTIntMaxVectorTests(IntFunction fa) { + static void IS_DEFAULTIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4925,7 +4925,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_DEFAULTMaskedIntMaxVectorTests(IntFunction fa, + static void IS_DEFAULTMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4949,7 +4949,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpProvider") - static void IS_NEGATIVEIntMaxVectorTests(IntFunction fa) { + static void IS_NEGATIVEIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4966,7 +4966,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTestOpMaskProvider") - static void IS_NEGATIVEMaskedIntMaxVectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4986,7 +4986,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LTIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5005,7 +5005,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ltIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5024,7 +5024,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5047,7 +5047,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GTIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GTIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5066,7 +5066,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GTIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5089,7 +5089,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void EQIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5108,7 +5108,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void eqIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5127,7 +5127,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5150,7 +5150,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void NEIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void NEIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5169,7 +5169,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void NEIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5192,7 +5192,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LEIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LEIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5211,7 +5211,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LEIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5234,7 +5234,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void GEIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GEIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5253,7 +5253,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void GEIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5276,7 +5276,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULTIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ULTIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5295,7 +5295,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULTIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5318,7 +5318,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGTIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UGTIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5337,7 +5337,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGTIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5360,7 +5360,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ULEIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ULEIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5379,7 +5379,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void ULEIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5402,7 +5402,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void UGEIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UGEIntVectorMaxTests(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5421,7 +5421,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void UGEIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5444,7 +5444,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5460,7 +5460,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5480,7 +5480,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void LTIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTIntVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5496,7 +5496,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void LTIntMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTIntVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5516,7 +5516,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5532,7 +5532,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5552,7 +5552,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void EQIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQIntVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5568,7 +5568,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpMaskProvider") - static void EQIntMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQIntVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5592,7 +5592,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendIntMaxVectorTests(IntFunction fa, IntFunction fb, + static void blendIntVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5608,11 +5608,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, IntMaxVectorTests::blend); + assertArraysEquals(r, a, b, mask, IntVectorMaxTests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void RearrangeIntMaxVectorTests(IntFunction fa, + static void RearrangeIntVectorMaxTests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5629,7 +5629,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void RearrangeIntMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeIntVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -5647,7 +5647,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void compressIntMaxVectorTests(IntFunction fa, + static void compressIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5665,7 +5665,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void expandIntMaxVectorTests(IntFunction fa, + static void expandIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5683,7 +5683,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void getIntMaxVectorTests(IntFunction fa) { + static void getIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -5839,7 +5839,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastIntMaxVectorTests(IntFunction fa) { + static void BroadcastIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5853,7 +5853,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZeroIntMaxVectorTests(IntFunction fa) { + static void ZeroIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5878,7 +5878,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void sliceUnaryIntMaxVectorTests(IntFunction fa) { + static void sliceUnaryIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5889,7 +5889,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, IntMaxVectorTests::sliceUnary); + assertArraysEquals(r, a, origin, IntVectorMaxTests::sliceUnary); } static int[] sliceBinary(int[] a, int[] b, int origin, int idx) { @@ -5906,7 +5906,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void sliceBinaryIntMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryIntVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -5919,7 +5919,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, IntMaxVectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, IntVectorMaxTests::sliceBinary); } static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) { @@ -5936,7 +5936,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void sliceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -5953,7 +5953,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, IntMaxVectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, IntVectorMaxTests::slice); } static int[] unsliceUnary(int[] a, int origin, int idx) { @@ -5970,7 +5970,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void unsliceUnaryIntMaxVectorTests(IntFunction fa) { + static void unsliceUnaryIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5981,7 +5981,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, IntMaxVectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, IntVectorMaxTests::unsliceUnary); } static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) { @@ -6007,7 +6007,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpProvider") - static void unsliceBinaryIntMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryIntVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -6021,7 +6021,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, IntMaxVectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, IntVectorMaxTests::unsliceBinary); } static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) { @@ -6061,7 +6061,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void unsliceIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6078,7 +6078,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, IntMaxVectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, IntVectorMaxTests::unslice); } static int BITWISE_BLEND(int a, int b, int c) { @@ -6090,7 +6090,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDIntMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6105,11 +6105,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, IntMaxVectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, IntVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendIntMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6122,11 +6122,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, IntMaxVectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, IntVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDIntMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6144,11 +6144,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, IntMaxVectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, IntVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6159,11 +6159,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, IntVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDIntMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6174,11 +6174,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, IntVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6189,11 +6189,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { IntVector bv = IntVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, IntVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendIntMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6204,11 +6204,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { IntVector cv = IntVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, IntVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6223,11 +6223,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, IntMaxVectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, IntVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDIntMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVectorMaxTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6242,11 +6242,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, IntMaxVectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, IntVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void BITWISE_BLENDIntMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDIntVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6257,11 +6257,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "intTernaryOpProvider") - static void bitwiseBlendIntMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendIntVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] c = fc.apply(SPECIES.length()); @@ -6272,11 +6272,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, IntVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "intTernaryOpMaskProvider") - static void BITWISE_BLENDIntMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDIntVectorMaxTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6290,7 +6290,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, IntMaxVectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, IntVectorMaxTests::BITWISE_BLEND); } static int NEG(int a) { @@ -6302,7 +6302,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NEGIntMaxVectorTests(IntFunction fa) { + static void NEGIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6313,11 +6313,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::NEG); + assertArraysEquals(r, a, IntVectorMaxTests::NEG); } @Test(dataProvider = "intUnaryOpProvider") - static void negIntMaxVectorTests(IntFunction fa) { + static void negIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6328,11 +6328,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::neg); + assertArraysEquals(r, a, IntVectorMaxTests::neg); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NEGMaskedIntMaxVectorTests(IntFunction fa, + static void NEGMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6346,7 +6346,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::NEG); + assertArraysEquals(r, a, mask, IntVectorMaxTests::NEG); } static int ABS(int a) { @@ -6358,7 +6358,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ABSIntMaxVectorTests(IntFunction fa) { + static void ABSIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6369,11 +6369,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::ABS); + assertArraysEquals(r, a, IntVectorMaxTests::ABS); } @Test(dataProvider = "intUnaryOpProvider") - static void absIntMaxVectorTests(IntFunction fa) { + static void absIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6384,11 +6384,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::abs); + assertArraysEquals(r, a, IntVectorMaxTests::abs); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ABSMaskedIntMaxVectorTests(IntFunction fa, + static void ABSMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6402,7 +6402,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::ABS); + assertArraysEquals(r, a, mask, IntVectorMaxTests::ABS); } static int NOT(int a) { @@ -6414,7 +6414,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void NOTIntMaxVectorTests(IntFunction fa) { + static void NOTIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6425,11 +6425,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::NOT); + assertArraysEquals(r, a, IntVectorMaxTests::NOT); } @Test(dataProvider = "intUnaryOpProvider") - static void notIntMaxVectorTests(IntFunction fa) { + static void notIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6440,11 +6440,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::not); + assertArraysEquals(r, a, IntVectorMaxTests::not); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void NOTMaskedIntMaxVectorTests(IntFunction fa, + static void NOTMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6458,7 +6458,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::NOT); + assertArraysEquals(r, a, mask, IntVectorMaxTests::NOT); } static int ZOMO(int a) { @@ -6466,7 +6466,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ZOMOIntMaxVectorTests(IntFunction fa) { + static void ZOMOIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6477,11 +6477,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::ZOMO); + assertArraysEquals(r, a, IntVectorMaxTests::ZOMO); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ZOMOMaskedIntMaxVectorTests(IntFunction fa, + static void ZOMOMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6495,7 +6495,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::ZOMO); + assertArraysEquals(r, a, mask, IntVectorMaxTests::ZOMO); } static int BIT_COUNT(int a) { @@ -6503,7 +6503,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void BIT_COUNTIntMaxVectorTests(IntFunction fa) { + static void BIT_COUNTIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6514,11 +6514,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::BIT_COUNT); + assertArraysEquals(r, a, IntVectorMaxTests::BIT_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void BIT_COUNTMaskedIntMaxVectorTests(IntFunction fa, + static void BIT_COUNTMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6532,7 +6532,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, IntVectorMaxTests::BIT_COUNT); } static int TRAILING_ZEROS_COUNT(int a) { @@ -6540,7 +6540,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void TRAILING_ZEROS_COUNTIntMaxVectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6551,11 +6551,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVectorMaxTests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedIntMaxVectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6569,7 +6569,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVectorMaxTests::TRAILING_ZEROS_COUNT); } static int LEADING_ZEROS_COUNT(int a) { @@ -6577,7 +6577,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void LEADING_ZEROS_COUNTIntMaxVectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6588,11 +6588,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, IntVectorMaxTests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedIntMaxVectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6606,7 +6606,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, IntVectorMaxTests::LEADING_ZEROS_COUNT); } static int REVERSE(int a) { @@ -6614,7 +6614,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSEIntMaxVectorTests(IntFunction fa) { + static void REVERSEIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6625,11 +6625,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::REVERSE); + assertArraysEquals(r, a, IntVectorMaxTests::REVERSE); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSEMaskedIntMaxVectorTests(IntFunction fa, + static void REVERSEMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6643,7 +6643,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::REVERSE); + assertArraysEquals(r, a, mask, IntVectorMaxTests::REVERSE); } static int REVERSE_BYTES(int a) { @@ -6651,7 +6651,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void REVERSE_BYTESIntMaxVectorTests(IntFunction fa) { + static void REVERSE_BYTESIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6662,11 +6662,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, IntVectorMaxTests::REVERSE_BYTES); } @Test(dataProvider = "intUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedIntMaxVectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedIntVectorMaxTests(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] r = fr.apply(SPECIES.length()); @@ -6680,7 +6680,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, IntMaxVectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, IntVectorMaxTests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6688,7 +6688,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandIntVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6701,7 +6701,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::band); + assertArraysEquals(r, a, b, IntVectorMaxTests::band); } static boolean bor(boolean a, boolean b) { @@ -6709,7 +6709,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskorIntVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6722,7 +6722,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::bor); + assertArraysEquals(r, a, b, IntVectorMaxTests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6730,7 +6730,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskxorIntVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6743,7 +6743,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::bxor); + assertArraysEquals(r, a, b, IntVectorMaxTests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6751,7 +6751,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotIntVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6764,7 +6764,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::bandNot); + assertArraysEquals(r, a, b, IntVectorMaxTests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6772,7 +6772,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskeqIntVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6785,7 +6785,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, IntMaxVectorTests::beq); + assertArraysEquals(r, a, b, IntVectorMaxTests::beq); } static boolean unot(boolean a) { @@ -6793,7 +6793,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotIntMaxVectorTests(IntFunction fa) { + static void masknotIntVectorMaxTests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6804,7 +6804,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, IntMaxVectorTests::unot); + assertArraysEquals(r, a, IntVectorMaxTests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6821,7 +6821,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongIntMaxVectorTests(IntFunction fa) { + static void maskFromToLongIntVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6835,7 +6835,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void ltIntMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltIntVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6851,7 +6851,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intCompareOpProvider") - static void eqIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqIntVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -6867,7 +6867,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toIntArrayIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayIntVectorMaxTestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6878,7 +6878,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toLongArrayIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayIntVectorMaxTestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6889,7 +6889,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toDoubleArrayIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayIntVectorMaxTestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6900,7 +6900,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void toStringIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void toStringIntVectorMaxTestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6913,7 +6913,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void hashCodeIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void hashCodeIntVectorMaxTestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6946,7 +6946,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpProvider") - static void ADDReduceLongIntMaxVectorTests(IntFunction fa) { + static void ADDReduceLongIntVectorMaxTests(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6962,7 +6962,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - IntMaxVectorTests::ADDReduceLong, IntMaxVectorTests::ADDReduceAllLong); + IntVectorMaxTests::ADDReduceLong, IntVectorMaxTests::ADDReduceAllLong); } static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) { @@ -6985,7 +6985,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpMaskProvider") - static void ADDReduceLongIntMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongIntVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -7003,11 +7003,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - IntMaxVectorTests::ADDReduceLongMasked, IntMaxVectorTests::ADDReduceAllLongMasked); + IntVectorMaxTests::ADDReduceLongMasked, IntVectorMaxTests::ADDReduceAllLongMasked); } @Test(dataProvider = "intUnaryOpProvider") - static void BroadcastLongIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongIntVectorMaxTestsSmokeTest(IntFunction fa) { int[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7018,7 +7018,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intBinaryOpMaskProvider") - static void blendIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendIntVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); @@ -7032,12 +7032,12 @@ public class IntMaxVectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, IntMaxVectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, IntVectorMaxTests::blend); } @Test(dataProvider = "intUnaryOpShuffleProvider") - static void SelectFromIntMaxVectorTests(IntFunction fa, + static void SelectFromIntVectorMaxTests(IntFunction fa, BiFunction fs) { int[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -7053,7 +7053,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorIntMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorIntVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { int[] a = fa.apply(SPECIES.length()); int[] b = fb.apply(SPECIES.length()); int[] idx = fc.apply(SPECIES.length()); @@ -7071,7 +7071,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "intUnaryOpShuffleMaskProvider") - static void SelectFromIntMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromIntVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { int[] a = fa.apply(SPECIES.length()); @@ -7090,7 +7090,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousIntMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousIntVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7106,7 +7106,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringIntMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringIntVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7120,7 +7120,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsIntMaxVectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsIntVectorMaxTestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7134,7 +7134,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsIntMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsIntVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7150,7 +7150,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeIntVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7172,7 +7172,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountIntVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7183,7 +7183,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, IntMaxVectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, IntVectorMaxTests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7197,7 +7197,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueIntVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7208,7 +7208,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, IntMaxVectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, IntVectorMaxTests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7222,7 +7222,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueIntVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7233,11 +7233,11 @@ public class IntMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, IntMaxVectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, IntVectorMaxTests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressIntMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskCompressIntVectorMaxTestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7265,7 +7265,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeIntMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeIntVectorMaxTestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7279,7 +7279,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongIntMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeLongIntVectorMaxTestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7306,14 +7306,14 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundIntMaxVectorTestsSmokeTest(int length) { + static void loopBoundIntVectorMaxTestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongIntMaxVectorTestsSmokeTest(int _length) { + static void loopBoundLongIntVectorMaxTestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7321,21 +7321,21 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test - static void ElementSizeIntMaxVectorTestsSmokeTest() { + static void ElementSizeIntVectorMaxTestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Integer.SIZE); } @Test - static void VectorShapeIntMaxVectorTestsSmokeTest() { + static void VectorShapeIntVectorMaxTestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_Max_BIT)); } @Test - static void ShapeWithLanesIntMaxVectorTestsSmokeTest() { + static void ShapeWithLanesIntVectorMaxTestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(int.class); @@ -7343,32 +7343,32 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test - static void ElementTypeIntMaxVectorTestsSmokeTest() { + static void ElementTypeIntVectorMaxTestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementType() == int.class); } @Test - static void SpeciesElementSizeIntMaxVectorTestsSmokeTest() { + static void SpeciesElementSizeIntVectorMaxTestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().elementSize() == Integer.SIZE); } @Test - static void VectorTypeIntMaxVectorTestsSmokeTest() { + static void VectorTypeIntVectorMaxTestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesIntMaxVectorTestsSmokeTest() { + static void WithLanesIntVectorMaxTestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(int.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeIntMaxVectorTestsSmokeTest() { + static void WithShapeIntVectorMaxTestsSmokeTest() { IntVector av = IntVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7376,7 +7376,7 @@ public class IntMaxVectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueIntMaxVectorTestsSmokeTest() { + static void MaskAllTrueIntVectorMaxTestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Long128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/LongVector128LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Long128VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/LongVector128LoadStoreTests.java index 20df291542f..3aa9c93e0d7 100644 --- a/test/jdk/jdk/incubator/vector/Long128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/LongVector128LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Long128VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation LongVector128LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Long128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class LongVector128LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = LongVector.SPECIES_128; diff --git a/test/jdk/jdk/incubator/vector/Long128VectorTests.java b/test/jdk/jdk/incubator/vector/LongVector128Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Long128VectorTests.java rename to test/jdk/jdk/incubator/vector/LongVector128Tests.java index 9847f79fc04..1d3af1684b9 100644 --- a/test/jdk/jdk/incubator/vector/Long128VectorTests.java +++ b/test/jdk/jdk/incubator/vector/LongVector128Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Long128VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation LongVector128Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Long128VectorTests extends AbstractVectorTest { +public class LongVector128Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = LongVector.SPECIES_128; @@ -1683,7 +1683,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLong128VectorTests(IntFunction fa, IntFunction fb) { + static void ADDLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1696,7 +1696,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::ADD); + assertArraysEquals(r, a, b, LongVector128Tests::ADD); } static long add(long a, long b) { @@ -1704,7 +1704,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void addLong128VectorTests(IntFunction fa, IntFunction fb) { + static void addLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1715,11 +1715,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long128VectorTests::add); + assertArraysEquals(r, a, b, LongVector128Tests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1735,11 +1735,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::ADD); + assertArraysEquals(r, a, b, mask, LongVector128Tests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1753,7 +1753,7 @@ public class Long128VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long128VectorTests::add); + assertArraysEquals(r, a, b, mask, LongVector128Tests::add); } static long SUB(long a, long b) { @@ -1761,7 +1761,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void SUBLong128VectorTests(IntFunction fa, IntFunction fb) { + static void SUBLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1774,7 +1774,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::SUB); + assertArraysEquals(r, a, b, LongVector128Tests::SUB); } static long sub(long a, long b) { @@ -1782,7 +1782,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void subLong128VectorTests(IntFunction fa, IntFunction fb) { + static void subLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1793,11 +1793,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long128VectorTests::sub); + assertArraysEquals(r, a, b, LongVector128Tests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void SUBLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1813,11 +1813,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::SUB); + assertArraysEquals(r, a, b, mask, LongVector128Tests::SUB); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1831,7 +1831,7 @@ public class Long128VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long128VectorTests::sub); + assertArraysEquals(r, a, b, mask, LongVector128Tests::sub); } static long MUL(long a, long b) { @@ -1839,7 +1839,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MULLong128VectorTests(IntFunction fa, IntFunction fb) { + static void MULLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1852,7 +1852,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::MUL); + assertArraysEquals(r, a, b, LongVector128Tests::MUL); } static long mul(long a, long b) { @@ -1860,7 +1860,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void mulLong128VectorTests(IntFunction fa, IntFunction fb) { + static void mulLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1871,11 +1871,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long128VectorTests::mul); + assertArraysEquals(r, a, b, LongVector128Tests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void MULLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1891,11 +1891,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::MUL); + assertArraysEquals(r, a, b, mask, LongVector128Tests::MUL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1909,7 +1909,7 @@ public class Long128VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long128VectorTests::mul); + assertArraysEquals(r, a, b, mask, LongVector128Tests::mul); } static long DIV(long a, long b) { @@ -1917,7 +1917,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void DIVLong128VectorTests(IntFunction fa, IntFunction fb) { + static void DIVLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1932,7 +1932,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::DIV); + assertArraysEquals(r, a, b, LongVector128Tests::DIV); } static long div(long a, long b) { @@ -1940,7 +1940,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void divLong128VectorTests(IntFunction fa, IntFunction fb) { + static void divLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1955,11 +1955,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::div); + assertArraysEquals(r, a, b, LongVector128Tests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void DIVLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1977,11 +1977,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::DIV); + assertArraysEquals(r, a, b, mask, LongVector128Tests::DIV); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1999,7 +1999,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::div); + assertArraysEquals(r, a, b, mask, LongVector128Tests::div); } static long FIRST_NONZERO(long a, long b) { @@ -2007,7 +2007,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void FIRST_NONZEROLong128VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2020,11 +2020,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, LongVector128Tests::FIRST_NONZERO); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void FIRST_NONZEROLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2040,7 +2040,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, LongVector128Tests::FIRST_NONZERO); } static long AND(long a, long b) { @@ -2048,7 +2048,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLong128VectorTests(IntFunction fa, IntFunction fb) { + static void ANDLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2061,7 +2061,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::AND); + assertArraysEquals(r, a, b, LongVector128Tests::AND); } static long and(long a, long b) { @@ -2069,7 +2069,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void andLong128VectorTests(IntFunction fa, IntFunction fb) { + static void andLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2080,11 +2080,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long128VectorTests::and); + assertArraysEquals(r, a, b, LongVector128Tests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2100,7 +2100,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::AND); + assertArraysEquals(r, a, b, mask, LongVector128Tests::AND); } static long AND_NOT(long a, long b) { @@ -2108,7 +2108,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void AND_NOTLong128VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2121,11 +2121,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::AND_NOT); + assertArraysEquals(r, a, b, LongVector128Tests::AND_NOT); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void AND_NOTLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2141,7 +2141,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, LongVector128Tests::AND_NOT); } static long OR(long a, long b) { @@ -2149,7 +2149,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong128VectorTests(IntFunction fa, IntFunction fb) { + static void ORLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2162,7 +2162,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::OR); + assertArraysEquals(r, a, b, LongVector128Tests::OR); } static long or(long a, long b) { @@ -2170,7 +2170,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void orLong128VectorTests(IntFunction fa, IntFunction fb) { + static void orLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2181,11 +2181,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long128VectorTests::or); + assertArraysEquals(r, a, b, LongVector128Tests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2201,7 +2201,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::OR); + assertArraysEquals(r, a, b, mask, LongVector128Tests::OR); } static long XOR(long a, long b) { @@ -2209,7 +2209,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void XORLong128VectorTests(IntFunction fa, IntFunction fb) { + static void XORLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2222,11 +2222,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::XOR); + assertArraysEquals(r, a, b, LongVector128Tests::XOR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void XORLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2242,7 +2242,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::XOR); + assertArraysEquals(r, a, b, mask, LongVector128Tests::XOR); } static long COMPRESS_BITS(long a, long b) { @@ -2250,7 +2250,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void COMPRESS_BITSLong128VectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2263,11 +2263,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, LongVector128Tests::COMPRESS_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void COMPRESS_BITSLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2283,7 +2283,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, LongVector128Tests::COMPRESS_BITS); } static long EXPAND_BITS(long a, long b) { @@ -2291,7 +2291,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void EXPAND_BITSLong128VectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2304,11 +2304,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, LongVector128Tests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void EXPAND_BITSLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2324,11 +2324,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, LongVector128Tests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpProvider") - static void addLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2338,11 +2338,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2355,11 +2355,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, LongVector128Tests::add); } @Test(dataProvider = "longBinaryOpProvider") - static void subLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2369,11 +2369,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2386,11 +2386,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, LongVector128Tests::sub); } @Test(dataProvider = "longBinaryOpProvider") - static void mulLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2400,11 +2400,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, LongVector128Tests::mul); } @Test(dataProvider = "longBinaryOpProvider") - static void divLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2433,11 +2433,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2452,11 +2452,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, LongVector128Tests::div); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2466,11 +2466,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void orLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2480,11 +2480,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::or); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2497,11 +2497,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long128VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, LongVector128Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2511,11 +2511,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void andLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2525,11 +2525,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::and); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2542,11 +2542,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long128VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, LongVector128Tests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2556,11 +2556,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Long128VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, LongVector128Tests::OR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2573,11 +2573,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Long128VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVector128Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLong128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDLongVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2587,11 +2587,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Long128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, LongVector128Tests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLong128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDLongVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2604,7 +2604,7 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Long128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVector128Tests::ADD); } static long LSHL(long a, long b) { @@ -2612,7 +2612,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLong128VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2625,11 +2625,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::LSHL); + assertArraysEquals(r, a, b, LongVector128Tests::LSHL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2645,7 +2645,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, LongVector128Tests::LSHL); } static long ASHR(long a, long b) { @@ -2653,7 +2653,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLong128VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2666,11 +2666,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::ASHR); + assertArraysEquals(r, a, b, LongVector128Tests::ASHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2686,7 +2686,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, LongVector128Tests::ASHR); } static long LSHR(long a, long b) { @@ -2694,7 +2694,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLong128VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2707,11 +2707,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::LSHR); + assertArraysEquals(r, a, b, LongVector128Tests::LSHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2727,7 +2727,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, LongVector128Tests::LSHR); } static long LSHL_unary(long a, long b) { @@ -2735,7 +2735,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLong128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLLongVector128TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2747,11 +2747,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long128VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, LongVector128Tests::LSHL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLong128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2766,7 +2766,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long128VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector128Tests::LSHL_unary); } static long LSHR_unary(long a, long b) { @@ -2774,7 +2774,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLong128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRLongVector128TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2786,11 +2786,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long128VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, LongVector128Tests::LSHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLong128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2805,7 +2805,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long128VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector128Tests::LSHR_unary); } static long ASHR_unary(long a, long b) { @@ -2813,7 +2813,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLong128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRLongVector128TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2825,11 +2825,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long128VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, LongVector128Tests::ASHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLong128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2844,7 +2844,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long128VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector128Tests::ASHR_unary); } static long ROR(long a, long b) { @@ -2852,7 +2852,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLong128VectorTests(IntFunction fa, IntFunction fb) { + static void RORLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2865,11 +2865,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::ROR); + assertArraysEquals(r, a, b, LongVector128Tests::ROR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2885,7 +2885,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::ROR); + assertArraysEquals(r, a, b, mask, LongVector128Tests::ROR); } static long ROL(long a, long b) { @@ -2893,7 +2893,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLong128VectorTests(IntFunction fa, IntFunction fb) { + static void ROLLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2906,11 +2906,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::ROL); + assertArraysEquals(r, a, b, LongVector128Tests::ROL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2926,7 +2926,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::ROL); + assertArraysEquals(r, a, b, mask, LongVector128Tests::ROL); } static long ROR_unary(long a, long b) { @@ -2934,7 +2934,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLong128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORLongVector128TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2946,11 +2946,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long128VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, LongVector128Tests::ROR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLong128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORLongVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2965,7 +2965,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long128VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector128Tests::ROR_unary); } static long ROL_unary(long a, long b) { @@ -2973,7 +2973,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLong128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLLongVector128TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2985,11 +2985,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long128VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, LongVector128Tests::ROL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLong128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLLongVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3004,14 +3004,14 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long128VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector128Tests::ROL_unary); } static long LSHR_binary_const(long a) { return (long)((a >>> CONST_SHIFT)); } @Test(dataProvider = "longUnaryOpProvider") - static void LSHRLong128VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRLongVector128TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3022,11 +3022,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long128VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, LongVector128Tests::LSHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHRLong128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRLongVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3040,7 +3040,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long128VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector128Tests::LSHR_binary_const); } static long LSHL_binary_const(long a) { @@ -3048,7 +3048,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LSHLLong128VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLLongVector128TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3059,11 +3059,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long128VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, LongVector128Tests::LSHL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHLLong128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLLongVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3077,7 +3077,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long128VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, LongVector128Tests::LSHL_binary_const); } static long ASHR_binary_const(long a) { @@ -3085,7 +3085,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ASHRLong128VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRLongVector128TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3096,11 +3096,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long128VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, LongVector128Tests::ASHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ASHRLong128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRLongVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3114,7 +3114,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long128VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector128Tests::ASHR_binary_const); } static long ROR_binary_const(long a) { @@ -3122,7 +3122,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void RORLong128VectorTestsScalarShiftConst(IntFunction fa) { + static void RORLongVector128TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3133,11 +3133,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long128VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, LongVector128Tests::ROR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void RORLong128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORLongVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3151,7 +3151,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long128VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector128Tests::ROR_binary_const); } static long ROL_binary_const(long a) { @@ -3159,7 +3159,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ROLLong128VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLLongVector128TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3170,11 +3170,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long128VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, LongVector128Tests::ROL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ROLLong128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLLongVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3188,14 +3188,14 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long128VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, LongVector128Tests::ROL_binary_const); } static LongVector bv_MIN = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MINLong128VectorTestsWithMemOp(IntFunction fa) { + static void MINLongVector128TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3206,13 +3206,13 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long128VectorTests::MIN); + assertArraysEquals(r, a, (long)10, LongVector128Tests::MIN); } static LongVector bv_min = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void minLong128VectorTestsWithMemOp(IntFunction fa) { + static void minLongVector128TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3223,13 +3223,13 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long128VectorTests::min); + assertArraysEquals(r, a, (long)10, LongVector128Tests::min); } static LongVector bv_MIN_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINLong128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINLongVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3242,13 +3242,13 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, Long128VectorTests::MIN); + assertArraysEquals(r, a, (long)10, mask, LongVector128Tests::MIN); } static LongVector bv_MAX = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MAXLong128VectorTestsWithMemOp(IntFunction fa) { + static void MAXLongVector128TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3259,13 +3259,13 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long128VectorTests::MAX); + assertArraysEquals(r, a, (long)10, LongVector128Tests::MAX); } static LongVector bv_max = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void maxLong128VectorTestsWithMemOp(IntFunction fa) { + static void maxLongVector128TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3276,13 +3276,13 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long128VectorTests::max); + assertArraysEquals(r, a, (long)10, LongVector128Tests::max); } static LongVector bv_MAX_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXLong128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXLongVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3295,7 +3295,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, Long128VectorTests::MAX); + assertArraysEquals(r, a, (long)10, mask, LongVector128Tests::MAX); } static long MIN(long a, long b) { @@ -3303,7 +3303,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MINLong128VectorTests(IntFunction fa, IntFunction fb) { + static void MINLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3316,7 +3316,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::MIN); + assertArraysEquals(r, a, b, LongVector128Tests::MIN); } static long min(long a, long b) { @@ -3324,7 +3324,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void minLong128VectorTests(IntFunction fa, IntFunction fb) { + static void minLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3335,7 +3335,7 @@ public class Long128VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long128VectorTests::min); + assertArraysEquals(r, a, b, LongVector128Tests::min); } static long MAX(long a, long b) { @@ -3343,7 +3343,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLong128VectorTests(IntFunction fa, IntFunction fb) { + static void MAXLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3356,7 +3356,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::MAX); + assertArraysEquals(r, a, b, LongVector128Tests::MAX); } static long max(long a, long b) { @@ -3364,7 +3364,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void maxLong128VectorTests(IntFunction fa, IntFunction fb) { + static void maxLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3375,7 +3375,7 @@ public class Long128VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long128VectorTests::max); + assertArraysEquals(r, a, b, LongVector128Tests::max); } static long UMIN(long a, long b) { @@ -3383,7 +3383,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMINLong128VectorTests(IntFunction fa, IntFunction fb) { + static void UMINLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3396,11 +3396,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::UMIN); + assertArraysEquals(r, a, b, LongVector128Tests::UMIN); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMINLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3416,7 +3416,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, LongVector128Tests::UMIN); } static long UMAX(long a, long b) { @@ -3424,7 +3424,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMAXLong128VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3437,11 +3437,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::UMAX); + assertArraysEquals(r, a, b, LongVector128Tests::UMAX); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMAXLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3457,7 +3457,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, LongVector128Tests::UMAX); } static long SADD(long a, long b) { @@ -3465,7 +3465,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SADDLong128VectorTests(IntFunction fa, IntFunction fb) { + static void SADDLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3478,11 +3478,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::SADD); + assertArraysEquals(r, a, b, LongVector128Tests::SADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SADDLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3498,7 +3498,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::SADD); + assertArraysEquals(r, a, b, mask, LongVector128Tests::SADD); } static long SSUB(long a, long b) { @@ -3506,7 +3506,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SSUBLong128VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3519,11 +3519,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::SSUB); + assertArraysEquals(r, a, b, LongVector128Tests::SSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SSUBLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3539,7 +3539,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, LongVector128Tests::SSUB); } static long SUADD(long a, long b) { @@ -3547,7 +3547,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUADDLong128VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3560,11 +3560,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::SUADD); + assertArraysEquals(r, a, b, LongVector128Tests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUADDLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3580,7 +3580,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, LongVector128Tests::SUADD); } static long SUSUB(long a, long b) { @@ -3588,7 +3588,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUSUBLong128VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3601,11 +3601,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::SUSUB); + assertArraysEquals(r, a, b, LongVector128Tests::SUSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUSUBLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3621,11 +3621,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, LongVector128Tests::SUSUB); } @Test(dataProvider = "longBinaryOpProvider") - static void MINLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3635,11 +3635,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::MIN); } @Test(dataProvider = "longBinaryOpProvider") - static void minLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3649,11 +3649,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::min); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::min); } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3663,11 +3663,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::MAX); } @Test(dataProvider = "longBinaryOpProvider") - static void maxLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3677,10 +3677,10 @@ public class Long128VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long128VectorTests::max); + assertBroadcastArraysEquals(r, a, b, LongVector128Tests::max); } @Test(dataProvider = "longSaturatingBinaryOpAssocProvider") - static void SUADDAssocLong128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocLongVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -3697,11 +3697,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Long128VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, LongVector128Tests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3722,7 +3722,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Long128VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, LongVector128Tests::SUADD); } static long ANDReduce(long[] a, int idx) { @@ -3744,7 +3744,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ANDReduceLong128VectorTests(IntFunction fa) { + static void ANDReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3760,7 +3760,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::ANDReduce, Long128VectorTests::ANDReduceAll); + LongVector128Tests::ANDReduce, LongVector128Tests::ANDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3806,7 +3806,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ANDReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3824,7 +3824,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::ANDReduceMasked, Long128VectorTests::ANDReduceAllMasked); + LongVector128Tests::ANDReduceMasked, LongVector128Tests::ANDReduceAllMasked); } static long ORReduce(long[] a, int idx) { @@ -3846,7 +3846,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ORReduceLong128VectorTests(IntFunction fa) { + static void ORReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3862,7 +3862,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::ORReduce, Long128VectorTests::ORReduceAll); + LongVector128Tests::ORReduce, LongVector128Tests::ORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3908,7 +3908,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ORReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3926,7 +3926,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::ORReduceMasked, Long128VectorTests::ORReduceAllMasked); + LongVector128Tests::ORReduceMasked, LongVector128Tests::ORReduceAllMasked); } static long XORReduce(long[] a, int idx) { @@ -3948,7 +3948,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void XORReduceLong128VectorTests(IntFunction fa) { + static void XORReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3964,7 +3964,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::XORReduce, Long128VectorTests::XORReduceAll); + LongVector128Tests::XORReduce, LongVector128Tests::XORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4010,7 +4010,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void XORReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4028,7 +4028,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::XORReduceMasked, Long128VectorTests::XORReduceAllMasked); + LongVector128Tests::XORReduceMasked, LongVector128Tests::XORReduceAllMasked); } static long ADDReduce(long[] a, int idx) { @@ -4050,7 +4050,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLong128VectorTests(IntFunction fa) { + static void ADDReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4066,7 +4066,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::ADDReduce, Long128VectorTests::ADDReduceAll); + LongVector128Tests::ADDReduce, LongVector128Tests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4112,7 +4112,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4130,7 +4130,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::ADDReduceMasked, Long128VectorTests::ADDReduceAllMasked); + LongVector128Tests::ADDReduceMasked, LongVector128Tests::ADDReduceAllMasked); } static long MULReduce(long[] a, int idx) { @@ -4152,7 +4152,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MULReduceLong128VectorTests(IntFunction fa) { + static void MULReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4168,7 +4168,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::MULReduce, Long128VectorTests::MULReduceAll); + LongVector128Tests::MULReduce, LongVector128Tests::MULReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4214,7 +4214,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MULReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4232,7 +4232,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::MULReduceMasked, Long128VectorTests::MULReduceAllMasked); + LongVector128Tests::MULReduceMasked, LongVector128Tests::MULReduceAllMasked); } static long MINReduce(long[] a, int idx) { @@ -4254,7 +4254,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MINReduceLong128VectorTests(IntFunction fa) { + static void MINReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4270,7 +4270,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::MINReduce, Long128VectorTests::MINReduceAll); + LongVector128Tests::MINReduce, LongVector128Tests::MINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4316,7 +4316,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4334,7 +4334,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::MINReduceMasked, Long128VectorTests::MINReduceAllMasked); + LongVector128Tests::MINReduceMasked, LongVector128Tests::MINReduceAllMasked); } static long MAXReduce(long[] a, int idx) { @@ -4356,7 +4356,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MAXReduceLong128VectorTests(IntFunction fa) { + static void MAXReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4372,7 +4372,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::MAXReduce, Long128VectorTests::MAXReduceAll); + LongVector128Tests::MAXReduce, LongVector128Tests::MAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4418,7 +4418,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4436,7 +4436,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::MAXReduceMasked, Long128VectorTests::MAXReduceAllMasked); + LongVector128Tests::MAXReduceMasked, LongVector128Tests::MAXReduceAllMasked); } static long UMINReduce(long[] a, int idx) { @@ -4458,7 +4458,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMINReduceLong128VectorTests(IntFunction fa) { + static void UMINReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4474,7 +4474,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::UMINReduce, Long128VectorTests::UMINReduceAll); + LongVector128Tests::UMINReduce, LongVector128Tests::UMINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4520,7 +4520,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMINReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4538,7 +4538,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::UMINReduceMasked, Long128VectorTests::UMINReduceAllMasked); + LongVector128Tests::UMINReduceMasked, LongVector128Tests::UMINReduceAllMasked); } static long UMAXReduce(long[] a, int idx) { @@ -4560,7 +4560,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMAXReduceLong128VectorTests(IntFunction fa) { + static void UMAXReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4576,7 +4576,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::UMAXReduce, Long128VectorTests::UMAXReduceAll); + LongVector128Tests::UMAXReduce, LongVector128Tests::UMAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4622,7 +4622,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMAXReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4640,7 +4640,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::UMAXReduceMasked, Long128VectorTests::UMAXReduceAllMasked); + LongVector128Tests::UMAXReduceMasked, LongVector128Tests::UMAXReduceAllMasked); } static long FIRST_NONZEROReduce(long[] a, int idx) { @@ -4662,7 +4662,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void FIRST_NONZEROReduceLong128VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4678,7 +4678,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::FIRST_NONZEROReduce, Long128VectorTests::FIRST_NONZEROReduceAll); + LongVector128Tests::FIRST_NONZEROReduce, LongVector128Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4724,7 +4724,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void FIRST_NONZEROReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4742,7 +4742,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::FIRST_NONZEROReduceMasked, Long128VectorTests::FIRST_NONZEROReduceAllMasked); + LongVector128Tests::FIRST_NONZEROReduceMasked, LongVector128Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4755,7 +4755,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueLong128VectorTests(IntFunction fm) { + static void anyTrueLongVector128Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4766,7 +4766,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Long128VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, LongVector128Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4779,7 +4779,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueLong128VectorTests(IntFunction fm) { + static void allTrueLongVector128Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4790,7 +4790,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Long128VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, LongVector128Tests::allTrue); } static long SUADDReduce(long[] a, int idx) { @@ -4812,7 +4812,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingUnaryOpProvider") - static void SUADDReduceLong128VectorTests(IntFunction fa) { + static void SUADDReduceLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4828,7 +4828,7 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::SUADDReduce, Long128VectorTests::SUADDReduceAll); + LongVector128Tests::SUADDReduce, LongVector128Tests::SUADDReduceAll); } @Test(dataProvider = "longSaturatingUnaryOpProvider") @@ -4873,7 +4873,7 @@ public class Long128VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "longSaturatingUnaryOpMaskProvider") - static void SUADDReduceLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4891,11 +4891,11 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::SUADDReduceMasked, Long128VectorTests::SUADDReduceAllMasked); + LongVector128Tests::SUADDReduceMasked, LongVector128Tests::SUADDReduceAllMasked); } @Test(dataProvider = "longBinaryOpProvider") - static void withLong128VectorTests(IntFunction fa, IntFunction fb) { + static void withLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -4918,7 +4918,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_DEFAULTLong128VectorTests(IntFunction fa) { + static void IS_DEFAULTLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4935,7 +4935,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_DEFAULTMaskedLong128VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4959,7 +4959,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_NEGATIVELong128VectorTests(IntFunction fa) { + static void IS_NEGATIVELongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4976,7 +4976,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_NEGATIVEMaskedLong128VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4996,7 +4996,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLong128VectorTests(IntFunction fa, IntFunction fb) { + static void LTLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5015,7 +5015,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLong128VectorTests(IntFunction fa, IntFunction fb) { + static void ltLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5034,7 +5034,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5057,7 +5057,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GTLong128VectorTests(IntFunction fa, IntFunction fb) { + static void GTLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5076,7 +5076,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GTLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5099,7 +5099,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void EQLong128VectorTests(IntFunction fa, IntFunction fb) { + static void EQLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5118,7 +5118,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLong128VectorTests(IntFunction fa, IntFunction fb) { + static void eqLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5137,7 +5137,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5160,7 +5160,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void NELong128VectorTests(IntFunction fa, IntFunction fb) { + static void NELongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5179,7 +5179,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void NELong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NELongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5202,7 +5202,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LELong128VectorTests(IntFunction fa, IntFunction fb) { + static void LELongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5221,7 +5221,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LELong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LELongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5244,7 +5244,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GELong128VectorTests(IntFunction fa, IntFunction fb) { + static void GELongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5263,7 +5263,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GELong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GELongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5286,7 +5286,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULTLong128VectorTests(IntFunction fa, IntFunction fb) { + static void ULTLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5305,7 +5305,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULTLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5328,7 +5328,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGTLong128VectorTests(IntFunction fa, IntFunction fb) { + static void UGTLongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5347,7 +5347,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGTLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5370,7 +5370,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULELong128VectorTests(IntFunction fa, IntFunction fb) { + static void ULELongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5389,7 +5389,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULELong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULELongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5412,7 +5412,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGELong128VectorTests(IntFunction fa, IntFunction fb) { + static void UGELongVector128Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5431,7 +5431,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGELong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGELongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5454,7 +5454,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5470,7 +5470,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5491,7 +5491,7 @@ public class Long128VectorTests extends AbstractVectorTest { @Test(dataProvider = "longCompareOpProvider") - static void EQLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5507,7 +5507,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5532,7 +5532,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void blendLong128VectorTests(IntFunction fa, IntFunction fb, + static void blendLongVector128Tests(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5548,11 +5548,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long128VectorTests::blend); + assertArraysEquals(r, a, b, mask, LongVector128Tests::blend); } @Test(dataProvider = "longUnaryOpShuffleProvider") - static void RearrangeLong128VectorTests(IntFunction fa, + static void RearrangeLongVector128Tests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5569,7 +5569,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpShuffleMaskProvider") - static void RearrangeLong128VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeLongVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -5587,7 +5587,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void compressLong128VectorTests(IntFunction fa, + static void compressLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5605,7 +5605,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void expandLong128VectorTests(IntFunction fa, + static void expandLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5623,7 +5623,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void getLong128VectorTests(IntFunction fa) { + static void getLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5779,7 +5779,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BroadcastLong128VectorTests(IntFunction fa) { + static void BroadcastLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5793,7 +5793,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZeroLong128VectorTests(IntFunction fa) { + static void ZeroLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5818,7 +5818,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void sliceUnaryLong128VectorTests(IntFunction fa) { + static void sliceUnaryLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5829,7 +5829,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Long128VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, LongVector128Tests::sliceUnary); } static long[] sliceBinary(long[] a, long[] b, int origin, int idx) { @@ -5846,7 +5846,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void sliceBinaryLong128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryLongVector128TestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5859,7 +5859,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Long128VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, LongVector128Tests::sliceBinary); } static long[] slice(long[] a, long[] b, int origin, boolean[] mask, int idx) { @@ -5876,7 +5876,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void sliceLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5893,7 +5893,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Long128VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, LongVector128Tests::slice); } static long[] unsliceUnary(long[] a, int origin, int idx) { @@ -5910,7 +5910,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void unsliceUnaryLong128VectorTests(IntFunction fa) { + static void unsliceUnaryLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5921,7 +5921,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Long128VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, LongVector128Tests::unsliceUnary); } static long[] unsliceBinary(long[] a, long[] b, int origin, int part, int idx) { @@ -5947,7 +5947,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void unsliceBinaryLong128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryLongVector128TestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5961,7 +5961,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Long128VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, LongVector128Tests::unsliceBinary); } static long[] unslice(long[] a, long[] b, int origin, int part, boolean[] mask, int idx) { @@ -6001,7 +6001,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void unsliceLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6018,7 +6018,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Long128VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, LongVector128Tests::unslice); } static long BITWISE_BLEND(long a, long b, long c) { @@ -6030,7 +6030,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6045,11 +6045,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Long128VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, LongVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6062,11 +6062,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Long128VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, LongVector128Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6084,11 +6084,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Long128VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, LongVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6099,11 +6099,11 @@ public class Long128VectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Long128VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, LongVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6114,11 +6114,11 @@ public class Long128VectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Long128VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, LongVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6129,11 +6129,11 @@ public class Long128VectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Long128VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, LongVector128Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6144,11 +6144,11 @@ public class Long128VectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Long128VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, LongVector128Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6163,11 +6163,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Long128VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, LongVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong128VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector128TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6182,11 +6182,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Long128VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, LongVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6197,11 +6197,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Long128VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6212,11 +6212,11 @@ public class Long128VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Long128VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVector128Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong128VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector128TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6230,7 +6230,7 @@ public class Long128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Long128VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, LongVector128Tests::BITWISE_BLEND); } static long NEG(long a) { @@ -6242,7 +6242,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NEGLong128VectorTests(IntFunction fa) { + static void NEGLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6253,11 +6253,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::NEG); + assertArraysEquals(r, a, LongVector128Tests::NEG); } @Test(dataProvider = "longUnaryOpProvider") - static void negLong128VectorTests(IntFunction fa) { + static void negLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6268,11 +6268,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::neg); + assertArraysEquals(r, a, LongVector128Tests::neg); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NEGMaskedLong128VectorTests(IntFunction fa, + static void NEGMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6286,7 +6286,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::NEG); + assertArraysEquals(r, a, mask, LongVector128Tests::NEG); } static long ABS(long a) { @@ -6298,7 +6298,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ABSLong128VectorTests(IntFunction fa) { + static void ABSLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6309,11 +6309,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::ABS); + assertArraysEquals(r, a, LongVector128Tests::ABS); } @Test(dataProvider = "longUnaryOpProvider") - static void absLong128VectorTests(IntFunction fa) { + static void absLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6324,11 +6324,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::abs); + assertArraysEquals(r, a, LongVector128Tests::abs); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ABSMaskedLong128VectorTests(IntFunction fa, + static void ABSMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6342,7 +6342,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::ABS); + assertArraysEquals(r, a, mask, LongVector128Tests::ABS); } static long NOT(long a) { @@ -6354,7 +6354,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NOTLong128VectorTests(IntFunction fa) { + static void NOTLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6365,11 +6365,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::NOT); + assertArraysEquals(r, a, LongVector128Tests::NOT); } @Test(dataProvider = "longUnaryOpProvider") - static void notLong128VectorTests(IntFunction fa) { + static void notLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6380,11 +6380,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::not); + assertArraysEquals(r, a, LongVector128Tests::not); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NOTMaskedLong128VectorTests(IntFunction fa, + static void NOTMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6398,7 +6398,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::NOT); + assertArraysEquals(r, a, mask, LongVector128Tests::NOT); } static long ZOMO(long a) { @@ -6406,7 +6406,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZOMOLong128VectorTests(IntFunction fa) { + static void ZOMOLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6417,11 +6417,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::ZOMO); + assertArraysEquals(r, a, LongVector128Tests::ZOMO); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ZOMOMaskedLong128VectorTests(IntFunction fa, + static void ZOMOMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6435,7 +6435,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::ZOMO); + assertArraysEquals(r, a, mask, LongVector128Tests::ZOMO); } static long BIT_COUNT(long a) { @@ -6443,7 +6443,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BIT_COUNTLong128VectorTests(IntFunction fa) { + static void BIT_COUNTLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6454,11 +6454,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::BIT_COUNT); + assertArraysEquals(r, a, LongVector128Tests::BIT_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void BIT_COUNTMaskedLong128VectorTests(IntFunction fa, + static void BIT_COUNTMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6472,7 +6472,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, LongVector128Tests::BIT_COUNT); } static long TRAILING_ZEROS_COUNT(long a) { @@ -6480,7 +6480,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void TRAILING_ZEROS_COUNTLong128VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6491,11 +6491,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVector128Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedLong128VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6509,7 +6509,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVector128Tests::TRAILING_ZEROS_COUNT); } static long LEADING_ZEROS_COUNT(long a) { @@ -6517,7 +6517,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LEADING_ZEROS_COUNTLong128VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6528,11 +6528,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVector128Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedLong128VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6546,7 +6546,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVector128Tests::LEADING_ZEROS_COUNT); } static long REVERSE(long a) { @@ -6554,7 +6554,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSELong128VectorTests(IntFunction fa) { + static void REVERSELongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6565,11 +6565,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::REVERSE); + assertArraysEquals(r, a, LongVector128Tests::REVERSE); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSEMaskedLong128VectorTests(IntFunction fa, + static void REVERSEMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6583,7 +6583,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::REVERSE); + assertArraysEquals(r, a, mask, LongVector128Tests::REVERSE); } static long REVERSE_BYTES(long a) { @@ -6591,7 +6591,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSE_BYTESLong128VectorTests(IntFunction fa) { + static void REVERSE_BYTESLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6602,11 +6602,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, LongVector128Tests::REVERSE_BYTES); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedLong128VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedLongVector128Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6620,7 +6620,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long128VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, LongVector128Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6628,7 +6628,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandLong128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandLongVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6641,7 +6641,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::band); + assertArraysEquals(r, a, b, LongVector128Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6649,7 +6649,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorLong128VectorTests(IntFunction fa, IntFunction fb) { + static void maskorLongVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6662,7 +6662,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::bor); + assertArraysEquals(r, a, b, LongVector128Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6670,7 +6670,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorLong128VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorLongVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6683,7 +6683,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::bxor); + assertArraysEquals(r, a, b, LongVector128Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6691,7 +6691,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotLong128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotLongVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6704,7 +6704,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::bandNot); + assertArraysEquals(r, a, b, LongVector128Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6712,7 +6712,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqLong128VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqLongVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6725,7 +6725,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long128VectorTests::beq); + assertArraysEquals(r, a, b, LongVector128Tests::beq); } static boolean unot(boolean a) { @@ -6733,7 +6733,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotLong128VectorTests(IntFunction fa) { + static void masknotLongVector128Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6744,7 +6744,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long128VectorTests::unot); + assertArraysEquals(r, a, LongVector128Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6761,7 +6761,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongLong128VectorTests(IntFunction fa) { + static void maskFromToLongLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6775,7 +6775,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLong128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltLongVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6791,7 +6791,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLong128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqLongVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6807,7 +6807,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longtoIntUnaryOpProvider") - static void toIntArrayLong128VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayLongVector128TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6818,7 +6818,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toLongArrayLong128VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayLongVector128TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6829,7 +6829,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toDoubleArrayLong128VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayLongVector128TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6840,7 +6840,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toStringLong128VectorTestsSmokeTest(IntFunction fa) { + static void toStringLongVector128TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6853,7 +6853,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void hashCodeLong128VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeLongVector128TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6869,7 +6869,7 @@ public class Long128VectorTests extends AbstractVectorTest { @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLongLong128VectorTests(IntFunction fa) { + static void ADDReduceLongLongVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -6885,11 +6885,11 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long128VectorTests::ADDReduce, Long128VectorTests::ADDReduceAll); + LongVector128Tests::ADDReduce, LongVector128Tests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLongLong128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongLongVector128TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6907,11 +6907,11 @@ public class Long128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long128VectorTests::ADDReduceMasked, Long128VectorTests::ADDReduceAllMasked); + LongVector128Tests::ADDReduceMasked, LongVector128Tests::ADDReduceAllMasked); } @Test(dataProvider = "longUnaryOpSelectFromProvider") - static void SelectFromLong128VectorTests(IntFunction fa, + static void SelectFromLongVector128Tests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); long[] order = fs.apply(a.length, SPECIES.length()); @@ -6927,7 +6927,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorLong128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorLongVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] idx = fc.apply(SPECIES.length()); @@ -6945,7 +6945,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpSelectFromMaskProvider") - static void SelectFromLong128VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromLongVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -6964,7 +6964,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousLong128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousLongVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6980,7 +6980,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringLong128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringLongVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6994,7 +6994,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsLong128VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsLongVector128TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7008,7 +7008,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsLong128VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsLongVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7024,7 +7024,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeLong128VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeLongVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7046,7 +7046,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountLong128VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountLongVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7057,7 +7057,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long128VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, LongVector128Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7071,7 +7071,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueLong128VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueLongVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7082,7 +7082,7 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long128VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, LongVector128Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7096,7 +7096,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueLong128VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueLongVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7107,11 +7107,11 @@ public class Long128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long128VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, LongVector128Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressLong128VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressLongVector128TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7139,7 +7139,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLong128VectorTestsSmokeTest(int offset) { + static void indexInRangeLongVector128TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7153,7 +7153,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongLong128VectorTestsSmokeTest(int offset) { + static void indexInRangeLongLongVector128TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7180,14 +7180,14 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundLong128VectorTestsSmokeTest(int length) { + static void loopBoundLongVector128TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongLong128VectorTestsSmokeTest(int _length) { + static void loopBoundLongLongVector128TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7195,21 +7195,21 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeLong128VectorTestsSmokeTest() { + static void ElementSizeLongVector128TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Long.SIZE); } @Test - static void VectorShapeLong128VectorTestsSmokeTest() { + static void VectorShapeLongVector128TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_128_BIT)); } @Test - static void ShapeWithLanesLong128VectorTestsSmokeTest() { + static void ShapeWithLanesLongVector128TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(long.class); @@ -7217,32 +7217,32 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeLong128VectorTestsSmokeTest() { + static void ElementTypeLongVector128TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementType() == long.class); } @Test - static void SpeciesElementSizeLong128VectorTestsSmokeTest() { + static void SpeciesElementSizeLongVector128TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementSize() == Long.SIZE); } @Test - static void VectorTypeLong128VectorTestsSmokeTest() { + static void VectorTypeLongVector128TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesLong128VectorTestsSmokeTest() { + static void WithLanesLongVector128TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(long.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeLong128VectorTestsSmokeTest() { + static void WithShapeLongVector128TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7250,7 +7250,7 @@ public class Long128VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueLong128VectorTestsSmokeTest() { + static void MaskAllTrueLongVector128TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Long256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/LongVector256LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Long256VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/LongVector256LoadStoreTests.java index 675536ee67b..411c48dc7cb 100644 --- a/test/jdk/jdk/incubator/vector/Long256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/LongVector256LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Long256VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation LongVector256LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Long256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class LongVector256LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = LongVector.SPECIES_256; diff --git a/test/jdk/jdk/incubator/vector/Long256VectorTests.java b/test/jdk/jdk/incubator/vector/LongVector256Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Long256VectorTests.java rename to test/jdk/jdk/incubator/vector/LongVector256Tests.java index 0f3e3347480..a766abe920f 100644 --- a/test/jdk/jdk/incubator/vector/Long256VectorTests.java +++ b/test/jdk/jdk/incubator/vector/LongVector256Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Long256VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation LongVector256Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Long256VectorTests extends AbstractVectorTest { +public class LongVector256Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = LongVector.SPECIES_256; @@ -1683,7 +1683,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLong256VectorTests(IntFunction fa, IntFunction fb) { + static void ADDLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1696,7 +1696,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::ADD); + assertArraysEquals(r, a, b, LongVector256Tests::ADD); } static long add(long a, long b) { @@ -1704,7 +1704,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void addLong256VectorTests(IntFunction fa, IntFunction fb) { + static void addLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1715,11 +1715,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long256VectorTests::add); + assertArraysEquals(r, a, b, LongVector256Tests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1735,11 +1735,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::ADD); + assertArraysEquals(r, a, b, mask, LongVector256Tests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1753,7 +1753,7 @@ public class Long256VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long256VectorTests::add); + assertArraysEquals(r, a, b, mask, LongVector256Tests::add); } static long SUB(long a, long b) { @@ -1761,7 +1761,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void SUBLong256VectorTests(IntFunction fa, IntFunction fb) { + static void SUBLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1774,7 +1774,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::SUB); + assertArraysEquals(r, a, b, LongVector256Tests::SUB); } static long sub(long a, long b) { @@ -1782,7 +1782,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void subLong256VectorTests(IntFunction fa, IntFunction fb) { + static void subLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1793,11 +1793,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long256VectorTests::sub); + assertArraysEquals(r, a, b, LongVector256Tests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void SUBLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1813,11 +1813,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::SUB); + assertArraysEquals(r, a, b, mask, LongVector256Tests::SUB); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1831,7 +1831,7 @@ public class Long256VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long256VectorTests::sub); + assertArraysEquals(r, a, b, mask, LongVector256Tests::sub); } static long MUL(long a, long b) { @@ -1839,7 +1839,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MULLong256VectorTests(IntFunction fa, IntFunction fb) { + static void MULLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1852,7 +1852,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::MUL); + assertArraysEquals(r, a, b, LongVector256Tests::MUL); } static long mul(long a, long b) { @@ -1860,7 +1860,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void mulLong256VectorTests(IntFunction fa, IntFunction fb) { + static void mulLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1871,11 +1871,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long256VectorTests::mul); + assertArraysEquals(r, a, b, LongVector256Tests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void MULLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1891,11 +1891,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::MUL); + assertArraysEquals(r, a, b, mask, LongVector256Tests::MUL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1909,7 +1909,7 @@ public class Long256VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long256VectorTests::mul); + assertArraysEquals(r, a, b, mask, LongVector256Tests::mul); } static long DIV(long a, long b) { @@ -1917,7 +1917,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void DIVLong256VectorTests(IntFunction fa, IntFunction fb) { + static void DIVLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1932,7 +1932,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::DIV); + assertArraysEquals(r, a, b, LongVector256Tests::DIV); } static long div(long a, long b) { @@ -1940,7 +1940,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void divLong256VectorTests(IntFunction fa, IntFunction fb) { + static void divLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1955,11 +1955,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::div); + assertArraysEquals(r, a, b, LongVector256Tests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void DIVLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1977,11 +1977,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::DIV); + assertArraysEquals(r, a, b, mask, LongVector256Tests::DIV); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1999,7 +1999,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::div); + assertArraysEquals(r, a, b, mask, LongVector256Tests::div); } static long FIRST_NONZERO(long a, long b) { @@ -2007,7 +2007,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void FIRST_NONZEROLong256VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2020,11 +2020,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, LongVector256Tests::FIRST_NONZERO); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void FIRST_NONZEROLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2040,7 +2040,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, LongVector256Tests::FIRST_NONZERO); } static long AND(long a, long b) { @@ -2048,7 +2048,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLong256VectorTests(IntFunction fa, IntFunction fb) { + static void ANDLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2061,7 +2061,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::AND); + assertArraysEquals(r, a, b, LongVector256Tests::AND); } static long and(long a, long b) { @@ -2069,7 +2069,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void andLong256VectorTests(IntFunction fa, IntFunction fb) { + static void andLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2080,11 +2080,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long256VectorTests::and); + assertArraysEquals(r, a, b, LongVector256Tests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2100,7 +2100,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::AND); + assertArraysEquals(r, a, b, mask, LongVector256Tests::AND); } static long AND_NOT(long a, long b) { @@ -2108,7 +2108,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void AND_NOTLong256VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2121,11 +2121,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::AND_NOT); + assertArraysEquals(r, a, b, LongVector256Tests::AND_NOT); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void AND_NOTLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2141,7 +2141,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, LongVector256Tests::AND_NOT); } static long OR(long a, long b) { @@ -2149,7 +2149,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong256VectorTests(IntFunction fa, IntFunction fb) { + static void ORLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2162,7 +2162,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::OR); + assertArraysEquals(r, a, b, LongVector256Tests::OR); } static long or(long a, long b) { @@ -2170,7 +2170,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void orLong256VectorTests(IntFunction fa, IntFunction fb) { + static void orLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2181,11 +2181,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long256VectorTests::or); + assertArraysEquals(r, a, b, LongVector256Tests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2201,7 +2201,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::OR); + assertArraysEquals(r, a, b, mask, LongVector256Tests::OR); } static long XOR(long a, long b) { @@ -2209,7 +2209,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void XORLong256VectorTests(IntFunction fa, IntFunction fb) { + static void XORLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2222,11 +2222,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::XOR); + assertArraysEquals(r, a, b, LongVector256Tests::XOR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void XORLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2242,7 +2242,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::XOR); + assertArraysEquals(r, a, b, mask, LongVector256Tests::XOR); } static long COMPRESS_BITS(long a, long b) { @@ -2250,7 +2250,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void COMPRESS_BITSLong256VectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2263,11 +2263,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, LongVector256Tests::COMPRESS_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void COMPRESS_BITSLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2283,7 +2283,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, LongVector256Tests::COMPRESS_BITS); } static long EXPAND_BITS(long a, long b) { @@ -2291,7 +2291,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void EXPAND_BITSLong256VectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2304,11 +2304,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, LongVector256Tests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void EXPAND_BITSLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2324,11 +2324,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, LongVector256Tests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpProvider") - static void addLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2338,11 +2338,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2355,11 +2355,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, LongVector256Tests::add); } @Test(dataProvider = "longBinaryOpProvider") - static void subLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2369,11 +2369,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2386,11 +2386,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, LongVector256Tests::sub); } @Test(dataProvider = "longBinaryOpProvider") - static void mulLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2400,11 +2400,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, LongVector256Tests::mul); } @Test(dataProvider = "longBinaryOpProvider") - static void divLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2433,11 +2433,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2452,11 +2452,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, LongVector256Tests::div); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2466,11 +2466,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void orLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2480,11 +2480,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::or); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2497,11 +2497,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, LongVector256Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2511,11 +2511,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void andLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2525,11 +2525,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::and); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2542,11 +2542,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, LongVector256Tests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2556,11 +2556,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Long256VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, LongVector256Tests::OR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2573,11 +2573,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Long256VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVector256Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLong256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDLongVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2587,11 +2587,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Long256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, LongVector256Tests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLong256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDLongVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2604,7 +2604,7 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Long256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVector256Tests::ADD); } static long LSHL(long a, long b) { @@ -2612,7 +2612,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLong256VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2625,11 +2625,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::LSHL); + assertArraysEquals(r, a, b, LongVector256Tests::LSHL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2645,7 +2645,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, LongVector256Tests::LSHL); } static long ASHR(long a, long b) { @@ -2653,7 +2653,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLong256VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2666,11 +2666,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::ASHR); + assertArraysEquals(r, a, b, LongVector256Tests::ASHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2686,7 +2686,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, LongVector256Tests::ASHR); } static long LSHR(long a, long b) { @@ -2694,7 +2694,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLong256VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2707,11 +2707,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::LSHR); + assertArraysEquals(r, a, b, LongVector256Tests::LSHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2727,7 +2727,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, LongVector256Tests::LSHR); } static long LSHL_unary(long a, long b) { @@ -2735,7 +2735,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLong256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLLongVector256TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2747,11 +2747,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long256VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, LongVector256Tests::LSHL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLong256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2766,7 +2766,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector256Tests::LSHL_unary); } static long LSHR_unary(long a, long b) { @@ -2774,7 +2774,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLong256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRLongVector256TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2786,11 +2786,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long256VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, LongVector256Tests::LSHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLong256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2805,7 +2805,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector256Tests::LSHR_unary); } static long ASHR_unary(long a, long b) { @@ -2813,7 +2813,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLong256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRLongVector256TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2825,11 +2825,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long256VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, LongVector256Tests::ASHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLong256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2844,7 +2844,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector256Tests::ASHR_unary); } static long ROR(long a, long b) { @@ -2852,7 +2852,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLong256VectorTests(IntFunction fa, IntFunction fb) { + static void RORLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2865,11 +2865,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::ROR); + assertArraysEquals(r, a, b, LongVector256Tests::ROR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2885,7 +2885,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::ROR); + assertArraysEquals(r, a, b, mask, LongVector256Tests::ROR); } static long ROL(long a, long b) { @@ -2893,7 +2893,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLong256VectorTests(IntFunction fa, IntFunction fb) { + static void ROLLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2906,11 +2906,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::ROL); + assertArraysEquals(r, a, b, LongVector256Tests::ROL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2926,7 +2926,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::ROL); + assertArraysEquals(r, a, b, mask, LongVector256Tests::ROL); } static long ROR_unary(long a, long b) { @@ -2934,7 +2934,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLong256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORLongVector256TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2946,11 +2946,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long256VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, LongVector256Tests::ROR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLong256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORLongVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2965,7 +2965,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector256Tests::ROR_unary); } static long ROL_unary(long a, long b) { @@ -2973,7 +2973,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLong256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLLongVector256TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2985,11 +2985,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long256VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, LongVector256Tests::ROL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLong256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLLongVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3004,14 +3004,14 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector256Tests::ROL_unary); } static long LSHR_binary_const(long a) { return (long)((a >>> CONST_SHIFT)); } @Test(dataProvider = "longUnaryOpProvider") - static void LSHRLong256VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRLongVector256TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3022,11 +3022,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long256VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, LongVector256Tests::LSHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHRLong256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRLongVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3040,7 +3040,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long256VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector256Tests::LSHR_binary_const); } static long LSHL_binary_const(long a) { @@ -3048,7 +3048,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LSHLLong256VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLLongVector256TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3059,11 +3059,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long256VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, LongVector256Tests::LSHL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHLLong256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLLongVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3077,7 +3077,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long256VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, LongVector256Tests::LSHL_binary_const); } static long ASHR_binary_const(long a) { @@ -3085,7 +3085,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ASHRLong256VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRLongVector256TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3096,11 +3096,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long256VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, LongVector256Tests::ASHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ASHRLong256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRLongVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3114,7 +3114,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long256VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector256Tests::ASHR_binary_const); } static long ROR_binary_const(long a) { @@ -3122,7 +3122,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void RORLong256VectorTestsScalarShiftConst(IntFunction fa) { + static void RORLongVector256TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3133,11 +3133,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long256VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, LongVector256Tests::ROR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void RORLong256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORLongVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3151,7 +3151,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long256VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector256Tests::ROR_binary_const); } static long ROL_binary_const(long a) { @@ -3159,7 +3159,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ROLLong256VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLLongVector256TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3170,11 +3170,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long256VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, LongVector256Tests::ROL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ROLLong256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLLongVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3188,14 +3188,14 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long256VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, LongVector256Tests::ROL_binary_const); } static LongVector bv_MIN = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MINLong256VectorTestsWithMemOp(IntFunction fa) { + static void MINLongVector256TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3206,13 +3206,13 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long256VectorTests::MIN); + assertArraysEquals(r, a, (long)10, LongVector256Tests::MIN); } static LongVector bv_min = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void minLong256VectorTestsWithMemOp(IntFunction fa) { + static void minLongVector256TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3223,13 +3223,13 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long256VectorTests::min); + assertArraysEquals(r, a, (long)10, LongVector256Tests::min); } static LongVector bv_MIN_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINLong256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINLongVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3242,13 +3242,13 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, Long256VectorTests::MIN); + assertArraysEquals(r, a, (long)10, mask, LongVector256Tests::MIN); } static LongVector bv_MAX = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MAXLong256VectorTestsWithMemOp(IntFunction fa) { + static void MAXLongVector256TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3259,13 +3259,13 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long256VectorTests::MAX); + assertArraysEquals(r, a, (long)10, LongVector256Tests::MAX); } static LongVector bv_max = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void maxLong256VectorTestsWithMemOp(IntFunction fa) { + static void maxLongVector256TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3276,13 +3276,13 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long256VectorTests::max); + assertArraysEquals(r, a, (long)10, LongVector256Tests::max); } static LongVector bv_MAX_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXLong256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXLongVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3295,7 +3295,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, Long256VectorTests::MAX); + assertArraysEquals(r, a, (long)10, mask, LongVector256Tests::MAX); } static long MIN(long a, long b) { @@ -3303,7 +3303,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MINLong256VectorTests(IntFunction fa, IntFunction fb) { + static void MINLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3316,7 +3316,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::MIN); + assertArraysEquals(r, a, b, LongVector256Tests::MIN); } static long min(long a, long b) { @@ -3324,7 +3324,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void minLong256VectorTests(IntFunction fa, IntFunction fb) { + static void minLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3335,7 +3335,7 @@ public class Long256VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long256VectorTests::min); + assertArraysEquals(r, a, b, LongVector256Tests::min); } static long MAX(long a, long b) { @@ -3343,7 +3343,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLong256VectorTests(IntFunction fa, IntFunction fb) { + static void MAXLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3356,7 +3356,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::MAX); + assertArraysEquals(r, a, b, LongVector256Tests::MAX); } static long max(long a, long b) { @@ -3364,7 +3364,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void maxLong256VectorTests(IntFunction fa, IntFunction fb) { + static void maxLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3375,7 +3375,7 @@ public class Long256VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long256VectorTests::max); + assertArraysEquals(r, a, b, LongVector256Tests::max); } static long UMIN(long a, long b) { @@ -3383,7 +3383,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMINLong256VectorTests(IntFunction fa, IntFunction fb) { + static void UMINLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3396,11 +3396,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::UMIN); + assertArraysEquals(r, a, b, LongVector256Tests::UMIN); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMINLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3416,7 +3416,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, LongVector256Tests::UMIN); } static long UMAX(long a, long b) { @@ -3424,7 +3424,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMAXLong256VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3437,11 +3437,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::UMAX); + assertArraysEquals(r, a, b, LongVector256Tests::UMAX); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMAXLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3457,7 +3457,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, LongVector256Tests::UMAX); } static long SADD(long a, long b) { @@ -3465,7 +3465,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SADDLong256VectorTests(IntFunction fa, IntFunction fb) { + static void SADDLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3478,11 +3478,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::SADD); + assertArraysEquals(r, a, b, LongVector256Tests::SADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SADDLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3498,7 +3498,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::SADD); + assertArraysEquals(r, a, b, mask, LongVector256Tests::SADD); } static long SSUB(long a, long b) { @@ -3506,7 +3506,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SSUBLong256VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3519,11 +3519,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::SSUB); + assertArraysEquals(r, a, b, LongVector256Tests::SSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SSUBLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3539,7 +3539,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, LongVector256Tests::SSUB); } static long SUADD(long a, long b) { @@ -3547,7 +3547,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUADDLong256VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3560,11 +3560,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::SUADD); + assertArraysEquals(r, a, b, LongVector256Tests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUADDLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3580,7 +3580,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, LongVector256Tests::SUADD); } static long SUSUB(long a, long b) { @@ -3588,7 +3588,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUSUBLong256VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3601,11 +3601,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::SUSUB); + assertArraysEquals(r, a, b, LongVector256Tests::SUSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUSUBLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3621,11 +3621,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, LongVector256Tests::SUSUB); } @Test(dataProvider = "longBinaryOpProvider") - static void MINLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3635,11 +3635,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::MIN); } @Test(dataProvider = "longBinaryOpProvider") - static void minLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3649,11 +3649,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::min); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::min); } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3663,11 +3663,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::MAX); } @Test(dataProvider = "longBinaryOpProvider") - static void maxLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3677,10 +3677,10 @@ public class Long256VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long256VectorTests::max); + assertBroadcastArraysEquals(r, a, b, LongVector256Tests::max); } @Test(dataProvider = "longSaturatingBinaryOpAssocProvider") - static void SUADDAssocLong256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocLongVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -3697,11 +3697,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Long256VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, LongVector256Tests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3722,7 +3722,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Long256VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, LongVector256Tests::SUADD); } static long ANDReduce(long[] a, int idx) { @@ -3744,7 +3744,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ANDReduceLong256VectorTests(IntFunction fa) { + static void ANDReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3760,7 +3760,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::ANDReduce, Long256VectorTests::ANDReduceAll); + LongVector256Tests::ANDReduce, LongVector256Tests::ANDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3806,7 +3806,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ANDReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3824,7 +3824,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::ANDReduceMasked, Long256VectorTests::ANDReduceAllMasked); + LongVector256Tests::ANDReduceMasked, LongVector256Tests::ANDReduceAllMasked); } static long ORReduce(long[] a, int idx) { @@ -3846,7 +3846,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ORReduceLong256VectorTests(IntFunction fa) { + static void ORReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3862,7 +3862,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::ORReduce, Long256VectorTests::ORReduceAll); + LongVector256Tests::ORReduce, LongVector256Tests::ORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3908,7 +3908,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ORReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3926,7 +3926,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::ORReduceMasked, Long256VectorTests::ORReduceAllMasked); + LongVector256Tests::ORReduceMasked, LongVector256Tests::ORReduceAllMasked); } static long XORReduce(long[] a, int idx) { @@ -3948,7 +3948,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void XORReduceLong256VectorTests(IntFunction fa) { + static void XORReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3964,7 +3964,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::XORReduce, Long256VectorTests::XORReduceAll); + LongVector256Tests::XORReduce, LongVector256Tests::XORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4010,7 +4010,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void XORReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4028,7 +4028,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::XORReduceMasked, Long256VectorTests::XORReduceAllMasked); + LongVector256Tests::XORReduceMasked, LongVector256Tests::XORReduceAllMasked); } static long ADDReduce(long[] a, int idx) { @@ -4050,7 +4050,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLong256VectorTests(IntFunction fa) { + static void ADDReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4066,7 +4066,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::ADDReduce, Long256VectorTests::ADDReduceAll); + LongVector256Tests::ADDReduce, LongVector256Tests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4112,7 +4112,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4130,7 +4130,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::ADDReduceMasked, Long256VectorTests::ADDReduceAllMasked); + LongVector256Tests::ADDReduceMasked, LongVector256Tests::ADDReduceAllMasked); } static long MULReduce(long[] a, int idx) { @@ -4152,7 +4152,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MULReduceLong256VectorTests(IntFunction fa) { + static void MULReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4168,7 +4168,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::MULReduce, Long256VectorTests::MULReduceAll); + LongVector256Tests::MULReduce, LongVector256Tests::MULReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4214,7 +4214,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MULReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4232,7 +4232,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::MULReduceMasked, Long256VectorTests::MULReduceAllMasked); + LongVector256Tests::MULReduceMasked, LongVector256Tests::MULReduceAllMasked); } static long MINReduce(long[] a, int idx) { @@ -4254,7 +4254,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MINReduceLong256VectorTests(IntFunction fa) { + static void MINReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4270,7 +4270,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::MINReduce, Long256VectorTests::MINReduceAll); + LongVector256Tests::MINReduce, LongVector256Tests::MINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4316,7 +4316,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4334,7 +4334,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::MINReduceMasked, Long256VectorTests::MINReduceAllMasked); + LongVector256Tests::MINReduceMasked, LongVector256Tests::MINReduceAllMasked); } static long MAXReduce(long[] a, int idx) { @@ -4356,7 +4356,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MAXReduceLong256VectorTests(IntFunction fa) { + static void MAXReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4372,7 +4372,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::MAXReduce, Long256VectorTests::MAXReduceAll); + LongVector256Tests::MAXReduce, LongVector256Tests::MAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4418,7 +4418,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4436,7 +4436,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::MAXReduceMasked, Long256VectorTests::MAXReduceAllMasked); + LongVector256Tests::MAXReduceMasked, LongVector256Tests::MAXReduceAllMasked); } static long UMINReduce(long[] a, int idx) { @@ -4458,7 +4458,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMINReduceLong256VectorTests(IntFunction fa) { + static void UMINReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4474,7 +4474,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::UMINReduce, Long256VectorTests::UMINReduceAll); + LongVector256Tests::UMINReduce, LongVector256Tests::UMINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4520,7 +4520,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMINReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4538,7 +4538,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::UMINReduceMasked, Long256VectorTests::UMINReduceAllMasked); + LongVector256Tests::UMINReduceMasked, LongVector256Tests::UMINReduceAllMasked); } static long UMAXReduce(long[] a, int idx) { @@ -4560,7 +4560,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMAXReduceLong256VectorTests(IntFunction fa) { + static void UMAXReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4576,7 +4576,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::UMAXReduce, Long256VectorTests::UMAXReduceAll); + LongVector256Tests::UMAXReduce, LongVector256Tests::UMAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4622,7 +4622,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMAXReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4640,7 +4640,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::UMAXReduceMasked, Long256VectorTests::UMAXReduceAllMasked); + LongVector256Tests::UMAXReduceMasked, LongVector256Tests::UMAXReduceAllMasked); } static long FIRST_NONZEROReduce(long[] a, int idx) { @@ -4662,7 +4662,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void FIRST_NONZEROReduceLong256VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4678,7 +4678,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::FIRST_NONZEROReduce, Long256VectorTests::FIRST_NONZEROReduceAll); + LongVector256Tests::FIRST_NONZEROReduce, LongVector256Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4724,7 +4724,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void FIRST_NONZEROReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4742,7 +4742,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::FIRST_NONZEROReduceMasked, Long256VectorTests::FIRST_NONZEROReduceAllMasked); + LongVector256Tests::FIRST_NONZEROReduceMasked, LongVector256Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4755,7 +4755,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueLong256VectorTests(IntFunction fm) { + static void anyTrueLongVector256Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4766,7 +4766,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Long256VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, LongVector256Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4779,7 +4779,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueLong256VectorTests(IntFunction fm) { + static void allTrueLongVector256Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4790,7 +4790,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Long256VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, LongVector256Tests::allTrue); } static long SUADDReduce(long[] a, int idx) { @@ -4812,7 +4812,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingUnaryOpProvider") - static void SUADDReduceLong256VectorTests(IntFunction fa) { + static void SUADDReduceLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4828,7 +4828,7 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::SUADDReduce, Long256VectorTests::SUADDReduceAll); + LongVector256Tests::SUADDReduce, LongVector256Tests::SUADDReduceAll); } @Test(dataProvider = "longSaturatingUnaryOpProvider") @@ -4873,7 +4873,7 @@ public class Long256VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "longSaturatingUnaryOpMaskProvider") - static void SUADDReduceLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4891,11 +4891,11 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::SUADDReduceMasked, Long256VectorTests::SUADDReduceAllMasked); + LongVector256Tests::SUADDReduceMasked, LongVector256Tests::SUADDReduceAllMasked); } @Test(dataProvider = "longBinaryOpProvider") - static void withLong256VectorTests(IntFunction fa, IntFunction fb) { + static void withLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -4918,7 +4918,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_DEFAULTLong256VectorTests(IntFunction fa) { + static void IS_DEFAULTLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4935,7 +4935,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_DEFAULTMaskedLong256VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4959,7 +4959,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_NEGATIVELong256VectorTests(IntFunction fa) { + static void IS_NEGATIVELongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4976,7 +4976,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_NEGATIVEMaskedLong256VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4996,7 +4996,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLong256VectorTests(IntFunction fa, IntFunction fb) { + static void LTLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5015,7 +5015,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLong256VectorTests(IntFunction fa, IntFunction fb) { + static void ltLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5034,7 +5034,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5057,7 +5057,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GTLong256VectorTests(IntFunction fa, IntFunction fb) { + static void GTLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5076,7 +5076,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GTLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5099,7 +5099,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void EQLong256VectorTests(IntFunction fa, IntFunction fb) { + static void EQLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5118,7 +5118,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLong256VectorTests(IntFunction fa, IntFunction fb) { + static void eqLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5137,7 +5137,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5160,7 +5160,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void NELong256VectorTests(IntFunction fa, IntFunction fb) { + static void NELongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5179,7 +5179,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void NELong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NELongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5202,7 +5202,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LELong256VectorTests(IntFunction fa, IntFunction fb) { + static void LELongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5221,7 +5221,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LELong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LELongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5244,7 +5244,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GELong256VectorTests(IntFunction fa, IntFunction fb) { + static void GELongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5263,7 +5263,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GELong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GELongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5286,7 +5286,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULTLong256VectorTests(IntFunction fa, IntFunction fb) { + static void ULTLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5305,7 +5305,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULTLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5328,7 +5328,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGTLong256VectorTests(IntFunction fa, IntFunction fb) { + static void UGTLongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5347,7 +5347,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGTLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5370,7 +5370,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULELong256VectorTests(IntFunction fa, IntFunction fb) { + static void ULELongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5389,7 +5389,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULELong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULELongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5412,7 +5412,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGELong256VectorTests(IntFunction fa, IntFunction fb) { + static void UGELongVector256Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5431,7 +5431,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGELong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGELongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5454,7 +5454,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5470,7 +5470,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5491,7 +5491,7 @@ public class Long256VectorTests extends AbstractVectorTest { @Test(dataProvider = "longCompareOpProvider") - static void EQLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5507,7 +5507,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5532,7 +5532,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void blendLong256VectorTests(IntFunction fa, IntFunction fb, + static void blendLongVector256Tests(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5548,11 +5548,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long256VectorTests::blend); + assertArraysEquals(r, a, b, mask, LongVector256Tests::blend); } @Test(dataProvider = "longUnaryOpShuffleProvider") - static void RearrangeLong256VectorTests(IntFunction fa, + static void RearrangeLongVector256Tests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5569,7 +5569,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpShuffleMaskProvider") - static void RearrangeLong256VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeLongVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -5587,7 +5587,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void compressLong256VectorTests(IntFunction fa, + static void compressLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5605,7 +5605,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void expandLong256VectorTests(IntFunction fa, + static void expandLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5623,7 +5623,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void getLong256VectorTests(IntFunction fa) { + static void getLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5779,7 +5779,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BroadcastLong256VectorTests(IntFunction fa) { + static void BroadcastLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5793,7 +5793,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZeroLong256VectorTests(IntFunction fa) { + static void ZeroLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5818,7 +5818,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void sliceUnaryLong256VectorTests(IntFunction fa) { + static void sliceUnaryLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5829,7 +5829,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Long256VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, LongVector256Tests::sliceUnary); } static long[] sliceBinary(long[] a, long[] b, int origin, int idx) { @@ -5846,7 +5846,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void sliceBinaryLong256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryLongVector256TestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5859,7 +5859,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Long256VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, LongVector256Tests::sliceBinary); } static long[] slice(long[] a, long[] b, int origin, boolean[] mask, int idx) { @@ -5876,7 +5876,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void sliceLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5893,7 +5893,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Long256VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, LongVector256Tests::slice); } static long[] unsliceUnary(long[] a, int origin, int idx) { @@ -5910,7 +5910,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void unsliceUnaryLong256VectorTests(IntFunction fa) { + static void unsliceUnaryLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5921,7 +5921,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Long256VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, LongVector256Tests::unsliceUnary); } static long[] unsliceBinary(long[] a, long[] b, int origin, int part, int idx) { @@ -5947,7 +5947,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void unsliceBinaryLong256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryLongVector256TestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5961,7 +5961,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Long256VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, LongVector256Tests::unsliceBinary); } static long[] unslice(long[] a, long[] b, int origin, int part, boolean[] mask, int idx) { @@ -6001,7 +6001,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void unsliceLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6018,7 +6018,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Long256VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, LongVector256Tests::unslice); } static long BITWISE_BLEND(long a, long b, long c) { @@ -6030,7 +6030,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6045,11 +6045,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Long256VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, LongVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6062,11 +6062,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Long256VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, LongVector256Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6084,11 +6084,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Long256VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, LongVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6099,11 +6099,11 @@ public class Long256VectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Long256VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, LongVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6114,11 +6114,11 @@ public class Long256VectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Long256VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, LongVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6129,11 +6129,11 @@ public class Long256VectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Long256VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, LongVector256Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6144,11 +6144,11 @@ public class Long256VectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Long256VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, LongVector256Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6163,11 +6163,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Long256VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, LongVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector256TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6182,11 +6182,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Long256VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, LongVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6197,11 +6197,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Long256VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6212,11 +6212,11 @@ public class Long256VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Long256VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVector256Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector256TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6230,7 +6230,7 @@ public class Long256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Long256VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, LongVector256Tests::BITWISE_BLEND); } static long NEG(long a) { @@ -6242,7 +6242,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NEGLong256VectorTests(IntFunction fa) { + static void NEGLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6253,11 +6253,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::NEG); + assertArraysEquals(r, a, LongVector256Tests::NEG); } @Test(dataProvider = "longUnaryOpProvider") - static void negLong256VectorTests(IntFunction fa) { + static void negLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6268,11 +6268,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::neg); + assertArraysEquals(r, a, LongVector256Tests::neg); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NEGMaskedLong256VectorTests(IntFunction fa, + static void NEGMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6286,7 +6286,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::NEG); + assertArraysEquals(r, a, mask, LongVector256Tests::NEG); } static long ABS(long a) { @@ -6298,7 +6298,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ABSLong256VectorTests(IntFunction fa) { + static void ABSLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6309,11 +6309,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::ABS); + assertArraysEquals(r, a, LongVector256Tests::ABS); } @Test(dataProvider = "longUnaryOpProvider") - static void absLong256VectorTests(IntFunction fa) { + static void absLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6324,11 +6324,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::abs); + assertArraysEquals(r, a, LongVector256Tests::abs); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ABSMaskedLong256VectorTests(IntFunction fa, + static void ABSMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6342,7 +6342,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::ABS); + assertArraysEquals(r, a, mask, LongVector256Tests::ABS); } static long NOT(long a) { @@ -6354,7 +6354,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NOTLong256VectorTests(IntFunction fa) { + static void NOTLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6365,11 +6365,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::NOT); + assertArraysEquals(r, a, LongVector256Tests::NOT); } @Test(dataProvider = "longUnaryOpProvider") - static void notLong256VectorTests(IntFunction fa) { + static void notLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6380,11 +6380,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::not); + assertArraysEquals(r, a, LongVector256Tests::not); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NOTMaskedLong256VectorTests(IntFunction fa, + static void NOTMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6398,7 +6398,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::NOT); + assertArraysEquals(r, a, mask, LongVector256Tests::NOT); } static long ZOMO(long a) { @@ -6406,7 +6406,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZOMOLong256VectorTests(IntFunction fa) { + static void ZOMOLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6417,11 +6417,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::ZOMO); + assertArraysEquals(r, a, LongVector256Tests::ZOMO); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ZOMOMaskedLong256VectorTests(IntFunction fa, + static void ZOMOMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6435,7 +6435,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::ZOMO); + assertArraysEquals(r, a, mask, LongVector256Tests::ZOMO); } static long BIT_COUNT(long a) { @@ -6443,7 +6443,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BIT_COUNTLong256VectorTests(IntFunction fa) { + static void BIT_COUNTLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6454,11 +6454,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::BIT_COUNT); + assertArraysEquals(r, a, LongVector256Tests::BIT_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void BIT_COUNTMaskedLong256VectorTests(IntFunction fa, + static void BIT_COUNTMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6472,7 +6472,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, LongVector256Tests::BIT_COUNT); } static long TRAILING_ZEROS_COUNT(long a) { @@ -6480,7 +6480,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void TRAILING_ZEROS_COUNTLong256VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6491,11 +6491,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVector256Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedLong256VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6509,7 +6509,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVector256Tests::TRAILING_ZEROS_COUNT); } static long LEADING_ZEROS_COUNT(long a) { @@ -6517,7 +6517,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LEADING_ZEROS_COUNTLong256VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6528,11 +6528,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVector256Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedLong256VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6546,7 +6546,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVector256Tests::LEADING_ZEROS_COUNT); } static long REVERSE(long a) { @@ -6554,7 +6554,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSELong256VectorTests(IntFunction fa) { + static void REVERSELongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6565,11 +6565,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::REVERSE); + assertArraysEquals(r, a, LongVector256Tests::REVERSE); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSEMaskedLong256VectorTests(IntFunction fa, + static void REVERSEMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6583,7 +6583,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::REVERSE); + assertArraysEquals(r, a, mask, LongVector256Tests::REVERSE); } static long REVERSE_BYTES(long a) { @@ -6591,7 +6591,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSE_BYTESLong256VectorTests(IntFunction fa) { + static void REVERSE_BYTESLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6602,11 +6602,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, LongVector256Tests::REVERSE_BYTES); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedLong256VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedLongVector256Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6620,7 +6620,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long256VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, LongVector256Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6628,7 +6628,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandLong256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandLongVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6641,7 +6641,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::band); + assertArraysEquals(r, a, b, LongVector256Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6649,7 +6649,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorLong256VectorTests(IntFunction fa, IntFunction fb) { + static void maskorLongVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6662,7 +6662,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::bor); + assertArraysEquals(r, a, b, LongVector256Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6670,7 +6670,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorLong256VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorLongVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6683,7 +6683,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::bxor); + assertArraysEquals(r, a, b, LongVector256Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6691,7 +6691,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotLong256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotLongVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6704,7 +6704,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::bandNot); + assertArraysEquals(r, a, b, LongVector256Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6712,7 +6712,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqLong256VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqLongVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6725,7 +6725,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long256VectorTests::beq); + assertArraysEquals(r, a, b, LongVector256Tests::beq); } static boolean unot(boolean a) { @@ -6733,7 +6733,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotLong256VectorTests(IntFunction fa) { + static void masknotLongVector256Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6744,7 +6744,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long256VectorTests::unot); + assertArraysEquals(r, a, LongVector256Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6761,7 +6761,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongLong256VectorTests(IntFunction fa) { + static void maskFromToLongLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6775,7 +6775,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLong256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltLongVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6791,7 +6791,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqLongVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6807,7 +6807,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longtoIntUnaryOpProvider") - static void toIntArrayLong256VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayLongVector256TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6818,7 +6818,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toLongArrayLong256VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayLongVector256TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6829,7 +6829,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toDoubleArrayLong256VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayLongVector256TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6840,7 +6840,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toStringLong256VectorTestsSmokeTest(IntFunction fa) { + static void toStringLongVector256TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6853,7 +6853,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void hashCodeLong256VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeLongVector256TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6869,7 +6869,7 @@ public class Long256VectorTests extends AbstractVectorTest { @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLongLong256VectorTests(IntFunction fa) { + static void ADDReduceLongLongVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -6885,11 +6885,11 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long256VectorTests::ADDReduce, Long256VectorTests::ADDReduceAll); + LongVector256Tests::ADDReduce, LongVector256Tests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLongLong256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongLongVector256TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6907,11 +6907,11 @@ public class Long256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long256VectorTests::ADDReduceMasked, Long256VectorTests::ADDReduceAllMasked); + LongVector256Tests::ADDReduceMasked, LongVector256Tests::ADDReduceAllMasked); } @Test(dataProvider = "longUnaryOpSelectFromProvider") - static void SelectFromLong256VectorTests(IntFunction fa, + static void SelectFromLongVector256Tests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); long[] order = fs.apply(a.length, SPECIES.length()); @@ -6927,7 +6927,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorLong256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorLongVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] idx = fc.apply(SPECIES.length()); @@ -6945,7 +6945,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpSelectFromMaskProvider") - static void SelectFromLong256VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromLongVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -6964,7 +6964,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousLong256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousLongVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6980,7 +6980,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringLong256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringLongVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6994,7 +6994,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsLong256VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsLongVector256TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7008,7 +7008,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsLong256VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsLongVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7024,7 +7024,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeLong256VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeLongVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7046,7 +7046,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountLong256VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountLongVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7057,7 +7057,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long256VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, LongVector256Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7071,7 +7071,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueLong256VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueLongVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7082,7 +7082,7 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long256VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, LongVector256Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7096,7 +7096,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueLong256VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueLongVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7107,11 +7107,11 @@ public class Long256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long256VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, LongVector256Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressLong256VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressLongVector256TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7139,7 +7139,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLong256VectorTestsSmokeTest(int offset) { + static void indexInRangeLongVector256TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7153,7 +7153,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongLong256VectorTestsSmokeTest(int offset) { + static void indexInRangeLongLongVector256TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7180,14 +7180,14 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundLong256VectorTestsSmokeTest(int length) { + static void loopBoundLongVector256TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongLong256VectorTestsSmokeTest(int _length) { + static void loopBoundLongLongVector256TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7195,21 +7195,21 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeLong256VectorTestsSmokeTest() { + static void ElementSizeLongVector256TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Long.SIZE); } @Test - static void VectorShapeLong256VectorTestsSmokeTest() { + static void VectorShapeLongVector256TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_256_BIT)); } @Test - static void ShapeWithLanesLong256VectorTestsSmokeTest() { + static void ShapeWithLanesLongVector256TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(long.class); @@ -7217,32 +7217,32 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeLong256VectorTestsSmokeTest() { + static void ElementTypeLongVector256TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementType() == long.class); } @Test - static void SpeciesElementSizeLong256VectorTestsSmokeTest() { + static void SpeciesElementSizeLongVector256TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementSize() == Long.SIZE); } @Test - static void VectorTypeLong256VectorTestsSmokeTest() { + static void VectorTypeLongVector256TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesLong256VectorTestsSmokeTest() { + static void WithLanesLongVector256TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(long.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeLong256VectorTestsSmokeTest() { + static void WithShapeLongVector256TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7250,7 +7250,7 @@ public class Long256VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueLong256VectorTestsSmokeTest() { + static void MaskAllTrueLongVector256TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Long512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/LongVector512LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Long512VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/LongVector512LoadStoreTests.java index dfdafc91d1a..095616595f8 100644 --- a/test/jdk/jdk/incubator/vector/Long512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/LongVector512LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Long512VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation LongVector512LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Long512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class LongVector512LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = LongVector.SPECIES_512; diff --git a/test/jdk/jdk/incubator/vector/Long512VectorTests.java b/test/jdk/jdk/incubator/vector/LongVector512Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Long512VectorTests.java rename to test/jdk/jdk/incubator/vector/LongVector512Tests.java index a575c80a0ce..503bd7942f2 100644 --- a/test/jdk/jdk/incubator/vector/Long512VectorTests.java +++ b/test/jdk/jdk/incubator/vector/LongVector512Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Long512VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation LongVector512Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Long512VectorTests extends AbstractVectorTest { +public class LongVector512Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = LongVector.SPECIES_512; @@ -1683,7 +1683,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLong512VectorTests(IntFunction fa, IntFunction fb) { + static void ADDLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1696,7 +1696,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::ADD); + assertArraysEquals(r, a, b, LongVector512Tests::ADD); } static long add(long a, long b) { @@ -1704,7 +1704,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void addLong512VectorTests(IntFunction fa, IntFunction fb) { + static void addLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1715,11 +1715,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long512VectorTests::add); + assertArraysEquals(r, a, b, LongVector512Tests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1735,11 +1735,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::ADD); + assertArraysEquals(r, a, b, mask, LongVector512Tests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1753,7 +1753,7 @@ public class Long512VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long512VectorTests::add); + assertArraysEquals(r, a, b, mask, LongVector512Tests::add); } static long SUB(long a, long b) { @@ -1761,7 +1761,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void SUBLong512VectorTests(IntFunction fa, IntFunction fb) { + static void SUBLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1774,7 +1774,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::SUB); + assertArraysEquals(r, a, b, LongVector512Tests::SUB); } static long sub(long a, long b) { @@ -1782,7 +1782,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void subLong512VectorTests(IntFunction fa, IntFunction fb) { + static void subLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1793,11 +1793,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long512VectorTests::sub); + assertArraysEquals(r, a, b, LongVector512Tests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void SUBLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1813,11 +1813,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::SUB); + assertArraysEquals(r, a, b, mask, LongVector512Tests::SUB); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1831,7 +1831,7 @@ public class Long512VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long512VectorTests::sub); + assertArraysEquals(r, a, b, mask, LongVector512Tests::sub); } static long MUL(long a, long b) { @@ -1839,7 +1839,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MULLong512VectorTests(IntFunction fa, IntFunction fb) { + static void MULLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1852,7 +1852,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::MUL); + assertArraysEquals(r, a, b, LongVector512Tests::MUL); } static long mul(long a, long b) { @@ -1860,7 +1860,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void mulLong512VectorTests(IntFunction fa, IntFunction fb) { + static void mulLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1871,11 +1871,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long512VectorTests::mul); + assertArraysEquals(r, a, b, LongVector512Tests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void MULLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1891,11 +1891,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::MUL); + assertArraysEquals(r, a, b, mask, LongVector512Tests::MUL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1909,7 +1909,7 @@ public class Long512VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long512VectorTests::mul); + assertArraysEquals(r, a, b, mask, LongVector512Tests::mul); } static long DIV(long a, long b) { @@ -1917,7 +1917,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void DIVLong512VectorTests(IntFunction fa, IntFunction fb) { + static void DIVLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1932,7 +1932,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::DIV); + assertArraysEquals(r, a, b, LongVector512Tests::DIV); } static long div(long a, long b) { @@ -1940,7 +1940,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void divLong512VectorTests(IntFunction fa, IntFunction fb) { + static void divLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1955,11 +1955,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::div); + assertArraysEquals(r, a, b, LongVector512Tests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void DIVLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1977,11 +1977,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::DIV); + assertArraysEquals(r, a, b, mask, LongVector512Tests::DIV); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1999,7 +1999,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::div); + assertArraysEquals(r, a, b, mask, LongVector512Tests::div); } static long FIRST_NONZERO(long a, long b) { @@ -2007,7 +2007,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void FIRST_NONZEROLong512VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2020,11 +2020,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, LongVector512Tests::FIRST_NONZERO); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void FIRST_NONZEROLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2040,7 +2040,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, LongVector512Tests::FIRST_NONZERO); } static long AND(long a, long b) { @@ -2048,7 +2048,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLong512VectorTests(IntFunction fa, IntFunction fb) { + static void ANDLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2061,7 +2061,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::AND); + assertArraysEquals(r, a, b, LongVector512Tests::AND); } static long and(long a, long b) { @@ -2069,7 +2069,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void andLong512VectorTests(IntFunction fa, IntFunction fb) { + static void andLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2080,11 +2080,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long512VectorTests::and); + assertArraysEquals(r, a, b, LongVector512Tests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2100,7 +2100,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::AND); + assertArraysEquals(r, a, b, mask, LongVector512Tests::AND); } static long AND_NOT(long a, long b) { @@ -2108,7 +2108,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void AND_NOTLong512VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2121,11 +2121,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::AND_NOT); + assertArraysEquals(r, a, b, LongVector512Tests::AND_NOT); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void AND_NOTLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2141,7 +2141,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, LongVector512Tests::AND_NOT); } static long OR(long a, long b) { @@ -2149,7 +2149,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong512VectorTests(IntFunction fa, IntFunction fb) { + static void ORLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2162,7 +2162,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::OR); + assertArraysEquals(r, a, b, LongVector512Tests::OR); } static long or(long a, long b) { @@ -2170,7 +2170,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void orLong512VectorTests(IntFunction fa, IntFunction fb) { + static void orLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2181,11 +2181,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long512VectorTests::or); + assertArraysEquals(r, a, b, LongVector512Tests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2201,7 +2201,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::OR); + assertArraysEquals(r, a, b, mask, LongVector512Tests::OR); } static long XOR(long a, long b) { @@ -2209,7 +2209,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void XORLong512VectorTests(IntFunction fa, IntFunction fb) { + static void XORLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2222,11 +2222,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::XOR); + assertArraysEquals(r, a, b, LongVector512Tests::XOR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void XORLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2242,7 +2242,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::XOR); + assertArraysEquals(r, a, b, mask, LongVector512Tests::XOR); } static long COMPRESS_BITS(long a, long b) { @@ -2250,7 +2250,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void COMPRESS_BITSLong512VectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2263,11 +2263,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, LongVector512Tests::COMPRESS_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void COMPRESS_BITSLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2283,7 +2283,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, LongVector512Tests::COMPRESS_BITS); } static long EXPAND_BITS(long a, long b) { @@ -2291,7 +2291,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void EXPAND_BITSLong512VectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2304,11 +2304,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, LongVector512Tests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void EXPAND_BITSLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2324,11 +2324,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, LongVector512Tests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpProvider") - static void addLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2338,11 +2338,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2355,11 +2355,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, LongVector512Tests::add); } @Test(dataProvider = "longBinaryOpProvider") - static void subLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2369,11 +2369,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2386,11 +2386,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, LongVector512Tests::sub); } @Test(dataProvider = "longBinaryOpProvider") - static void mulLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2400,11 +2400,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, LongVector512Tests::mul); } @Test(dataProvider = "longBinaryOpProvider") - static void divLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2433,11 +2433,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2452,11 +2452,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, LongVector512Tests::div); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2466,11 +2466,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void orLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2480,11 +2480,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::or); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2497,11 +2497,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, LongVector512Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2511,11 +2511,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void andLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2525,11 +2525,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::and); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2542,11 +2542,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, LongVector512Tests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2556,11 +2556,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Long512VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, LongVector512Tests::OR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2573,11 +2573,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Long512VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVector512Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLong512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDLongVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2587,11 +2587,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Long512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, LongVector512Tests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLong512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDLongVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2604,7 +2604,7 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Long512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVector512Tests::ADD); } static long LSHL(long a, long b) { @@ -2612,7 +2612,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLong512VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2625,11 +2625,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::LSHL); + assertArraysEquals(r, a, b, LongVector512Tests::LSHL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2645,7 +2645,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, LongVector512Tests::LSHL); } static long ASHR(long a, long b) { @@ -2653,7 +2653,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLong512VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2666,11 +2666,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::ASHR); + assertArraysEquals(r, a, b, LongVector512Tests::ASHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2686,7 +2686,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, LongVector512Tests::ASHR); } static long LSHR(long a, long b) { @@ -2694,7 +2694,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLong512VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2707,11 +2707,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::LSHR); + assertArraysEquals(r, a, b, LongVector512Tests::LSHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2727,7 +2727,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, LongVector512Tests::LSHR); } static long LSHL_unary(long a, long b) { @@ -2735,7 +2735,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLong512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLLongVector512TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2747,11 +2747,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long512VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, LongVector512Tests::LSHL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLong512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2766,7 +2766,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector512Tests::LSHL_unary); } static long LSHR_unary(long a, long b) { @@ -2774,7 +2774,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLong512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRLongVector512TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2786,11 +2786,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long512VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, LongVector512Tests::LSHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLong512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2805,7 +2805,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector512Tests::LSHR_unary); } static long ASHR_unary(long a, long b) { @@ -2813,7 +2813,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLong512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRLongVector512TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2825,11 +2825,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long512VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, LongVector512Tests::ASHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLong512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2844,7 +2844,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector512Tests::ASHR_unary); } static long ROR(long a, long b) { @@ -2852,7 +2852,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLong512VectorTests(IntFunction fa, IntFunction fb) { + static void RORLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2865,11 +2865,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::ROR); + assertArraysEquals(r, a, b, LongVector512Tests::ROR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2885,7 +2885,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::ROR); + assertArraysEquals(r, a, b, mask, LongVector512Tests::ROR); } static long ROL(long a, long b) { @@ -2893,7 +2893,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLong512VectorTests(IntFunction fa, IntFunction fb) { + static void ROLLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2906,11 +2906,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::ROL); + assertArraysEquals(r, a, b, LongVector512Tests::ROL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2926,7 +2926,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::ROL); + assertArraysEquals(r, a, b, mask, LongVector512Tests::ROL); } static long ROR_unary(long a, long b) { @@ -2934,7 +2934,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLong512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORLongVector512TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2946,11 +2946,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long512VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, LongVector512Tests::ROR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLong512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORLongVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2965,7 +2965,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector512Tests::ROR_unary); } static long ROL_unary(long a, long b) { @@ -2973,7 +2973,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLong512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLLongVector512TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2985,11 +2985,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long512VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, LongVector512Tests::ROL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLong512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLLongVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3004,14 +3004,14 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector512Tests::ROL_unary); } static long LSHR_binary_const(long a) { return (long)((a >>> CONST_SHIFT)); } @Test(dataProvider = "longUnaryOpProvider") - static void LSHRLong512VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRLongVector512TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3022,11 +3022,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long512VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, LongVector512Tests::LSHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHRLong512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRLongVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3040,7 +3040,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long512VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector512Tests::LSHR_binary_const); } static long LSHL_binary_const(long a) { @@ -3048,7 +3048,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LSHLLong512VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLLongVector512TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3059,11 +3059,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long512VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, LongVector512Tests::LSHL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHLLong512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLLongVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3077,7 +3077,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long512VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, LongVector512Tests::LSHL_binary_const); } static long ASHR_binary_const(long a) { @@ -3085,7 +3085,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ASHRLong512VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRLongVector512TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3096,11 +3096,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long512VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, LongVector512Tests::ASHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ASHRLong512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRLongVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3114,7 +3114,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long512VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector512Tests::ASHR_binary_const); } static long ROR_binary_const(long a) { @@ -3122,7 +3122,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void RORLong512VectorTestsScalarShiftConst(IntFunction fa) { + static void RORLongVector512TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3133,11 +3133,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long512VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, LongVector512Tests::ROR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void RORLong512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORLongVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3151,7 +3151,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long512VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector512Tests::ROR_binary_const); } static long ROL_binary_const(long a) { @@ -3159,7 +3159,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ROLLong512VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLLongVector512TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3170,11 +3170,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long512VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, LongVector512Tests::ROL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ROLLong512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLLongVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3188,14 +3188,14 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long512VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, LongVector512Tests::ROL_binary_const); } static LongVector bv_MIN = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MINLong512VectorTestsWithMemOp(IntFunction fa) { + static void MINLongVector512TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3206,13 +3206,13 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long512VectorTests::MIN); + assertArraysEquals(r, a, (long)10, LongVector512Tests::MIN); } static LongVector bv_min = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void minLong512VectorTestsWithMemOp(IntFunction fa) { + static void minLongVector512TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3223,13 +3223,13 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long512VectorTests::min); + assertArraysEquals(r, a, (long)10, LongVector512Tests::min); } static LongVector bv_MIN_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINLong512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINLongVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3242,13 +3242,13 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, Long512VectorTests::MIN); + assertArraysEquals(r, a, (long)10, mask, LongVector512Tests::MIN); } static LongVector bv_MAX = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MAXLong512VectorTestsWithMemOp(IntFunction fa) { + static void MAXLongVector512TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3259,13 +3259,13 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long512VectorTests::MAX); + assertArraysEquals(r, a, (long)10, LongVector512Tests::MAX); } static LongVector bv_max = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void maxLong512VectorTestsWithMemOp(IntFunction fa) { + static void maxLongVector512TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3276,13 +3276,13 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long512VectorTests::max); + assertArraysEquals(r, a, (long)10, LongVector512Tests::max); } static LongVector bv_MAX_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXLong512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXLongVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3295,7 +3295,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, Long512VectorTests::MAX); + assertArraysEquals(r, a, (long)10, mask, LongVector512Tests::MAX); } static long MIN(long a, long b) { @@ -3303,7 +3303,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MINLong512VectorTests(IntFunction fa, IntFunction fb) { + static void MINLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3316,7 +3316,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::MIN); + assertArraysEquals(r, a, b, LongVector512Tests::MIN); } static long min(long a, long b) { @@ -3324,7 +3324,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void minLong512VectorTests(IntFunction fa, IntFunction fb) { + static void minLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3335,7 +3335,7 @@ public class Long512VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long512VectorTests::min); + assertArraysEquals(r, a, b, LongVector512Tests::min); } static long MAX(long a, long b) { @@ -3343,7 +3343,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLong512VectorTests(IntFunction fa, IntFunction fb) { + static void MAXLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3356,7 +3356,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::MAX); + assertArraysEquals(r, a, b, LongVector512Tests::MAX); } static long max(long a, long b) { @@ -3364,7 +3364,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void maxLong512VectorTests(IntFunction fa, IntFunction fb) { + static void maxLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3375,7 +3375,7 @@ public class Long512VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long512VectorTests::max); + assertArraysEquals(r, a, b, LongVector512Tests::max); } static long UMIN(long a, long b) { @@ -3383,7 +3383,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMINLong512VectorTests(IntFunction fa, IntFunction fb) { + static void UMINLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3396,11 +3396,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::UMIN); + assertArraysEquals(r, a, b, LongVector512Tests::UMIN); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMINLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3416,7 +3416,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, LongVector512Tests::UMIN); } static long UMAX(long a, long b) { @@ -3424,7 +3424,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMAXLong512VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3437,11 +3437,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::UMAX); + assertArraysEquals(r, a, b, LongVector512Tests::UMAX); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMAXLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3457,7 +3457,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, LongVector512Tests::UMAX); } static long SADD(long a, long b) { @@ -3465,7 +3465,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SADDLong512VectorTests(IntFunction fa, IntFunction fb) { + static void SADDLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3478,11 +3478,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::SADD); + assertArraysEquals(r, a, b, LongVector512Tests::SADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SADDLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3498,7 +3498,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::SADD); + assertArraysEquals(r, a, b, mask, LongVector512Tests::SADD); } static long SSUB(long a, long b) { @@ -3506,7 +3506,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SSUBLong512VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3519,11 +3519,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::SSUB); + assertArraysEquals(r, a, b, LongVector512Tests::SSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SSUBLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3539,7 +3539,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, LongVector512Tests::SSUB); } static long SUADD(long a, long b) { @@ -3547,7 +3547,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUADDLong512VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3560,11 +3560,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::SUADD); + assertArraysEquals(r, a, b, LongVector512Tests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUADDLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3580,7 +3580,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, LongVector512Tests::SUADD); } static long SUSUB(long a, long b) { @@ -3588,7 +3588,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUSUBLong512VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3601,11 +3601,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::SUSUB); + assertArraysEquals(r, a, b, LongVector512Tests::SUSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUSUBLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3621,11 +3621,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, LongVector512Tests::SUSUB); } @Test(dataProvider = "longBinaryOpProvider") - static void MINLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3635,11 +3635,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::MIN); } @Test(dataProvider = "longBinaryOpProvider") - static void minLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3649,11 +3649,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::min); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::min); } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3663,11 +3663,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::MAX); } @Test(dataProvider = "longBinaryOpProvider") - static void maxLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3677,10 +3677,10 @@ public class Long512VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long512VectorTests::max); + assertBroadcastArraysEquals(r, a, b, LongVector512Tests::max); } @Test(dataProvider = "longSaturatingBinaryOpAssocProvider") - static void SUADDAssocLong512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocLongVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -3697,11 +3697,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Long512VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, LongVector512Tests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3722,7 +3722,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Long512VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, LongVector512Tests::SUADD); } static long ANDReduce(long[] a, int idx) { @@ -3744,7 +3744,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ANDReduceLong512VectorTests(IntFunction fa) { + static void ANDReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3760,7 +3760,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::ANDReduce, Long512VectorTests::ANDReduceAll); + LongVector512Tests::ANDReduce, LongVector512Tests::ANDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3806,7 +3806,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ANDReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3824,7 +3824,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::ANDReduceMasked, Long512VectorTests::ANDReduceAllMasked); + LongVector512Tests::ANDReduceMasked, LongVector512Tests::ANDReduceAllMasked); } static long ORReduce(long[] a, int idx) { @@ -3846,7 +3846,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ORReduceLong512VectorTests(IntFunction fa) { + static void ORReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3862,7 +3862,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::ORReduce, Long512VectorTests::ORReduceAll); + LongVector512Tests::ORReduce, LongVector512Tests::ORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3908,7 +3908,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ORReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3926,7 +3926,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::ORReduceMasked, Long512VectorTests::ORReduceAllMasked); + LongVector512Tests::ORReduceMasked, LongVector512Tests::ORReduceAllMasked); } static long XORReduce(long[] a, int idx) { @@ -3948,7 +3948,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void XORReduceLong512VectorTests(IntFunction fa) { + static void XORReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3964,7 +3964,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::XORReduce, Long512VectorTests::XORReduceAll); + LongVector512Tests::XORReduce, LongVector512Tests::XORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4010,7 +4010,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void XORReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4028,7 +4028,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::XORReduceMasked, Long512VectorTests::XORReduceAllMasked); + LongVector512Tests::XORReduceMasked, LongVector512Tests::XORReduceAllMasked); } static long ADDReduce(long[] a, int idx) { @@ -4050,7 +4050,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLong512VectorTests(IntFunction fa) { + static void ADDReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4066,7 +4066,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::ADDReduce, Long512VectorTests::ADDReduceAll); + LongVector512Tests::ADDReduce, LongVector512Tests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4112,7 +4112,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4130,7 +4130,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::ADDReduceMasked, Long512VectorTests::ADDReduceAllMasked); + LongVector512Tests::ADDReduceMasked, LongVector512Tests::ADDReduceAllMasked); } static long MULReduce(long[] a, int idx) { @@ -4152,7 +4152,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MULReduceLong512VectorTests(IntFunction fa) { + static void MULReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4168,7 +4168,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::MULReduce, Long512VectorTests::MULReduceAll); + LongVector512Tests::MULReduce, LongVector512Tests::MULReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4214,7 +4214,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MULReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4232,7 +4232,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::MULReduceMasked, Long512VectorTests::MULReduceAllMasked); + LongVector512Tests::MULReduceMasked, LongVector512Tests::MULReduceAllMasked); } static long MINReduce(long[] a, int idx) { @@ -4254,7 +4254,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MINReduceLong512VectorTests(IntFunction fa) { + static void MINReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4270,7 +4270,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::MINReduce, Long512VectorTests::MINReduceAll); + LongVector512Tests::MINReduce, LongVector512Tests::MINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4316,7 +4316,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4334,7 +4334,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::MINReduceMasked, Long512VectorTests::MINReduceAllMasked); + LongVector512Tests::MINReduceMasked, LongVector512Tests::MINReduceAllMasked); } static long MAXReduce(long[] a, int idx) { @@ -4356,7 +4356,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MAXReduceLong512VectorTests(IntFunction fa) { + static void MAXReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4372,7 +4372,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::MAXReduce, Long512VectorTests::MAXReduceAll); + LongVector512Tests::MAXReduce, LongVector512Tests::MAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4418,7 +4418,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4436,7 +4436,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::MAXReduceMasked, Long512VectorTests::MAXReduceAllMasked); + LongVector512Tests::MAXReduceMasked, LongVector512Tests::MAXReduceAllMasked); } static long UMINReduce(long[] a, int idx) { @@ -4458,7 +4458,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMINReduceLong512VectorTests(IntFunction fa) { + static void UMINReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4474,7 +4474,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::UMINReduce, Long512VectorTests::UMINReduceAll); + LongVector512Tests::UMINReduce, LongVector512Tests::UMINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4520,7 +4520,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMINReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4538,7 +4538,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::UMINReduceMasked, Long512VectorTests::UMINReduceAllMasked); + LongVector512Tests::UMINReduceMasked, LongVector512Tests::UMINReduceAllMasked); } static long UMAXReduce(long[] a, int idx) { @@ -4560,7 +4560,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMAXReduceLong512VectorTests(IntFunction fa) { + static void UMAXReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4576,7 +4576,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::UMAXReduce, Long512VectorTests::UMAXReduceAll); + LongVector512Tests::UMAXReduce, LongVector512Tests::UMAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4622,7 +4622,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMAXReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4640,7 +4640,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::UMAXReduceMasked, Long512VectorTests::UMAXReduceAllMasked); + LongVector512Tests::UMAXReduceMasked, LongVector512Tests::UMAXReduceAllMasked); } static long FIRST_NONZEROReduce(long[] a, int idx) { @@ -4662,7 +4662,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void FIRST_NONZEROReduceLong512VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4678,7 +4678,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::FIRST_NONZEROReduce, Long512VectorTests::FIRST_NONZEROReduceAll); + LongVector512Tests::FIRST_NONZEROReduce, LongVector512Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4724,7 +4724,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void FIRST_NONZEROReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4742,7 +4742,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::FIRST_NONZEROReduceMasked, Long512VectorTests::FIRST_NONZEROReduceAllMasked); + LongVector512Tests::FIRST_NONZEROReduceMasked, LongVector512Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4755,7 +4755,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueLong512VectorTests(IntFunction fm) { + static void anyTrueLongVector512Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4766,7 +4766,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Long512VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, LongVector512Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4779,7 +4779,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueLong512VectorTests(IntFunction fm) { + static void allTrueLongVector512Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4790,7 +4790,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Long512VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, LongVector512Tests::allTrue); } static long SUADDReduce(long[] a, int idx) { @@ -4812,7 +4812,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingUnaryOpProvider") - static void SUADDReduceLong512VectorTests(IntFunction fa) { + static void SUADDReduceLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4828,7 +4828,7 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::SUADDReduce, Long512VectorTests::SUADDReduceAll); + LongVector512Tests::SUADDReduce, LongVector512Tests::SUADDReduceAll); } @Test(dataProvider = "longSaturatingUnaryOpProvider") @@ -4873,7 +4873,7 @@ public class Long512VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "longSaturatingUnaryOpMaskProvider") - static void SUADDReduceLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4891,11 +4891,11 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::SUADDReduceMasked, Long512VectorTests::SUADDReduceAllMasked); + LongVector512Tests::SUADDReduceMasked, LongVector512Tests::SUADDReduceAllMasked); } @Test(dataProvider = "longBinaryOpProvider") - static void withLong512VectorTests(IntFunction fa, IntFunction fb) { + static void withLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -4918,7 +4918,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_DEFAULTLong512VectorTests(IntFunction fa) { + static void IS_DEFAULTLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4935,7 +4935,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_DEFAULTMaskedLong512VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4959,7 +4959,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_NEGATIVELong512VectorTests(IntFunction fa) { + static void IS_NEGATIVELongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4976,7 +4976,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_NEGATIVEMaskedLong512VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4996,7 +4996,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLong512VectorTests(IntFunction fa, IntFunction fb) { + static void LTLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5015,7 +5015,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLong512VectorTests(IntFunction fa, IntFunction fb) { + static void ltLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5034,7 +5034,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5057,7 +5057,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GTLong512VectorTests(IntFunction fa, IntFunction fb) { + static void GTLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5076,7 +5076,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GTLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5099,7 +5099,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void EQLong512VectorTests(IntFunction fa, IntFunction fb) { + static void EQLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5118,7 +5118,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLong512VectorTests(IntFunction fa, IntFunction fb) { + static void eqLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5137,7 +5137,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5160,7 +5160,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void NELong512VectorTests(IntFunction fa, IntFunction fb) { + static void NELongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5179,7 +5179,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void NELong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NELongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5202,7 +5202,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LELong512VectorTests(IntFunction fa, IntFunction fb) { + static void LELongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5221,7 +5221,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LELong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LELongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5244,7 +5244,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GELong512VectorTests(IntFunction fa, IntFunction fb) { + static void GELongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5263,7 +5263,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GELong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GELongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5286,7 +5286,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULTLong512VectorTests(IntFunction fa, IntFunction fb) { + static void ULTLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5305,7 +5305,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULTLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5328,7 +5328,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGTLong512VectorTests(IntFunction fa, IntFunction fb) { + static void UGTLongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5347,7 +5347,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGTLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5370,7 +5370,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULELong512VectorTests(IntFunction fa, IntFunction fb) { + static void ULELongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5389,7 +5389,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULELong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULELongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5412,7 +5412,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGELong512VectorTests(IntFunction fa, IntFunction fb) { + static void UGELongVector512Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5431,7 +5431,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGELong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGELongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5454,7 +5454,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5470,7 +5470,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5491,7 +5491,7 @@ public class Long512VectorTests extends AbstractVectorTest { @Test(dataProvider = "longCompareOpProvider") - static void EQLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5507,7 +5507,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5532,7 +5532,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void blendLong512VectorTests(IntFunction fa, IntFunction fb, + static void blendLongVector512Tests(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5548,11 +5548,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long512VectorTests::blend); + assertArraysEquals(r, a, b, mask, LongVector512Tests::blend); } @Test(dataProvider = "longUnaryOpShuffleProvider") - static void RearrangeLong512VectorTests(IntFunction fa, + static void RearrangeLongVector512Tests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5569,7 +5569,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpShuffleMaskProvider") - static void RearrangeLong512VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeLongVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -5587,7 +5587,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void compressLong512VectorTests(IntFunction fa, + static void compressLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5605,7 +5605,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void expandLong512VectorTests(IntFunction fa, + static void expandLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5623,7 +5623,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void getLong512VectorTests(IntFunction fa) { + static void getLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5779,7 +5779,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BroadcastLong512VectorTests(IntFunction fa) { + static void BroadcastLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5793,7 +5793,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZeroLong512VectorTests(IntFunction fa) { + static void ZeroLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5818,7 +5818,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void sliceUnaryLong512VectorTests(IntFunction fa) { + static void sliceUnaryLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5829,7 +5829,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Long512VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, LongVector512Tests::sliceUnary); } static long[] sliceBinary(long[] a, long[] b, int origin, int idx) { @@ -5846,7 +5846,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void sliceBinaryLong512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryLongVector512TestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5859,7 +5859,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Long512VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, LongVector512Tests::sliceBinary); } static long[] slice(long[] a, long[] b, int origin, boolean[] mask, int idx) { @@ -5876,7 +5876,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void sliceLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5893,7 +5893,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Long512VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, LongVector512Tests::slice); } static long[] unsliceUnary(long[] a, int origin, int idx) { @@ -5910,7 +5910,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void unsliceUnaryLong512VectorTests(IntFunction fa) { + static void unsliceUnaryLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5921,7 +5921,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Long512VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, LongVector512Tests::unsliceUnary); } static long[] unsliceBinary(long[] a, long[] b, int origin, int part, int idx) { @@ -5947,7 +5947,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void unsliceBinaryLong512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryLongVector512TestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5961,7 +5961,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Long512VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, LongVector512Tests::unsliceBinary); } static long[] unslice(long[] a, long[] b, int origin, int part, boolean[] mask, int idx) { @@ -6001,7 +6001,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void unsliceLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6018,7 +6018,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Long512VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, LongVector512Tests::unslice); } static long BITWISE_BLEND(long a, long b, long c) { @@ -6030,7 +6030,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6045,11 +6045,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Long512VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, LongVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6062,11 +6062,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Long512VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, LongVector512Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6084,11 +6084,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Long512VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, LongVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6099,11 +6099,11 @@ public class Long512VectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Long512VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, LongVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6114,11 +6114,11 @@ public class Long512VectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Long512VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, LongVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6129,11 +6129,11 @@ public class Long512VectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Long512VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, LongVector512Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6144,11 +6144,11 @@ public class Long512VectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Long512VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, LongVector512Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6163,11 +6163,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Long512VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, LongVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong512VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector512TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6182,11 +6182,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Long512VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, LongVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6197,11 +6197,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Long512VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6212,11 +6212,11 @@ public class Long512VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Long512VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVector512Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong512VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector512TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6230,7 +6230,7 @@ public class Long512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Long512VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, LongVector512Tests::BITWISE_BLEND); } static long NEG(long a) { @@ -6242,7 +6242,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NEGLong512VectorTests(IntFunction fa) { + static void NEGLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6253,11 +6253,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::NEG); + assertArraysEquals(r, a, LongVector512Tests::NEG); } @Test(dataProvider = "longUnaryOpProvider") - static void negLong512VectorTests(IntFunction fa) { + static void negLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6268,11 +6268,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::neg); + assertArraysEquals(r, a, LongVector512Tests::neg); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NEGMaskedLong512VectorTests(IntFunction fa, + static void NEGMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6286,7 +6286,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::NEG); + assertArraysEquals(r, a, mask, LongVector512Tests::NEG); } static long ABS(long a) { @@ -6298,7 +6298,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ABSLong512VectorTests(IntFunction fa) { + static void ABSLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6309,11 +6309,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::ABS); + assertArraysEquals(r, a, LongVector512Tests::ABS); } @Test(dataProvider = "longUnaryOpProvider") - static void absLong512VectorTests(IntFunction fa) { + static void absLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6324,11 +6324,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::abs); + assertArraysEquals(r, a, LongVector512Tests::abs); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ABSMaskedLong512VectorTests(IntFunction fa, + static void ABSMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6342,7 +6342,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::ABS); + assertArraysEquals(r, a, mask, LongVector512Tests::ABS); } static long NOT(long a) { @@ -6354,7 +6354,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NOTLong512VectorTests(IntFunction fa) { + static void NOTLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6365,11 +6365,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::NOT); + assertArraysEquals(r, a, LongVector512Tests::NOT); } @Test(dataProvider = "longUnaryOpProvider") - static void notLong512VectorTests(IntFunction fa) { + static void notLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6380,11 +6380,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::not); + assertArraysEquals(r, a, LongVector512Tests::not); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NOTMaskedLong512VectorTests(IntFunction fa, + static void NOTMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6398,7 +6398,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::NOT); + assertArraysEquals(r, a, mask, LongVector512Tests::NOT); } static long ZOMO(long a) { @@ -6406,7 +6406,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZOMOLong512VectorTests(IntFunction fa) { + static void ZOMOLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6417,11 +6417,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::ZOMO); + assertArraysEquals(r, a, LongVector512Tests::ZOMO); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ZOMOMaskedLong512VectorTests(IntFunction fa, + static void ZOMOMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6435,7 +6435,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::ZOMO); + assertArraysEquals(r, a, mask, LongVector512Tests::ZOMO); } static long BIT_COUNT(long a) { @@ -6443,7 +6443,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BIT_COUNTLong512VectorTests(IntFunction fa) { + static void BIT_COUNTLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6454,11 +6454,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::BIT_COUNT); + assertArraysEquals(r, a, LongVector512Tests::BIT_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void BIT_COUNTMaskedLong512VectorTests(IntFunction fa, + static void BIT_COUNTMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6472,7 +6472,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, LongVector512Tests::BIT_COUNT); } static long TRAILING_ZEROS_COUNT(long a) { @@ -6480,7 +6480,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void TRAILING_ZEROS_COUNTLong512VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6491,11 +6491,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVector512Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedLong512VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6509,7 +6509,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVector512Tests::TRAILING_ZEROS_COUNT); } static long LEADING_ZEROS_COUNT(long a) { @@ -6517,7 +6517,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LEADING_ZEROS_COUNTLong512VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6528,11 +6528,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVector512Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedLong512VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6546,7 +6546,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVector512Tests::LEADING_ZEROS_COUNT); } static long REVERSE(long a) { @@ -6554,7 +6554,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSELong512VectorTests(IntFunction fa) { + static void REVERSELongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6565,11 +6565,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::REVERSE); + assertArraysEquals(r, a, LongVector512Tests::REVERSE); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSEMaskedLong512VectorTests(IntFunction fa, + static void REVERSEMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6583,7 +6583,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::REVERSE); + assertArraysEquals(r, a, mask, LongVector512Tests::REVERSE); } static long REVERSE_BYTES(long a) { @@ -6591,7 +6591,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSE_BYTESLong512VectorTests(IntFunction fa) { + static void REVERSE_BYTESLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6602,11 +6602,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, LongVector512Tests::REVERSE_BYTES); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedLong512VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedLongVector512Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6620,7 +6620,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long512VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, LongVector512Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6628,7 +6628,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandLong512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandLongVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6641,7 +6641,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::band); + assertArraysEquals(r, a, b, LongVector512Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6649,7 +6649,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorLong512VectorTests(IntFunction fa, IntFunction fb) { + static void maskorLongVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6662,7 +6662,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::bor); + assertArraysEquals(r, a, b, LongVector512Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6670,7 +6670,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorLong512VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorLongVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6683,7 +6683,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::bxor); + assertArraysEquals(r, a, b, LongVector512Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6691,7 +6691,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotLong512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotLongVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6704,7 +6704,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::bandNot); + assertArraysEquals(r, a, b, LongVector512Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6712,7 +6712,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqLong512VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqLongVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6725,7 +6725,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long512VectorTests::beq); + assertArraysEquals(r, a, b, LongVector512Tests::beq); } static boolean unot(boolean a) { @@ -6733,7 +6733,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotLong512VectorTests(IntFunction fa) { + static void masknotLongVector512Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6744,7 +6744,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long512VectorTests::unot); + assertArraysEquals(r, a, LongVector512Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6761,7 +6761,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongLong512VectorTests(IntFunction fa) { + static void maskFromToLongLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6775,7 +6775,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLong512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltLongVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6791,7 +6791,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqLongVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6807,7 +6807,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longtoIntUnaryOpProvider") - static void toIntArrayLong512VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayLongVector512TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6818,7 +6818,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toLongArrayLong512VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayLongVector512TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6829,7 +6829,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toDoubleArrayLong512VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayLongVector512TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6840,7 +6840,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toStringLong512VectorTestsSmokeTest(IntFunction fa) { + static void toStringLongVector512TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6853,7 +6853,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void hashCodeLong512VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeLongVector512TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6869,7 +6869,7 @@ public class Long512VectorTests extends AbstractVectorTest { @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLongLong512VectorTests(IntFunction fa) { + static void ADDReduceLongLongVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -6885,11 +6885,11 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long512VectorTests::ADDReduce, Long512VectorTests::ADDReduceAll); + LongVector512Tests::ADDReduce, LongVector512Tests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLongLong512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongLongVector512TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6907,11 +6907,11 @@ public class Long512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long512VectorTests::ADDReduceMasked, Long512VectorTests::ADDReduceAllMasked); + LongVector512Tests::ADDReduceMasked, LongVector512Tests::ADDReduceAllMasked); } @Test(dataProvider = "longUnaryOpSelectFromProvider") - static void SelectFromLong512VectorTests(IntFunction fa, + static void SelectFromLongVector512Tests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); long[] order = fs.apply(a.length, SPECIES.length()); @@ -6927,7 +6927,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorLong512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorLongVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] idx = fc.apply(SPECIES.length()); @@ -6945,7 +6945,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpSelectFromMaskProvider") - static void SelectFromLong512VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromLongVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -6964,7 +6964,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousLong512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousLongVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6980,7 +6980,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringLong512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringLongVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6994,7 +6994,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsLong512VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsLongVector512TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7008,7 +7008,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsLong512VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsLongVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7024,7 +7024,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeLong512VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeLongVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7046,7 +7046,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountLong512VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountLongVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7057,7 +7057,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long512VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, LongVector512Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7071,7 +7071,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueLong512VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueLongVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7082,7 +7082,7 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long512VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, LongVector512Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7096,7 +7096,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueLong512VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueLongVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7107,11 +7107,11 @@ public class Long512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long512VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, LongVector512Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressLong512VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressLongVector512TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7139,7 +7139,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLong512VectorTestsSmokeTest(int offset) { + static void indexInRangeLongVector512TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7153,7 +7153,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongLong512VectorTestsSmokeTest(int offset) { + static void indexInRangeLongLongVector512TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7180,14 +7180,14 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundLong512VectorTestsSmokeTest(int length) { + static void loopBoundLongVector512TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongLong512VectorTestsSmokeTest(int _length) { + static void loopBoundLongLongVector512TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7195,21 +7195,21 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeLong512VectorTestsSmokeTest() { + static void ElementSizeLongVector512TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Long.SIZE); } @Test - static void VectorShapeLong512VectorTestsSmokeTest() { + static void VectorShapeLongVector512TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_512_BIT)); } @Test - static void ShapeWithLanesLong512VectorTestsSmokeTest() { + static void ShapeWithLanesLongVector512TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(long.class); @@ -7217,32 +7217,32 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeLong512VectorTestsSmokeTest() { + static void ElementTypeLongVector512TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementType() == long.class); } @Test - static void SpeciesElementSizeLong512VectorTestsSmokeTest() { + static void SpeciesElementSizeLongVector512TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementSize() == Long.SIZE); } @Test - static void VectorTypeLong512VectorTestsSmokeTest() { + static void VectorTypeLongVector512TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesLong512VectorTestsSmokeTest() { + static void WithLanesLongVector512TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(long.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeLong512VectorTestsSmokeTest() { + static void WithShapeLongVector512TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7250,7 +7250,7 @@ public class Long512VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueLong512VectorTestsSmokeTest() { + static void MaskAllTrueLongVector512TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Long64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/LongVector64LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Long64VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/LongVector64LoadStoreTests.java index c4894fd86a4..c1eb1e87561 100644 --- a/test/jdk/jdk/incubator/vector/Long64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/LongVector64LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Long64VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation LongVector64LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Long64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class LongVector64LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = LongVector.SPECIES_64; diff --git a/test/jdk/jdk/incubator/vector/Long64VectorTests.java b/test/jdk/jdk/incubator/vector/LongVector64Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Long64VectorTests.java rename to test/jdk/jdk/incubator/vector/LongVector64Tests.java index 3118ce5a4a2..6ca3c63054a 100644 --- a/test/jdk/jdk/incubator/vector/Long64VectorTests.java +++ b/test/jdk/jdk/incubator/vector/LongVector64Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Long64VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation LongVector64Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Long64VectorTests extends AbstractVectorTest { +public class LongVector64Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = LongVector.SPECIES_64; @@ -1683,7 +1683,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLong64VectorTests(IntFunction fa, IntFunction fb) { + static void ADDLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1696,7 +1696,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::ADD); + assertArraysEquals(r, a, b, LongVector64Tests::ADD); } static long add(long a, long b) { @@ -1704,7 +1704,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void addLong64VectorTests(IntFunction fa, IntFunction fb) { + static void addLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1715,11 +1715,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long64VectorTests::add); + assertArraysEquals(r, a, b, LongVector64Tests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1735,11 +1735,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::ADD); + assertArraysEquals(r, a, b, mask, LongVector64Tests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1753,7 +1753,7 @@ public class Long64VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long64VectorTests::add); + assertArraysEquals(r, a, b, mask, LongVector64Tests::add); } static long SUB(long a, long b) { @@ -1761,7 +1761,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void SUBLong64VectorTests(IntFunction fa, IntFunction fb) { + static void SUBLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1774,7 +1774,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::SUB); + assertArraysEquals(r, a, b, LongVector64Tests::SUB); } static long sub(long a, long b) { @@ -1782,7 +1782,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void subLong64VectorTests(IntFunction fa, IntFunction fb) { + static void subLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1793,11 +1793,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long64VectorTests::sub); + assertArraysEquals(r, a, b, LongVector64Tests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void SUBLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1813,11 +1813,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::SUB); + assertArraysEquals(r, a, b, mask, LongVector64Tests::SUB); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1831,7 +1831,7 @@ public class Long64VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long64VectorTests::sub); + assertArraysEquals(r, a, b, mask, LongVector64Tests::sub); } static long MUL(long a, long b) { @@ -1839,7 +1839,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MULLong64VectorTests(IntFunction fa, IntFunction fb) { + static void MULLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1852,7 +1852,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::MUL); + assertArraysEquals(r, a, b, LongVector64Tests::MUL); } static long mul(long a, long b) { @@ -1860,7 +1860,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void mulLong64VectorTests(IntFunction fa, IntFunction fb) { + static void mulLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1871,11 +1871,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long64VectorTests::mul); + assertArraysEquals(r, a, b, LongVector64Tests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void MULLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1891,11 +1891,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::MUL); + assertArraysEquals(r, a, b, mask, LongVector64Tests::MUL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1909,7 +1909,7 @@ public class Long64VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Long64VectorTests::mul); + assertArraysEquals(r, a, b, mask, LongVector64Tests::mul); } static long DIV(long a, long b) { @@ -1917,7 +1917,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void DIVLong64VectorTests(IntFunction fa, IntFunction fb) { + static void DIVLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1932,7 +1932,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::DIV); + assertArraysEquals(r, a, b, LongVector64Tests::DIV); } static long div(long a, long b) { @@ -1940,7 +1940,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void divLong64VectorTests(IntFunction fa, IntFunction fb) { + static void divLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1955,11 +1955,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::div); + assertArraysEquals(r, a, b, LongVector64Tests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void DIVLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1977,11 +1977,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::DIV); + assertArraysEquals(r, a, b, mask, LongVector64Tests::DIV); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1999,7 +1999,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::div); + assertArraysEquals(r, a, b, mask, LongVector64Tests::div); } static long FIRST_NONZERO(long a, long b) { @@ -2007,7 +2007,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void FIRST_NONZEROLong64VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2020,11 +2020,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, LongVector64Tests::FIRST_NONZERO); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void FIRST_NONZEROLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2040,7 +2040,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, LongVector64Tests::FIRST_NONZERO); } static long AND(long a, long b) { @@ -2048,7 +2048,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLong64VectorTests(IntFunction fa, IntFunction fb) { + static void ANDLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2061,7 +2061,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::AND); + assertArraysEquals(r, a, b, LongVector64Tests::AND); } static long and(long a, long b) { @@ -2069,7 +2069,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void andLong64VectorTests(IntFunction fa, IntFunction fb) { + static void andLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2080,11 +2080,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long64VectorTests::and); + assertArraysEquals(r, a, b, LongVector64Tests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2100,7 +2100,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::AND); + assertArraysEquals(r, a, b, mask, LongVector64Tests::AND); } static long AND_NOT(long a, long b) { @@ -2108,7 +2108,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void AND_NOTLong64VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2121,11 +2121,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::AND_NOT); + assertArraysEquals(r, a, b, LongVector64Tests::AND_NOT); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void AND_NOTLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2141,7 +2141,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, LongVector64Tests::AND_NOT); } static long OR(long a, long b) { @@ -2149,7 +2149,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong64VectorTests(IntFunction fa, IntFunction fb) { + static void ORLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2162,7 +2162,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::OR); + assertArraysEquals(r, a, b, LongVector64Tests::OR); } static long or(long a, long b) { @@ -2170,7 +2170,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void orLong64VectorTests(IntFunction fa, IntFunction fb) { + static void orLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2181,11 +2181,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long64VectorTests::or); + assertArraysEquals(r, a, b, LongVector64Tests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2201,7 +2201,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::OR); + assertArraysEquals(r, a, b, mask, LongVector64Tests::OR); } static long XOR(long a, long b) { @@ -2209,7 +2209,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void XORLong64VectorTests(IntFunction fa, IntFunction fb) { + static void XORLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2222,11 +2222,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::XOR); + assertArraysEquals(r, a, b, LongVector64Tests::XOR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void XORLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2242,7 +2242,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::XOR); + assertArraysEquals(r, a, b, mask, LongVector64Tests::XOR); } static long COMPRESS_BITS(long a, long b) { @@ -2250,7 +2250,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void COMPRESS_BITSLong64VectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2263,11 +2263,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, LongVector64Tests::COMPRESS_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void COMPRESS_BITSLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2283,7 +2283,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, LongVector64Tests::COMPRESS_BITS); } static long EXPAND_BITS(long a, long b) { @@ -2291,7 +2291,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void EXPAND_BITSLong64VectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2304,11 +2304,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, LongVector64Tests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void EXPAND_BITSLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2324,11 +2324,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, LongVector64Tests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpProvider") - static void addLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2338,11 +2338,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2355,11 +2355,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, LongVector64Tests::add); } @Test(dataProvider = "longBinaryOpProvider") - static void subLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2369,11 +2369,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2386,11 +2386,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, LongVector64Tests::sub); } @Test(dataProvider = "longBinaryOpProvider") - static void mulLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2400,11 +2400,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, LongVector64Tests::mul); } @Test(dataProvider = "longBinaryOpProvider") - static void divLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2433,11 +2433,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2452,11 +2452,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, LongVector64Tests::div); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2466,11 +2466,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void orLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2480,11 +2480,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::or); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2497,11 +2497,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long64VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, LongVector64Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2511,11 +2511,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void andLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2525,11 +2525,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::and); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2542,11 +2542,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Long64VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, LongVector64Tests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLong64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2556,11 +2556,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Long64VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, LongVector64Tests::OR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLong64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2573,11 +2573,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Long64VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVector64Tests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLong64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDLongVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2587,11 +2587,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Long64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, LongVector64Tests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLong64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDLongVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2604,7 +2604,7 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Long64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVector64Tests::ADD); } static long LSHL(long a, long b) { @@ -2612,7 +2612,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLong64VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2625,11 +2625,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::LSHL); + assertArraysEquals(r, a, b, LongVector64Tests::LSHL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2645,7 +2645,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, LongVector64Tests::LSHL); } static long ASHR(long a, long b) { @@ -2653,7 +2653,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLong64VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2666,11 +2666,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::ASHR); + assertArraysEquals(r, a, b, LongVector64Tests::ASHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2686,7 +2686,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, LongVector64Tests::ASHR); } static long LSHR(long a, long b) { @@ -2694,7 +2694,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLong64VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2707,11 +2707,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::LSHR); + assertArraysEquals(r, a, b, LongVector64Tests::LSHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2727,7 +2727,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, LongVector64Tests::LSHR); } static long LSHL_unary(long a, long b) { @@ -2735,7 +2735,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLong64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLLongVector64TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2747,11 +2747,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long64VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, LongVector64Tests::LSHL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLong64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2766,7 +2766,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long64VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector64Tests::LSHL_unary); } static long LSHR_unary(long a, long b) { @@ -2774,7 +2774,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLong64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRLongVector64TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2786,11 +2786,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long64VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, LongVector64Tests::LSHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLong64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2805,7 +2805,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long64VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector64Tests::LSHR_unary); } static long ASHR_unary(long a, long b) { @@ -2813,7 +2813,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLong64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRLongVector64TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2825,11 +2825,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long64VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, LongVector64Tests::ASHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLong64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2844,7 +2844,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long64VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector64Tests::ASHR_unary); } static long ROR(long a, long b) { @@ -2852,7 +2852,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLong64VectorTests(IntFunction fa, IntFunction fb) { + static void RORLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2865,11 +2865,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::ROR); + assertArraysEquals(r, a, b, LongVector64Tests::ROR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2885,7 +2885,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::ROR); + assertArraysEquals(r, a, b, mask, LongVector64Tests::ROR); } static long ROL(long a, long b) { @@ -2893,7 +2893,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLong64VectorTests(IntFunction fa, IntFunction fb) { + static void ROLLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2906,11 +2906,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::ROL); + assertArraysEquals(r, a, b, LongVector64Tests::ROL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2926,7 +2926,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::ROL); + assertArraysEquals(r, a, b, mask, LongVector64Tests::ROL); } static long ROR_unary(long a, long b) { @@ -2934,7 +2934,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLong64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORLongVector64TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2946,11 +2946,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long64VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, LongVector64Tests::ROR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLong64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORLongVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2965,7 +2965,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long64VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector64Tests::ROR_unary); } static long ROL_unary(long a, long b) { @@ -2973,7 +2973,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLong64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLLongVector64TestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2985,11 +2985,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Long64VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, LongVector64Tests::ROL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLong64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLLongVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3004,14 +3004,14 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Long64VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVector64Tests::ROL_unary); } static long LSHR_binary_const(long a) { return (long)((a >>> CONST_SHIFT)); } @Test(dataProvider = "longUnaryOpProvider") - static void LSHRLong64VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRLongVector64TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3022,11 +3022,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long64VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, LongVector64Tests::LSHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHRLong64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRLongVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3040,7 +3040,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long64VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector64Tests::LSHR_binary_const); } static long LSHL_binary_const(long a) { @@ -3048,7 +3048,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LSHLLong64VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLLongVector64TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3059,11 +3059,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long64VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, LongVector64Tests::LSHL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHLLong64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLLongVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3077,7 +3077,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long64VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, LongVector64Tests::LSHL_binary_const); } static long ASHR_binary_const(long a) { @@ -3085,7 +3085,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ASHRLong64VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRLongVector64TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3096,11 +3096,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long64VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, LongVector64Tests::ASHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ASHRLong64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRLongVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3114,7 +3114,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long64VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector64Tests::ASHR_binary_const); } static long ROR_binary_const(long a) { @@ -3122,7 +3122,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void RORLong64VectorTestsScalarShiftConst(IntFunction fa) { + static void RORLongVector64TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3133,11 +3133,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long64VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, LongVector64Tests::ROR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void RORLong64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORLongVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3151,7 +3151,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long64VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, LongVector64Tests::ROR_binary_const); } static long ROL_binary_const(long a) { @@ -3159,7 +3159,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ROLLong64VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLLongVector64TestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3170,11 +3170,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Long64VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, LongVector64Tests::ROL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ROLLong64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLLongVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3188,14 +3188,14 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Long64VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, LongVector64Tests::ROL_binary_const); } static LongVector bv_MIN = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MINLong64VectorTestsWithMemOp(IntFunction fa) { + static void MINLongVector64TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3206,13 +3206,13 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long64VectorTests::MIN); + assertArraysEquals(r, a, (long)10, LongVector64Tests::MIN); } static LongVector bv_min = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void minLong64VectorTestsWithMemOp(IntFunction fa) { + static void minLongVector64TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3223,13 +3223,13 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long64VectorTests::min); + assertArraysEquals(r, a, (long)10, LongVector64Tests::min); } static LongVector bv_MIN_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINLong64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINLongVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3242,13 +3242,13 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, Long64VectorTests::MIN); + assertArraysEquals(r, a, (long)10, mask, LongVector64Tests::MIN); } static LongVector bv_MAX = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MAXLong64VectorTestsWithMemOp(IntFunction fa) { + static void MAXLongVector64TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3259,13 +3259,13 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long64VectorTests::MAX); + assertArraysEquals(r, a, (long)10, LongVector64Tests::MAX); } static LongVector bv_max = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void maxLong64VectorTestsWithMemOp(IntFunction fa) { + static void maxLongVector64TestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3276,13 +3276,13 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, Long64VectorTests::max); + assertArraysEquals(r, a, (long)10, LongVector64Tests::max); } static LongVector bv_MAX_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXLong64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXLongVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3295,7 +3295,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, Long64VectorTests::MAX); + assertArraysEquals(r, a, (long)10, mask, LongVector64Tests::MAX); } static long MIN(long a, long b) { @@ -3303,7 +3303,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MINLong64VectorTests(IntFunction fa, IntFunction fb) { + static void MINLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3316,7 +3316,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::MIN); + assertArraysEquals(r, a, b, LongVector64Tests::MIN); } static long min(long a, long b) { @@ -3324,7 +3324,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void minLong64VectorTests(IntFunction fa, IntFunction fb) { + static void minLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3335,7 +3335,7 @@ public class Long64VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long64VectorTests::min); + assertArraysEquals(r, a, b, LongVector64Tests::min); } static long MAX(long a, long b) { @@ -3343,7 +3343,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLong64VectorTests(IntFunction fa, IntFunction fb) { + static void MAXLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3356,7 +3356,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::MAX); + assertArraysEquals(r, a, b, LongVector64Tests::MAX); } static long max(long a, long b) { @@ -3364,7 +3364,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void maxLong64VectorTests(IntFunction fa, IntFunction fb) { + static void maxLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3375,7 +3375,7 @@ public class Long64VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Long64VectorTests::max); + assertArraysEquals(r, a, b, LongVector64Tests::max); } static long UMIN(long a, long b) { @@ -3383,7 +3383,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMINLong64VectorTests(IntFunction fa, IntFunction fb) { + static void UMINLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3396,11 +3396,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::UMIN); + assertArraysEquals(r, a, b, LongVector64Tests::UMIN); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMINLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3416,7 +3416,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, LongVector64Tests::UMIN); } static long UMAX(long a, long b) { @@ -3424,7 +3424,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMAXLong64VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3437,11 +3437,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::UMAX); + assertArraysEquals(r, a, b, LongVector64Tests::UMAX); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMAXLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3457,7 +3457,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, LongVector64Tests::UMAX); } static long SADD(long a, long b) { @@ -3465,7 +3465,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SADDLong64VectorTests(IntFunction fa, IntFunction fb) { + static void SADDLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3478,11 +3478,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::SADD); + assertArraysEquals(r, a, b, LongVector64Tests::SADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SADDLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3498,7 +3498,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::SADD); + assertArraysEquals(r, a, b, mask, LongVector64Tests::SADD); } static long SSUB(long a, long b) { @@ -3506,7 +3506,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SSUBLong64VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3519,11 +3519,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::SSUB); + assertArraysEquals(r, a, b, LongVector64Tests::SSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SSUBLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3539,7 +3539,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, LongVector64Tests::SSUB); } static long SUADD(long a, long b) { @@ -3547,7 +3547,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUADDLong64VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3560,11 +3560,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::SUADD); + assertArraysEquals(r, a, b, LongVector64Tests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUADDLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3580,7 +3580,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, LongVector64Tests::SUADD); } static long SUSUB(long a, long b) { @@ -3588,7 +3588,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUSUBLong64VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3601,11 +3601,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::SUSUB); + assertArraysEquals(r, a, b, LongVector64Tests::SUSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUSUBLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3621,11 +3621,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, LongVector64Tests::SUSUB); } @Test(dataProvider = "longBinaryOpProvider") - static void MINLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3635,11 +3635,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::MIN); } @Test(dataProvider = "longBinaryOpProvider") - static void minLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3649,11 +3649,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::min); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::min); } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3663,11 +3663,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::MAX); } @Test(dataProvider = "longBinaryOpProvider") - static void maxLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3677,10 +3677,10 @@ public class Long64VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Long64VectorTests::max); + assertBroadcastArraysEquals(r, a, b, LongVector64Tests::max); } @Test(dataProvider = "longSaturatingBinaryOpAssocProvider") - static void SUADDAssocLong64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocLongVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -3697,11 +3697,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Long64VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, LongVector64Tests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3722,7 +3722,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Long64VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, LongVector64Tests::SUADD); } static long ANDReduce(long[] a, int idx) { @@ -3744,7 +3744,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ANDReduceLong64VectorTests(IntFunction fa) { + static void ANDReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3760,7 +3760,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::ANDReduce, Long64VectorTests::ANDReduceAll); + LongVector64Tests::ANDReduce, LongVector64Tests::ANDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3806,7 +3806,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ANDReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3824,7 +3824,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::ANDReduceMasked, Long64VectorTests::ANDReduceAllMasked); + LongVector64Tests::ANDReduceMasked, LongVector64Tests::ANDReduceAllMasked); } static long ORReduce(long[] a, int idx) { @@ -3846,7 +3846,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ORReduceLong64VectorTests(IntFunction fa) { + static void ORReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3862,7 +3862,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::ORReduce, Long64VectorTests::ORReduceAll); + LongVector64Tests::ORReduce, LongVector64Tests::ORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3908,7 +3908,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ORReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3926,7 +3926,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::ORReduceMasked, Long64VectorTests::ORReduceAllMasked); + LongVector64Tests::ORReduceMasked, LongVector64Tests::ORReduceAllMasked); } static long XORReduce(long[] a, int idx) { @@ -3948,7 +3948,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void XORReduceLong64VectorTests(IntFunction fa) { + static void XORReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3964,7 +3964,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::XORReduce, Long64VectorTests::XORReduceAll); + LongVector64Tests::XORReduce, LongVector64Tests::XORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4010,7 +4010,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void XORReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4028,7 +4028,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::XORReduceMasked, Long64VectorTests::XORReduceAllMasked); + LongVector64Tests::XORReduceMasked, LongVector64Tests::XORReduceAllMasked); } static long ADDReduce(long[] a, int idx) { @@ -4050,7 +4050,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLong64VectorTests(IntFunction fa) { + static void ADDReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4066,7 +4066,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::ADDReduce, Long64VectorTests::ADDReduceAll); + LongVector64Tests::ADDReduce, LongVector64Tests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4112,7 +4112,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4130,7 +4130,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::ADDReduceMasked, Long64VectorTests::ADDReduceAllMasked); + LongVector64Tests::ADDReduceMasked, LongVector64Tests::ADDReduceAllMasked); } static long MULReduce(long[] a, int idx) { @@ -4152,7 +4152,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MULReduceLong64VectorTests(IntFunction fa) { + static void MULReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4168,7 +4168,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::MULReduce, Long64VectorTests::MULReduceAll); + LongVector64Tests::MULReduce, LongVector64Tests::MULReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4214,7 +4214,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MULReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4232,7 +4232,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::MULReduceMasked, Long64VectorTests::MULReduceAllMasked); + LongVector64Tests::MULReduceMasked, LongVector64Tests::MULReduceAllMasked); } static long MINReduce(long[] a, int idx) { @@ -4254,7 +4254,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MINReduceLong64VectorTests(IntFunction fa) { + static void MINReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4270,7 +4270,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::MINReduce, Long64VectorTests::MINReduceAll); + LongVector64Tests::MINReduce, LongVector64Tests::MINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4316,7 +4316,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4334,7 +4334,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::MINReduceMasked, Long64VectorTests::MINReduceAllMasked); + LongVector64Tests::MINReduceMasked, LongVector64Tests::MINReduceAllMasked); } static long MAXReduce(long[] a, int idx) { @@ -4356,7 +4356,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MAXReduceLong64VectorTests(IntFunction fa) { + static void MAXReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4372,7 +4372,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::MAXReduce, Long64VectorTests::MAXReduceAll); + LongVector64Tests::MAXReduce, LongVector64Tests::MAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4418,7 +4418,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4436,7 +4436,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::MAXReduceMasked, Long64VectorTests::MAXReduceAllMasked); + LongVector64Tests::MAXReduceMasked, LongVector64Tests::MAXReduceAllMasked); } static long UMINReduce(long[] a, int idx) { @@ -4458,7 +4458,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMINReduceLong64VectorTests(IntFunction fa) { + static void UMINReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4474,7 +4474,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::UMINReduce, Long64VectorTests::UMINReduceAll); + LongVector64Tests::UMINReduce, LongVector64Tests::UMINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4520,7 +4520,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMINReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4538,7 +4538,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::UMINReduceMasked, Long64VectorTests::UMINReduceAllMasked); + LongVector64Tests::UMINReduceMasked, LongVector64Tests::UMINReduceAllMasked); } static long UMAXReduce(long[] a, int idx) { @@ -4560,7 +4560,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMAXReduceLong64VectorTests(IntFunction fa) { + static void UMAXReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4576,7 +4576,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::UMAXReduce, Long64VectorTests::UMAXReduceAll); + LongVector64Tests::UMAXReduce, LongVector64Tests::UMAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4622,7 +4622,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMAXReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4640,7 +4640,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::UMAXReduceMasked, Long64VectorTests::UMAXReduceAllMasked); + LongVector64Tests::UMAXReduceMasked, LongVector64Tests::UMAXReduceAllMasked); } static long FIRST_NONZEROReduce(long[] a, int idx) { @@ -4662,7 +4662,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void FIRST_NONZEROReduceLong64VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4678,7 +4678,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::FIRST_NONZEROReduce, Long64VectorTests::FIRST_NONZEROReduceAll); + LongVector64Tests::FIRST_NONZEROReduce, LongVector64Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4724,7 +4724,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void FIRST_NONZEROReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4742,7 +4742,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::FIRST_NONZEROReduceMasked, Long64VectorTests::FIRST_NONZEROReduceAllMasked); + LongVector64Tests::FIRST_NONZEROReduceMasked, LongVector64Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4755,7 +4755,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueLong64VectorTests(IntFunction fm) { + static void anyTrueLongVector64Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4766,7 +4766,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Long64VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, LongVector64Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4779,7 +4779,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueLong64VectorTests(IntFunction fm) { + static void allTrueLongVector64Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4790,7 +4790,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Long64VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, LongVector64Tests::allTrue); } static long SUADDReduce(long[] a, int idx) { @@ -4812,7 +4812,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingUnaryOpProvider") - static void SUADDReduceLong64VectorTests(IntFunction fa) { + static void SUADDReduceLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4828,7 +4828,7 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::SUADDReduce, Long64VectorTests::SUADDReduceAll); + LongVector64Tests::SUADDReduce, LongVector64Tests::SUADDReduceAll); } @Test(dataProvider = "longSaturatingUnaryOpProvider") @@ -4873,7 +4873,7 @@ public class Long64VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "longSaturatingUnaryOpMaskProvider") - static void SUADDReduceLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4891,11 +4891,11 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::SUADDReduceMasked, Long64VectorTests::SUADDReduceAllMasked); + LongVector64Tests::SUADDReduceMasked, LongVector64Tests::SUADDReduceAllMasked); } @Test(dataProvider = "longBinaryOpProvider") - static void withLong64VectorTests(IntFunction fa, IntFunction fb) { + static void withLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -4918,7 +4918,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_DEFAULTLong64VectorTests(IntFunction fa) { + static void IS_DEFAULTLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4935,7 +4935,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_DEFAULTMaskedLong64VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4959,7 +4959,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_NEGATIVELong64VectorTests(IntFunction fa) { + static void IS_NEGATIVELongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4976,7 +4976,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_NEGATIVEMaskedLong64VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4996,7 +4996,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLong64VectorTests(IntFunction fa, IntFunction fb) { + static void LTLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5015,7 +5015,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLong64VectorTests(IntFunction fa, IntFunction fb) { + static void ltLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5034,7 +5034,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5057,7 +5057,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GTLong64VectorTests(IntFunction fa, IntFunction fb) { + static void GTLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5076,7 +5076,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GTLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5099,7 +5099,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void EQLong64VectorTests(IntFunction fa, IntFunction fb) { + static void EQLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5118,7 +5118,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLong64VectorTests(IntFunction fa, IntFunction fb) { + static void eqLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5137,7 +5137,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5160,7 +5160,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void NELong64VectorTests(IntFunction fa, IntFunction fb) { + static void NELongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5179,7 +5179,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void NELong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NELongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5202,7 +5202,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LELong64VectorTests(IntFunction fa, IntFunction fb) { + static void LELongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5221,7 +5221,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LELong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LELongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5244,7 +5244,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GELong64VectorTests(IntFunction fa, IntFunction fb) { + static void GELongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5263,7 +5263,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GELong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GELongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5286,7 +5286,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULTLong64VectorTests(IntFunction fa, IntFunction fb) { + static void ULTLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5305,7 +5305,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULTLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5328,7 +5328,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGTLong64VectorTests(IntFunction fa, IntFunction fb) { + static void UGTLongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5347,7 +5347,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGTLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5370,7 +5370,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULELong64VectorTests(IntFunction fa, IntFunction fb) { + static void ULELongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5389,7 +5389,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULELong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULELongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5412,7 +5412,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGELong64VectorTests(IntFunction fa, IntFunction fb) { + static void UGELongVector64Tests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5431,7 +5431,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGELong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGELongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5454,7 +5454,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5470,7 +5470,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5491,7 +5491,7 @@ public class Long64VectorTests extends AbstractVectorTest { @Test(dataProvider = "longCompareOpProvider") - static void EQLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5507,7 +5507,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5532,7 +5532,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void blendLong64VectorTests(IntFunction fa, IntFunction fb, + static void blendLongVector64Tests(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5548,11 +5548,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Long64VectorTests::blend); + assertArraysEquals(r, a, b, mask, LongVector64Tests::blend); } @Test(dataProvider = "longUnaryOpShuffleProvider") - static void RearrangeLong64VectorTests(IntFunction fa, + static void RearrangeLongVector64Tests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5569,7 +5569,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpShuffleMaskProvider") - static void RearrangeLong64VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeLongVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -5587,7 +5587,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void compressLong64VectorTests(IntFunction fa, + static void compressLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5605,7 +5605,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void expandLong64VectorTests(IntFunction fa, + static void expandLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5623,7 +5623,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void getLong64VectorTests(IntFunction fa) { + static void getLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5779,7 +5779,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BroadcastLong64VectorTests(IntFunction fa) { + static void BroadcastLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5793,7 +5793,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZeroLong64VectorTests(IntFunction fa) { + static void ZeroLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5818,7 +5818,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void sliceUnaryLong64VectorTests(IntFunction fa) { + static void sliceUnaryLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5829,7 +5829,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Long64VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, LongVector64Tests::sliceUnary); } static long[] sliceBinary(long[] a, long[] b, int origin, int idx) { @@ -5846,7 +5846,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void sliceBinaryLong64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryLongVector64TestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5859,7 +5859,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Long64VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, LongVector64Tests::sliceBinary); } static long[] slice(long[] a, long[] b, int origin, boolean[] mask, int idx) { @@ -5876,7 +5876,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void sliceLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5893,7 +5893,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Long64VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, LongVector64Tests::slice); } static long[] unsliceUnary(long[] a, int origin, int idx) { @@ -5910,7 +5910,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void unsliceUnaryLong64VectorTests(IntFunction fa) { + static void unsliceUnaryLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5921,7 +5921,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Long64VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, LongVector64Tests::unsliceUnary); } static long[] unsliceBinary(long[] a, long[] b, int origin, int part, int idx) { @@ -5947,7 +5947,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void unsliceBinaryLong64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryLongVector64TestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5961,7 +5961,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Long64VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, LongVector64Tests::unsliceBinary); } static long[] unslice(long[] a, long[] b, int origin, int part, boolean[] mask, int idx) { @@ -6001,7 +6001,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void unsliceLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6018,7 +6018,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Long64VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, LongVector64Tests::unslice); } static long BITWISE_BLEND(long a, long b, long c) { @@ -6030,7 +6030,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6045,11 +6045,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Long64VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, LongVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6062,11 +6062,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Long64VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, LongVector64Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6084,11 +6084,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Long64VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, LongVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6099,11 +6099,11 @@ public class Long64VectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Long64VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, LongVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6114,11 +6114,11 @@ public class Long64VectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Long64VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, LongVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6129,11 +6129,11 @@ public class Long64VectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Long64VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, LongVector64Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6144,11 +6144,11 @@ public class Long64VectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Long64VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, LongVector64Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6163,11 +6163,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Long64VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, LongVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong64VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector64TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6182,11 +6182,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Long64VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, LongVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLong64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6197,11 +6197,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Long64VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLong64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6212,11 +6212,11 @@ public class Long64VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Long64VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVector64Tests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLong64VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVector64TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6230,7 +6230,7 @@ public class Long64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Long64VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, LongVector64Tests::BITWISE_BLEND); } static long NEG(long a) { @@ -6242,7 +6242,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NEGLong64VectorTests(IntFunction fa) { + static void NEGLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6253,11 +6253,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::NEG); + assertArraysEquals(r, a, LongVector64Tests::NEG); } @Test(dataProvider = "longUnaryOpProvider") - static void negLong64VectorTests(IntFunction fa) { + static void negLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6268,11 +6268,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::neg); + assertArraysEquals(r, a, LongVector64Tests::neg); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NEGMaskedLong64VectorTests(IntFunction fa, + static void NEGMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6286,7 +6286,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::NEG); + assertArraysEquals(r, a, mask, LongVector64Tests::NEG); } static long ABS(long a) { @@ -6298,7 +6298,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ABSLong64VectorTests(IntFunction fa) { + static void ABSLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6309,11 +6309,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::ABS); + assertArraysEquals(r, a, LongVector64Tests::ABS); } @Test(dataProvider = "longUnaryOpProvider") - static void absLong64VectorTests(IntFunction fa) { + static void absLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6324,11 +6324,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::abs); + assertArraysEquals(r, a, LongVector64Tests::abs); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ABSMaskedLong64VectorTests(IntFunction fa, + static void ABSMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6342,7 +6342,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::ABS); + assertArraysEquals(r, a, mask, LongVector64Tests::ABS); } static long NOT(long a) { @@ -6354,7 +6354,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NOTLong64VectorTests(IntFunction fa) { + static void NOTLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6365,11 +6365,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::NOT); + assertArraysEquals(r, a, LongVector64Tests::NOT); } @Test(dataProvider = "longUnaryOpProvider") - static void notLong64VectorTests(IntFunction fa) { + static void notLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6380,11 +6380,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::not); + assertArraysEquals(r, a, LongVector64Tests::not); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NOTMaskedLong64VectorTests(IntFunction fa, + static void NOTMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6398,7 +6398,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::NOT); + assertArraysEquals(r, a, mask, LongVector64Tests::NOT); } static long ZOMO(long a) { @@ -6406,7 +6406,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZOMOLong64VectorTests(IntFunction fa) { + static void ZOMOLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6417,11 +6417,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::ZOMO); + assertArraysEquals(r, a, LongVector64Tests::ZOMO); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ZOMOMaskedLong64VectorTests(IntFunction fa, + static void ZOMOMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6435,7 +6435,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::ZOMO); + assertArraysEquals(r, a, mask, LongVector64Tests::ZOMO); } static long BIT_COUNT(long a) { @@ -6443,7 +6443,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BIT_COUNTLong64VectorTests(IntFunction fa) { + static void BIT_COUNTLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6454,11 +6454,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::BIT_COUNT); + assertArraysEquals(r, a, LongVector64Tests::BIT_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void BIT_COUNTMaskedLong64VectorTests(IntFunction fa, + static void BIT_COUNTMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6472,7 +6472,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, LongVector64Tests::BIT_COUNT); } static long TRAILING_ZEROS_COUNT(long a) { @@ -6480,7 +6480,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void TRAILING_ZEROS_COUNTLong64VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6491,11 +6491,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVector64Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedLong64VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6509,7 +6509,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVector64Tests::TRAILING_ZEROS_COUNT); } static long LEADING_ZEROS_COUNT(long a) { @@ -6517,7 +6517,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LEADING_ZEROS_COUNTLong64VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6528,11 +6528,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVector64Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedLong64VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6546,7 +6546,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVector64Tests::LEADING_ZEROS_COUNT); } static long REVERSE(long a) { @@ -6554,7 +6554,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSELong64VectorTests(IntFunction fa) { + static void REVERSELongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6565,11 +6565,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::REVERSE); + assertArraysEquals(r, a, LongVector64Tests::REVERSE); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSEMaskedLong64VectorTests(IntFunction fa, + static void REVERSEMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6583,7 +6583,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::REVERSE); + assertArraysEquals(r, a, mask, LongVector64Tests::REVERSE); } static long REVERSE_BYTES(long a) { @@ -6591,7 +6591,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSE_BYTESLong64VectorTests(IntFunction fa) { + static void REVERSE_BYTESLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6602,11 +6602,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, LongVector64Tests::REVERSE_BYTES); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedLong64VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedLongVector64Tests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6620,7 +6620,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Long64VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, LongVector64Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6628,7 +6628,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandLong64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandLongVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6641,7 +6641,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::band); + assertArraysEquals(r, a, b, LongVector64Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6649,7 +6649,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorLong64VectorTests(IntFunction fa, IntFunction fb) { + static void maskorLongVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6662,7 +6662,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::bor); + assertArraysEquals(r, a, b, LongVector64Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6670,7 +6670,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorLong64VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorLongVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6683,7 +6683,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::bxor); + assertArraysEquals(r, a, b, LongVector64Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6691,7 +6691,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotLong64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotLongVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6704,7 +6704,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::bandNot); + assertArraysEquals(r, a, b, LongVector64Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6712,7 +6712,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqLong64VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqLongVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6725,7 +6725,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Long64VectorTests::beq); + assertArraysEquals(r, a, b, LongVector64Tests::beq); } static boolean unot(boolean a) { @@ -6733,7 +6733,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotLong64VectorTests(IntFunction fa) { + static void masknotLongVector64Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6744,7 +6744,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Long64VectorTests::unot); + assertArraysEquals(r, a, LongVector64Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6761,7 +6761,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongLong64VectorTests(IntFunction fa) { + static void maskFromToLongLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6775,7 +6775,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLong64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltLongVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6791,7 +6791,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLong64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqLongVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6807,7 +6807,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longtoIntUnaryOpProvider") - static void toIntArrayLong64VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayLongVector64TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6818,7 +6818,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toLongArrayLong64VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayLongVector64TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6829,7 +6829,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toDoubleArrayLong64VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayLongVector64TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6840,7 +6840,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toStringLong64VectorTestsSmokeTest(IntFunction fa) { + static void toStringLongVector64TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6853,7 +6853,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void hashCodeLong64VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeLongVector64TestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6869,7 +6869,7 @@ public class Long64VectorTests extends AbstractVectorTest { @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLongLong64VectorTests(IntFunction fa) { + static void ADDReduceLongLongVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -6885,11 +6885,11 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Long64VectorTests::ADDReduce, Long64VectorTests::ADDReduceAll); + LongVector64Tests::ADDReduce, LongVector64Tests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLongLong64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongLongVector64TestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6907,11 +6907,11 @@ public class Long64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Long64VectorTests::ADDReduceMasked, Long64VectorTests::ADDReduceAllMasked); + LongVector64Tests::ADDReduceMasked, LongVector64Tests::ADDReduceAllMasked); } @Test(dataProvider = "longUnaryOpSelectFromProvider") - static void SelectFromLong64VectorTests(IntFunction fa, + static void SelectFromLongVector64Tests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); long[] order = fs.apply(a.length, SPECIES.length()); @@ -6927,7 +6927,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorLong64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorLongVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] idx = fc.apply(SPECIES.length()); @@ -6945,7 +6945,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpSelectFromMaskProvider") - static void SelectFromLong64VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromLongVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -6964,7 +6964,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousLong64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousLongVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6980,7 +6980,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringLong64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringLongVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6994,7 +6994,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsLong64VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsLongVector64TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7008,7 +7008,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsLong64VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsLongVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7024,7 +7024,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeLong64VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeLongVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7046,7 +7046,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountLong64VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountLongVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7057,7 +7057,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long64VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, LongVector64Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7071,7 +7071,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueLong64VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueLongVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7082,7 +7082,7 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long64VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, LongVector64Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7096,7 +7096,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueLong64VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueLongVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7107,11 +7107,11 @@ public class Long64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Long64VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, LongVector64Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressLong64VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressLongVector64TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7139,7 +7139,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLong64VectorTestsSmokeTest(int offset) { + static void indexInRangeLongVector64TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7153,7 +7153,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongLong64VectorTestsSmokeTest(int offset) { + static void indexInRangeLongLongVector64TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7180,14 +7180,14 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundLong64VectorTestsSmokeTest(int length) { + static void loopBoundLongVector64TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongLong64VectorTestsSmokeTest(int _length) { + static void loopBoundLongLongVector64TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7195,21 +7195,21 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeLong64VectorTestsSmokeTest() { + static void ElementSizeLongVector64TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Long.SIZE); } @Test - static void VectorShapeLong64VectorTestsSmokeTest() { + static void VectorShapeLongVector64TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_64_BIT)); } @Test - static void ShapeWithLanesLong64VectorTestsSmokeTest() { + static void ShapeWithLanesLongVector64TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(long.class); @@ -7217,32 +7217,32 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeLong64VectorTestsSmokeTest() { + static void ElementTypeLongVector64TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementType() == long.class); } @Test - static void SpeciesElementSizeLong64VectorTestsSmokeTest() { + static void SpeciesElementSizeLongVector64TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementSize() == Long.SIZE); } @Test - static void VectorTypeLong64VectorTestsSmokeTest() { + static void VectorTypeLongVector64TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesLong64VectorTestsSmokeTest() { + static void WithLanesLongVector64TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(long.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeLong64VectorTestsSmokeTest() { + static void WithShapeLongVector64TestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7250,7 +7250,7 @@ public class Long64VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueLong64VectorTestsSmokeTest() { + static void MaskAllTrueLongVector64TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/LongMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/LongVectorMaxLoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/LongMaxVectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/LongVectorMaxLoadStoreTests.java index 6994ee7c770..cb5bb74424a 100644 --- a/test/jdk/jdk/incubator/vector/LongMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/LongVectorMaxLoadStoreTests.java @@ -28,7 +28,7 @@ * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation * @run testng/othervm --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED - * -XX:-TieredCompilation LongMaxVectorLoadStoreTests + * -XX:-TieredCompilation LongVectorMaxLoadStoreTests * */ @@ -52,7 +52,7 @@ import java.util.List; import java.util.function.*; @Test -public class LongMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class LongVectorMaxLoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = LongVector.SPECIES_MAX; diff --git a/test/jdk/jdk/incubator/vector/LongMaxVectorTests.java b/test/jdk/jdk/incubator/vector/LongVectorMaxTests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/LongMaxVectorTests.java rename to test/jdk/jdk/incubator/vector/LongVectorMaxTests.java index 0e19a587093..aef89af5893 100644 --- a/test/jdk/jdk/incubator/vector/LongMaxVectorTests.java +++ b/test/jdk/jdk/incubator/vector/LongVectorMaxTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation LongMaxVectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation LongVectorMaxTests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class LongMaxVectorTests extends AbstractVectorTest { +public class LongVectorMaxTests extends AbstractVectorTest { static final VectorSpecies SPECIES = LongVector.SPECIES_MAX; @@ -1689,7 +1689,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ADDLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1702,7 +1702,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::ADD); + assertArraysEquals(r, a, b, LongVectorMaxTests::ADD); } static long add(long a, long b) { @@ -1710,7 +1710,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void addLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void addLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1721,11 +1721,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, LongMaxVectorTests::add); + assertArraysEquals(r, a, b, LongVectorMaxTests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1741,11 +1741,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::ADD); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void addLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1759,7 +1759,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::add); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::add); } static long SUB(long a, long b) { @@ -1767,7 +1767,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void SUBLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUBLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1780,7 +1780,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::SUB); + assertArraysEquals(r, a, b, LongVectorMaxTests::SUB); } static long sub(long a, long b) { @@ -1788,7 +1788,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void subLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void subLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1799,11 +1799,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, LongMaxVectorTests::sub); + assertArraysEquals(r, a, b, LongVectorMaxTests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void SUBLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1819,11 +1819,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::SUB); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::SUB); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void subLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1837,7 +1837,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::sub); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::sub); } static long MUL(long a, long b) { @@ -1845,7 +1845,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MULLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MULLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1858,7 +1858,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::MUL); + assertArraysEquals(r, a, b, LongVectorMaxTests::MUL); } static long mul(long a, long b) { @@ -1866,7 +1866,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void mulLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void mulLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1877,11 +1877,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, LongMaxVectorTests::mul); + assertArraysEquals(r, a, b, LongVectorMaxTests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void MULLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1897,11 +1897,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::MUL); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::MUL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1915,7 +1915,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::mul); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::mul); } static long DIV(long a, long b) { @@ -1923,7 +1923,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void DIVLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void DIVLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1938,7 +1938,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::DIV); + assertArraysEquals(r, a, b, LongVectorMaxTests::DIV); } static long div(long a, long b) { @@ -1946,7 +1946,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void divLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void divLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -1961,11 +1961,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::div); + assertArraysEquals(r, a, b, LongVectorMaxTests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void DIVLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -1983,11 +1983,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::DIV); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::DIV); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void divLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2005,7 +2005,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::div); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::div); } static long FIRST_NONZERO(long a, long b) { @@ -2013,7 +2013,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void FIRST_NONZEROLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2026,11 +2026,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, LongVectorMaxTests::FIRST_NONZERO); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void FIRST_NONZEROLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2046,7 +2046,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::FIRST_NONZERO); } static long AND(long a, long b) { @@ -2054,7 +2054,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ANDLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2067,7 +2067,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::AND); + assertArraysEquals(r, a, b, LongVectorMaxTests::AND); } static long and(long a, long b) { @@ -2075,7 +2075,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void andLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void andLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2086,11 +2086,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, LongMaxVectorTests::and); + assertArraysEquals(r, a, b, LongVectorMaxTests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2106,7 +2106,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::AND); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::AND); } static long AND_NOT(long a, long b) { @@ -2114,7 +2114,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void AND_NOTLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2127,11 +2127,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::AND_NOT); + assertArraysEquals(r, a, b, LongVectorMaxTests::AND_NOT); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void AND_NOTLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2147,7 +2147,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::AND_NOT); } static long OR(long a, long b) { @@ -2155,7 +2155,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ORLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ORLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2168,7 +2168,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::OR); + assertArraysEquals(r, a, b, LongVectorMaxTests::OR); } static long or(long a, long b) { @@ -2176,7 +2176,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void orLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void orLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2187,11 +2187,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, LongMaxVectorTests::or); + assertArraysEquals(r, a, b, LongVectorMaxTests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2207,7 +2207,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::OR); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::OR); } static long XOR(long a, long b) { @@ -2215,7 +2215,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void XORLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void XORLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2228,11 +2228,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::XOR); + assertArraysEquals(r, a, b, LongVectorMaxTests::XOR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void XORLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2248,7 +2248,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::XOR); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::XOR); } static long COMPRESS_BITS(long a, long b) { @@ -2256,7 +2256,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void COMPRESS_BITSLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void COMPRESS_BITSLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2269,11 +2269,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, LongVectorMaxTests::COMPRESS_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void COMPRESS_BITSLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void COMPRESS_BITSLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2289,7 +2289,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::COMPRESS_BITS); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::COMPRESS_BITS); } static long EXPAND_BITS(long a, long b) { @@ -2297,7 +2297,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void EXPAND_BITSLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void EXPAND_BITSLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2310,11 +2310,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, LongVectorMaxTests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void EXPAND_BITSLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void EXPAND_BITSLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2330,11 +2330,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::EXPAND_BITS); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::EXPAND_BITS); } @Test(dataProvider = "longBinaryOpProvider") - static void addLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2344,11 +2344,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::add); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void addLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2361,11 +2361,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, LongMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, LongVectorMaxTests::add); } @Test(dataProvider = "longBinaryOpProvider") - static void subLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2375,11 +2375,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::sub); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void subLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2392,11 +2392,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, LongMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, LongVectorMaxTests::sub); } @Test(dataProvider = "longBinaryOpProvider") - static void mulLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2406,11 +2406,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::mul); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void mulLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2423,11 +2423,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, LongMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, LongVectorMaxTests::mul); } @Test(dataProvider = "longBinaryOpProvider") - static void divLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2439,11 +2439,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::div); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void divLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2458,11 +2458,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, LongMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, LongVectorMaxTests::div); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2472,11 +2472,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::OR); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void orLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2486,11 +2486,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::or); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::or); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2503,11 +2503,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, LongMaxVectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, LongVectorMaxTests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ANDLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2517,11 +2517,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::AND); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void andLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2531,11 +2531,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::and); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::and); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ANDLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2548,11 +2548,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, LongMaxVectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, LongVectorMaxTests::AND); } @Test(dataProvider = "longBinaryOpProvider") - static void ORLongMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORLongVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2562,11 +2562,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, LongMaxVectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, LongVectorMaxTests::OR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ORLongMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORLongVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2579,11 +2579,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, LongMaxVectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVectorMaxTests::OR); } @Test(dataProvider = "longBinaryOpProvider") - static void ADDLongMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDLongVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2593,11 +2593,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, LongMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, LongVectorMaxTests::ADD); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ADDLongMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDLongVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2610,7 +2610,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, LongMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, LongVectorMaxTests::ADD); } static long LSHL(long a, long b) { @@ -2618,7 +2618,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LSHLLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2631,11 +2631,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::LSHL); + assertArraysEquals(r, a, b, LongVectorMaxTests::LSHL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2651,7 +2651,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::LSHL); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::LSHL); } static long ASHR(long a, long b) { @@ -2659,7 +2659,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ASHRLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2672,11 +2672,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::ASHR); + assertArraysEquals(r, a, b, LongVectorMaxTests::ASHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2692,7 +2692,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::ASHR); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::ASHR); } static long LSHR(long a, long b) { @@ -2700,7 +2700,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LSHRLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2713,11 +2713,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::LSHR); + assertArraysEquals(r, a, b, LongVectorMaxTests::LSHR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2733,7 +2733,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::LSHR); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::LSHR); } static long LSHL_unary(long a, long b) { @@ -2741,7 +2741,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHLLongMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLLongVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2753,11 +2753,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, LongMaxVectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, LongVectorMaxTests::LSHL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHLLongMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLLongVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2772,7 +2772,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, LongMaxVectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVectorMaxTests::LSHL_unary); } static long LSHR_unary(long a, long b) { @@ -2780,7 +2780,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void LSHRLongMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRLongVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2792,11 +2792,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, LongMaxVectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, LongVectorMaxTests::LSHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void LSHRLongMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRLongVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2811,7 +2811,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, LongMaxVectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVectorMaxTests::LSHR_unary); } static long ASHR_unary(long a, long b) { @@ -2819,7 +2819,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ASHRLongMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRLongVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2831,11 +2831,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, LongMaxVectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, LongVectorMaxTests::ASHR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ASHRLongMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRLongVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2850,7 +2850,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, LongMaxVectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVectorMaxTests::ASHR_unary); } static long ROR(long a, long b) { @@ -2858,7 +2858,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void RORLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2871,11 +2871,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::ROR); + assertArraysEquals(r, a, b, LongVectorMaxTests::ROR); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2891,7 +2891,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::ROR); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::ROR); } static long ROL(long a, long b) { @@ -2899,7 +2899,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ROLLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2912,11 +2912,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::ROL); + assertArraysEquals(r, a, b, LongVectorMaxTests::ROL); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2932,7 +2932,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::ROL); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::ROL); } static long ROR_unary(long a, long b) { @@ -2940,7 +2940,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void RORLongMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORLongVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2952,11 +2952,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, LongMaxVectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, LongVectorMaxTests::ROR_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void RORLongMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORLongVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -2971,7 +2971,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, LongMaxVectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, LongVectorMaxTests::ROR_unary); } static long ROL_unary(long a, long b) { @@ -2979,7 +2979,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void ROLLongMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLLongVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -2991,11 +2991,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, LongMaxVectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, LongVectorMaxTests::ROL_unary); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void ROLLongMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLLongVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3010,14 +3010,14 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, LongMaxVectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, LongVectorMaxTests::ROL_unary); } static long LSHR_binary_const(long a) { return (long)((a >>> CONST_SHIFT)); } @Test(dataProvider = "longUnaryOpProvider") - static void LSHRLongMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRLongVectorMaxTestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3028,11 +3028,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, LongMaxVectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, LongVectorMaxTests::LSHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHRLongMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRLongVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3046,7 +3046,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, LongMaxVectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVectorMaxTests::LSHR_binary_const); } static long LSHL_binary_const(long a) { @@ -3054,7 +3054,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LSHLLongMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLLongVectorMaxTestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3065,11 +3065,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, LongMaxVectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, LongVectorMaxTests::LSHL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LSHLLongMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLLongVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3083,7 +3083,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, LongMaxVectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, LongVectorMaxTests::LSHL_binary_const); } static long ASHR_binary_const(long a) { @@ -3091,7 +3091,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ASHRLongMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRLongVectorMaxTestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3102,11 +3102,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, LongMaxVectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, LongVectorMaxTests::ASHR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ASHRLongMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRLongVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3120,7 +3120,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, LongMaxVectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, LongVectorMaxTests::ASHR_binary_const); } static long ROR_binary_const(long a) { @@ -3128,7 +3128,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void RORLongMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void RORLongVectorMaxTestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3139,11 +3139,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, LongMaxVectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, LongVectorMaxTests::ROR_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void RORLongMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORLongVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3157,7 +3157,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, LongMaxVectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, LongVectorMaxTests::ROR_binary_const); } static long ROL_binary_const(long a) { @@ -3165,7 +3165,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ROLLongMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void ROLLongVectorMaxTestsScalarShiftConst(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3176,11 +3176,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, LongMaxVectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, LongVectorMaxTests::ROL_binary_const); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ROLLongMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLLongVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3194,14 +3194,14 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, LongMaxVectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, LongVectorMaxTests::ROL_binary_const); } static LongVector bv_MIN = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MINLongMaxVectorTestsWithMemOp(IntFunction fa) { + static void MINLongVectorMaxTestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3212,13 +3212,13 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, LongMaxVectorTests::MIN); + assertArraysEquals(r, a, (long)10, LongVectorMaxTests::MIN); } static LongVector bv_min = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void minLongMaxVectorTestsWithMemOp(IntFunction fa) { + static void minLongVectorMaxTestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3229,13 +3229,13 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, LongMaxVectorTests::min); + assertArraysEquals(r, a, (long)10, LongVectorMaxTests::min); } static LongVector bv_MIN_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINLongMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINLongVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3248,13 +3248,13 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, LongMaxVectorTests::MIN); + assertArraysEquals(r, a, (long)10, mask, LongVectorMaxTests::MIN); } static LongVector bv_MAX = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void MAXLongMaxVectorTestsWithMemOp(IntFunction fa) { + static void MAXLongVectorMaxTestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3265,13 +3265,13 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, LongMaxVectorTests::MAX); + assertArraysEquals(r, a, (long)10, LongVectorMaxTests::MAX); } static LongVector bv_max = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpProvider") - static void maxLongMaxVectorTestsWithMemOp(IntFunction fa) { + static void maxLongVectorMaxTestsWithMemOp(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3282,13 +3282,13 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, LongMaxVectorTests::max); + assertArraysEquals(r, a, (long)10, LongVectorMaxTests::max); } static LongVector bv_MAX_M = LongVector.broadcast(SPECIES, (long)10); @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXLongMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXLongVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3301,7 +3301,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (long)10, mask, LongMaxVectorTests::MAX); + assertArraysEquals(r, a, (long)10, mask, LongVectorMaxTests::MAX); } static long MIN(long a, long b) { @@ -3309,7 +3309,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MINLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MINLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3322,7 +3322,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::MIN); + assertArraysEquals(r, a, b, LongVectorMaxTests::MIN); } static long min(long a, long b) { @@ -3330,7 +3330,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void minLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void minLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3341,7 +3341,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, LongMaxVectorTests::min); + assertArraysEquals(r, a, b, LongVectorMaxTests::min); } static long MAX(long a, long b) { @@ -3349,7 +3349,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MAXLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3362,7 +3362,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::MAX); + assertArraysEquals(r, a, b, LongVectorMaxTests::MAX); } static long max(long a, long b) { @@ -3370,7 +3370,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void maxLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maxLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3381,7 +3381,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, LongMaxVectorTests::max); + assertArraysEquals(r, a, b, LongVectorMaxTests::max); } static long UMIN(long a, long b) { @@ -3389,7 +3389,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMINLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UMINLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3402,11 +3402,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::UMIN); + assertArraysEquals(r, a, b, LongVectorMaxTests::UMIN); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMINLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3422,7 +3422,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::UMIN); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::UMIN); } static long UMAX(long a, long b) { @@ -3430,7 +3430,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void UMAXLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UMAXLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3443,11 +3443,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::UMAX); + assertArraysEquals(r, a, b, LongVectorMaxTests::UMAX); } @Test(dataProvider = "longBinaryOpMaskProvider") - static void UMAXLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3463,7 +3463,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::UMAX); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::UMAX); } static long SADD(long a, long b) { @@ -3471,7 +3471,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SADDLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SADDLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3484,11 +3484,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::SADD); + assertArraysEquals(r, a, b, LongVectorMaxTests::SADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SADDLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3504,7 +3504,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::SADD); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::SADD); } static long SSUB(long a, long b) { @@ -3512,7 +3512,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SSUBLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SSUBLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3525,11 +3525,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::SSUB); + assertArraysEquals(r, a, b, LongVectorMaxTests::SSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SSUBLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3545,7 +3545,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::SSUB); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::SSUB); } static long SUADD(long a, long b) { @@ -3553,7 +3553,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUADDLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUADDLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3566,11 +3566,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::SUADD); + assertArraysEquals(r, a, b, LongVectorMaxTests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUADDLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3586,7 +3586,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::SUADD); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::SUADD); } static long SUSUB(long a, long b) { @@ -3594,7 +3594,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingBinaryOpProvider") - static void SUSUBLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3607,11 +3607,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::SUSUB); + assertArraysEquals(r, a, b, LongVectorMaxTests::SUSUB); } @Test(dataProvider = "longSaturatingBinaryOpMaskProvider") - static void SUSUBLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3627,11 +3627,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::SUSUB); } @Test(dataProvider = "longBinaryOpProvider") - static void MINLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3641,11 +3641,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::MIN); } @Test(dataProvider = "longBinaryOpProvider") - static void minLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3655,11 +3655,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::min); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::min); } @Test(dataProvider = "longBinaryOpProvider") - static void MAXLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3669,11 +3669,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::MAX); } @Test(dataProvider = "longBinaryOpProvider") - static void maxLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -3683,10 +3683,10 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, LongMaxVectorTests::max); + assertBroadcastArraysEquals(r, a, b, LongVectorMaxTests::max); } @Test(dataProvider = "longSaturatingBinaryOpAssocProvider") - static void SUADDAssocLongMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocLongVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -3703,11 +3703,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, LongMaxVectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, LongVectorMaxTests::SUADD); } @Test(dataProvider = "longSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -3728,7 +3728,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, LongMaxVectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, LongVectorMaxTests::SUADD); } static long ANDReduce(long[] a, int idx) { @@ -3750,7 +3750,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ANDReduceLongMaxVectorTests(IntFunction fa) { + static void ANDReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3766,7 +3766,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::ANDReduce, LongMaxVectorTests::ANDReduceAll); + LongVectorMaxTests::ANDReduce, LongVectorMaxTests::ANDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3812,7 +3812,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ANDReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3830,7 +3830,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::ANDReduceMasked, LongMaxVectorTests::ANDReduceAllMasked); + LongVectorMaxTests::ANDReduceMasked, LongVectorMaxTests::ANDReduceAllMasked); } static long ORReduce(long[] a, int idx) { @@ -3852,7 +3852,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ORReduceLongMaxVectorTests(IntFunction fa) { + static void ORReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3868,7 +3868,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::ORReduce, LongMaxVectorTests::ORReduceAll); + LongVectorMaxTests::ORReduce, LongVectorMaxTests::ORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -3914,7 +3914,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ORReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3932,7 +3932,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::ORReduceMasked, LongMaxVectorTests::ORReduceAllMasked); + LongVectorMaxTests::ORReduceMasked, LongVectorMaxTests::ORReduceAllMasked); } static long XORReduce(long[] a, int idx) { @@ -3954,7 +3954,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void XORReduceLongMaxVectorTests(IntFunction fa) { + static void XORReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -3970,7 +3970,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::XORReduce, LongMaxVectorTests::XORReduceAll); + LongVectorMaxTests::XORReduce, LongVectorMaxTests::XORReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4016,7 +4016,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void XORReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4034,7 +4034,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::XORReduceMasked, LongMaxVectorTests::XORReduceAllMasked); + LongVectorMaxTests::XORReduceMasked, LongVectorMaxTests::XORReduceAllMasked); } static long ADDReduce(long[] a, int idx) { @@ -4056,7 +4056,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLongMaxVectorTests(IntFunction fa) { + static void ADDReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4072,7 +4072,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::ADDReduce, LongMaxVectorTests::ADDReduceAll); + LongVectorMaxTests::ADDReduce, LongVectorMaxTests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4118,7 +4118,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4136,7 +4136,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::ADDReduceMasked, LongMaxVectorTests::ADDReduceAllMasked); + LongVectorMaxTests::ADDReduceMasked, LongVectorMaxTests::ADDReduceAllMasked); } static long MULReduce(long[] a, int idx) { @@ -4158,7 +4158,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MULReduceLongMaxVectorTests(IntFunction fa) { + static void MULReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4174,7 +4174,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::MULReduce, LongMaxVectorTests::MULReduceAll); + LongVectorMaxTests::MULReduce, LongVectorMaxTests::MULReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4220,7 +4220,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MULReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4238,7 +4238,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::MULReduceMasked, LongMaxVectorTests::MULReduceAllMasked); + LongVectorMaxTests::MULReduceMasked, LongVectorMaxTests::MULReduceAllMasked); } static long MINReduce(long[] a, int idx) { @@ -4260,7 +4260,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MINReduceLongMaxVectorTests(IntFunction fa) { + static void MINReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4276,7 +4276,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::MINReduce, LongMaxVectorTests::MINReduceAll); + LongVectorMaxTests::MINReduce, LongVectorMaxTests::MINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4322,7 +4322,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MINReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4340,7 +4340,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::MINReduceMasked, LongMaxVectorTests::MINReduceAllMasked); + LongVectorMaxTests::MINReduceMasked, LongVectorMaxTests::MINReduceAllMasked); } static long MAXReduce(long[] a, int idx) { @@ -4362,7 +4362,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void MAXReduceLongMaxVectorTests(IntFunction fa) { + static void MAXReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4378,7 +4378,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::MAXReduce, LongMaxVectorTests::MAXReduceAll); + LongVectorMaxTests::MAXReduce, LongVectorMaxTests::MAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4424,7 +4424,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void MAXReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4442,7 +4442,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::MAXReduceMasked, LongMaxVectorTests::MAXReduceAllMasked); + LongVectorMaxTests::MAXReduceMasked, LongVectorMaxTests::MAXReduceAllMasked); } static long UMINReduce(long[] a, int idx) { @@ -4464,7 +4464,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMINReduceLongMaxVectorTests(IntFunction fa) { + static void UMINReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4480,7 +4480,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::UMINReduce, LongMaxVectorTests::UMINReduceAll); + LongVectorMaxTests::UMINReduce, LongVectorMaxTests::UMINReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4526,7 +4526,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMINReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4544,7 +4544,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::UMINReduceMasked, LongMaxVectorTests::UMINReduceAllMasked); + LongVectorMaxTests::UMINReduceMasked, LongVectorMaxTests::UMINReduceAllMasked); } static long UMAXReduce(long[] a, int idx) { @@ -4566,7 +4566,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void UMAXReduceLongMaxVectorTests(IntFunction fa) { + static void UMAXReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4582,7 +4582,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::UMAXReduce, LongMaxVectorTests::UMAXReduceAll); + LongVectorMaxTests::UMAXReduce, LongVectorMaxTests::UMAXReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4628,7 +4628,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void UMAXReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4646,7 +4646,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::UMAXReduceMasked, LongMaxVectorTests::UMAXReduceAllMasked); + LongVectorMaxTests::UMAXReduceMasked, LongVectorMaxTests::UMAXReduceAllMasked); } static long FIRST_NONZEROReduce(long[] a, int idx) { @@ -4668,7 +4668,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void FIRST_NONZEROReduceLongMaxVectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4684,7 +4684,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::FIRST_NONZEROReduce, LongMaxVectorTests::FIRST_NONZEROReduceAll); + LongVectorMaxTests::FIRST_NONZEROReduce, LongVectorMaxTests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "longUnaryOpProvider") @@ -4730,7 +4730,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void FIRST_NONZEROReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4748,7 +4748,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::FIRST_NONZEROReduceMasked, LongMaxVectorTests::FIRST_NONZEROReduceAllMasked); + LongVectorMaxTests::FIRST_NONZEROReduceMasked, LongVectorMaxTests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4761,7 +4761,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueLongMaxVectorTests(IntFunction fm) { + static void anyTrueLongVectorMaxTests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4772,7 +4772,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, LongMaxVectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, LongVectorMaxTests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4785,7 +4785,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueLongMaxVectorTests(IntFunction fm) { + static void allTrueLongVectorMaxTests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4796,7 +4796,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, LongMaxVectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, LongVectorMaxTests::allTrue); } static long SUADDReduce(long[] a, int idx) { @@ -4818,7 +4818,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSaturatingUnaryOpProvider") - static void SUADDReduceLongMaxVectorTests(IntFunction fa) { + static void SUADDReduceLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -4834,7 +4834,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::SUADDReduce, LongMaxVectorTests::SUADDReduceAll); + LongVectorMaxTests::SUADDReduce, LongVectorMaxTests::SUADDReduceAll); } @Test(dataProvider = "longSaturatingUnaryOpProvider") @@ -4879,7 +4879,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "longSaturatingUnaryOpMaskProvider") - static void SUADDReduceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4897,11 +4897,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::SUADDReduceMasked, LongMaxVectorTests::SUADDReduceAllMasked); + LongVectorMaxTests::SUADDReduceMasked, LongVectorMaxTests::SUADDReduceAllMasked); } @Test(dataProvider = "longBinaryOpProvider") - static void withLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void withLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -4924,7 +4924,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_DEFAULTLongMaxVectorTests(IntFunction fa) { + static void IS_DEFAULTLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4941,7 +4941,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_DEFAULTMaskedLongMaxVectorTests(IntFunction fa, + static void IS_DEFAULTMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4965,7 +4965,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpProvider") - static void IS_NEGATIVELongMaxVectorTests(IntFunction fa) { + static void IS_NEGATIVELongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4982,7 +4982,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTestOpMaskProvider") - static void IS_NEGATIVEMaskedLongMaxVectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -5002,7 +5002,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LTLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5021,7 +5021,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ltLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5040,7 +5040,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5063,7 +5063,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GTLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GTLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5082,7 +5082,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GTLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5105,7 +5105,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void EQLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void EQLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5124,7 +5124,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void eqLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5143,7 +5143,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5166,7 +5166,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void NELongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void NELongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5185,7 +5185,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void NELongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void NELongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5208,7 +5208,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LELongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LELongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5227,7 +5227,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LELongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LELongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5250,7 +5250,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void GELongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GELongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5269,7 +5269,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void GELongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GELongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5292,7 +5292,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULTLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ULTLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5311,7 +5311,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULTLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5334,7 +5334,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGTLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UGTLongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5353,7 +5353,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGTLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5376,7 +5376,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ULELongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ULELongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5395,7 +5395,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void ULELongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULELongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5418,7 +5418,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void UGELongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UGELongVectorMaxTests(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5437,7 +5437,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void UGELongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGELongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5460,7 +5460,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void LTLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5476,7 +5476,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void LTLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5497,7 +5497,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { @Test(dataProvider = "longCompareOpProvider") - static void EQLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5513,7 +5513,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpMaskProvider") - static void EQLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5538,7 +5538,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void blendLongMaxVectorTests(IntFunction fa, IntFunction fb, + static void blendLongVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5554,11 +5554,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, LongMaxVectorTests::blend); + assertArraysEquals(r, a, b, mask, LongVectorMaxTests::blend); } @Test(dataProvider = "longUnaryOpShuffleProvider") - static void RearrangeLongMaxVectorTests(IntFunction fa, + static void RearrangeLongVectorMaxTests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5575,7 +5575,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpShuffleMaskProvider") - static void RearrangeLongMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeLongVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -5593,7 +5593,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void compressLongMaxVectorTests(IntFunction fa, + static void compressLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5611,7 +5611,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpMaskProvider") - static void expandLongMaxVectorTests(IntFunction fa, + static void expandLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5629,7 +5629,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void getLongMaxVectorTests(IntFunction fa) { + static void getLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -5785,7 +5785,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BroadcastLongMaxVectorTests(IntFunction fa) { + static void BroadcastLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5799,7 +5799,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZeroLongMaxVectorTests(IntFunction fa) { + static void ZeroLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5824,7 +5824,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void sliceUnaryLongMaxVectorTests(IntFunction fa) { + static void sliceUnaryLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5835,7 +5835,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, LongMaxVectorTests::sliceUnary); + assertArraysEquals(r, a, origin, LongVectorMaxTests::sliceUnary); } static long[] sliceBinary(long[] a, long[] b, int origin, int idx) { @@ -5852,7 +5852,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void sliceBinaryLongMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryLongVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5865,7 +5865,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, LongMaxVectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, LongVectorMaxTests::sliceBinary); } static long[] slice(long[] a, long[] b, int origin, boolean[] mask, int idx) { @@ -5882,7 +5882,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void sliceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -5899,7 +5899,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, LongMaxVectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, LongVectorMaxTests::slice); } static long[] unsliceUnary(long[] a, int origin, int idx) { @@ -5916,7 +5916,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void unsliceUnaryLongMaxVectorTests(IntFunction fa) { + static void unsliceUnaryLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5927,7 +5927,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, LongMaxVectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, LongVectorMaxTests::unsliceUnary); } static long[] unsliceBinary(long[] a, long[] b, int origin, int part, int idx) { @@ -5953,7 +5953,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpProvider") - static void unsliceBinaryLongMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryLongVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -5967,7 +5967,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, LongMaxVectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, LongVectorMaxTests::unsliceBinary); } static long[] unslice(long[] a, long[] b, int origin, int part, boolean[] mask, int idx) { @@ -6007,7 +6007,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longBinaryOpMaskProvider") - static void unsliceLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6024,7 +6024,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, LongMaxVectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, LongVectorMaxTests::unslice); } static long BITWISE_BLEND(long a, long b, long c) { @@ -6036,7 +6036,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLongMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6051,11 +6051,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, LongMaxVectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, LongVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLongMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6068,11 +6068,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, LongMaxVectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, LongVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLongMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6090,11 +6090,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, LongMaxVectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, LongVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6105,11 +6105,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, LongMaxVectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, LongVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLongMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6120,11 +6120,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, LongMaxVectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, LongVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6135,11 +6135,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { LongVector bv = LongVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, LongMaxVectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, LongVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLongMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6150,11 +6150,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { LongVector cv = LongVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, LongMaxVectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, LongVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6169,11 +6169,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, LongMaxVectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, LongVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLongMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVectorMaxTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6188,11 +6188,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, LongMaxVectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, LongVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void BITWISE_BLENDLongMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDLongVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6203,11 +6203,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, LongMaxVectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "longTernaryOpProvider") - static void bitwiseBlendLongMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendLongVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] c = fc.apply(SPECIES.length()); @@ -6218,11 +6218,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, LongMaxVectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, LongVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "longTernaryOpMaskProvider") - static void BITWISE_BLENDLongMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDLongVectorMaxTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6236,7 +6236,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, LongMaxVectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, LongVectorMaxTests::BITWISE_BLEND); } static long NEG(long a) { @@ -6248,7 +6248,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NEGLongMaxVectorTests(IntFunction fa) { + static void NEGLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6259,11 +6259,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::NEG); + assertArraysEquals(r, a, LongVectorMaxTests::NEG); } @Test(dataProvider = "longUnaryOpProvider") - static void negLongMaxVectorTests(IntFunction fa) { + static void negLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6274,11 +6274,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::neg); + assertArraysEquals(r, a, LongVectorMaxTests::neg); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NEGMaskedLongMaxVectorTests(IntFunction fa, + static void NEGMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6292,7 +6292,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::NEG); + assertArraysEquals(r, a, mask, LongVectorMaxTests::NEG); } static long ABS(long a) { @@ -6304,7 +6304,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ABSLongMaxVectorTests(IntFunction fa) { + static void ABSLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6315,11 +6315,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::ABS); + assertArraysEquals(r, a, LongVectorMaxTests::ABS); } @Test(dataProvider = "longUnaryOpProvider") - static void absLongMaxVectorTests(IntFunction fa) { + static void absLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6330,11 +6330,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::abs); + assertArraysEquals(r, a, LongVectorMaxTests::abs); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ABSMaskedLongMaxVectorTests(IntFunction fa, + static void ABSMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6348,7 +6348,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::ABS); + assertArraysEquals(r, a, mask, LongVectorMaxTests::ABS); } static long NOT(long a) { @@ -6360,7 +6360,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void NOTLongMaxVectorTests(IntFunction fa) { + static void NOTLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6371,11 +6371,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::NOT); + assertArraysEquals(r, a, LongVectorMaxTests::NOT); } @Test(dataProvider = "longUnaryOpProvider") - static void notLongMaxVectorTests(IntFunction fa) { + static void notLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6386,11 +6386,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::not); + assertArraysEquals(r, a, LongVectorMaxTests::not); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void NOTMaskedLongMaxVectorTests(IntFunction fa, + static void NOTMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6404,7 +6404,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::NOT); + assertArraysEquals(r, a, mask, LongVectorMaxTests::NOT); } static long ZOMO(long a) { @@ -6412,7 +6412,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void ZOMOLongMaxVectorTests(IntFunction fa) { + static void ZOMOLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6423,11 +6423,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::ZOMO); + assertArraysEquals(r, a, LongVectorMaxTests::ZOMO); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ZOMOMaskedLongMaxVectorTests(IntFunction fa, + static void ZOMOMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6441,7 +6441,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::ZOMO); + assertArraysEquals(r, a, mask, LongVectorMaxTests::ZOMO); } static long BIT_COUNT(long a) { @@ -6449,7 +6449,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void BIT_COUNTLongMaxVectorTests(IntFunction fa) { + static void BIT_COUNTLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6460,11 +6460,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::BIT_COUNT); + assertArraysEquals(r, a, LongVectorMaxTests::BIT_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void BIT_COUNTMaskedLongMaxVectorTests(IntFunction fa, + static void BIT_COUNTMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6478,7 +6478,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, LongVectorMaxTests::BIT_COUNT); } static long TRAILING_ZEROS_COUNT(long a) { @@ -6486,7 +6486,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void TRAILING_ZEROS_COUNTLongMaxVectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6497,11 +6497,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVectorMaxTests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedLongMaxVectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6515,7 +6515,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVectorMaxTests::TRAILING_ZEROS_COUNT); } static long LEADING_ZEROS_COUNT(long a) { @@ -6523,7 +6523,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void LEADING_ZEROS_COUNTLongMaxVectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6534,11 +6534,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, LongVectorMaxTests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedLongMaxVectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6552,7 +6552,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, LongVectorMaxTests::LEADING_ZEROS_COUNT); } static long REVERSE(long a) { @@ -6560,7 +6560,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSELongMaxVectorTests(IntFunction fa) { + static void REVERSELongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6571,11 +6571,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::REVERSE); + assertArraysEquals(r, a, LongVectorMaxTests::REVERSE); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSEMaskedLongMaxVectorTests(IntFunction fa, + static void REVERSEMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6589,7 +6589,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::REVERSE); + assertArraysEquals(r, a, mask, LongVectorMaxTests::REVERSE); } static long REVERSE_BYTES(long a) { @@ -6597,7 +6597,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void REVERSE_BYTESLongMaxVectorTests(IntFunction fa) { + static void REVERSE_BYTESLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6608,11 +6608,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, LongVectorMaxTests::REVERSE_BYTES); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedLongMaxVectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedLongVectorMaxTests(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); @@ -6626,7 +6626,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, LongMaxVectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, LongVectorMaxTests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6634,7 +6634,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandLongVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6647,7 +6647,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::band); + assertArraysEquals(r, a, b, LongVectorMaxTests::band); } static boolean bor(boolean a, boolean b) { @@ -6655,7 +6655,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskorLongVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6668,7 +6668,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::bor); + assertArraysEquals(r, a, b, LongVectorMaxTests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6676,7 +6676,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskxorLongVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6689,7 +6689,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::bxor); + assertArraysEquals(r, a, b, LongVectorMaxTests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6697,7 +6697,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotLongVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6710,7 +6710,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::bandNot); + assertArraysEquals(r, a, b, LongVectorMaxTests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6718,7 +6718,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskeqLongVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6731,7 +6731,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, LongMaxVectorTests::beq); + assertArraysEquals(r, a, b, LongVectorMaxTests::beq); } static boolean unot(boolean a) { @@ -6739,7 +6739,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotLongMaxVectorTests(IntFunction fa) { + static void masknotLongVectorMaxTests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6750,7 +6750,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, LongMaxVectorTests::unot); + assertArraysEquals(r, a, LongVectorMaxTests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6767,7 +6767,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongLongMaxVectorTests(IntFunction fa) { + static void maskFromToLongLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6781,7 +6781,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void ltLongMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltLongVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6797,7 +6797,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longCompareOpProvider") - static void eqLongMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqLongVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); @@ -6813,7 +6813,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longtoIntUnaryOpProvider") - static void toIntArrayLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayLongVectorMaxTestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6824,7 +6824,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toLongArrayLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayLongVectorMaxTestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6835,7 +6835,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toDoubleArrayLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayLongVectorMaxTestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6846,7 +6846,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void toStringLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void toStringLongVectorMaxTestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6859,7 +6859,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpProvider") - static void hashCodeLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void hashCodeLongVectorMaxTestsSmokeTest(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6875,7 +6875,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { @Test(dataProvider = "longUnaryOpProvider") - static void ADDReduceLongLongMaxVectorTests(IntFunction fa) { + static void ADDReduceLongLongVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); long ra = 0; @@ -6891,11 +6891,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - LongMaxVectorTests::ADDReduce, LongMaxVectorTests::ADDReduceAll); + LongVectorMaxTests::ADDReduce, LongVectorMaxTests::ADDReduceAll); } @Test(dataProvider = "longUnaryOpMaskProvider") - static void ADDReduceLongLongMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongLongVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); long[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6913,11 +6913,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - LongMaxVectorTests::ADDReduceMasked, LongMaxVectorTests::ADDReduceAllMasked); + LongVectorMaxTests::ADDReduceMasked, LongVectorMaxTests::ADDReduceAllMasked); } @Test(dataProvider = "longUnaryOpSelectFromProvider") - static void SelectFromLongMaxVectorTests(IntFunction fa, + static void SelectFromLongVectorMaxTests(IntFunction fa, BiFunction fs) { long[] a = fa.apply(SPECIES.length()); long[] order = fs.apply(a.length, SPECIES.length()); @@ -6933,7 +6933,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorLongMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorLongVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { long[] a = fa.apply(SPECIES.length()); long[] b = fb.apply(SPECIES.length()); long[] idx = fc.apply(SPECIES.length()); @@ -6951,7 +6951,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longUnaryOpSelectFromMaskProvider") - static void SelectFromLongMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromLongVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { long[] a = fa.apply(SPECIES.length()); @@ -6970,7 +6970,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousLongMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousLongVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6986,7 +6986,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringLongMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringLongVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7000,7 +7000,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsLongMaxVectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsLongVectorMaxTestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7014,7 +7014,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsLongMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsLongVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7030,7 +7030,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeLongVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7052,7 +7052,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountLongVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7063,7 +7063,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, LongMaxVectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, LongVectorMaxTests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7077,7 +7077,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueLongVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7088,7 +7088,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, LongMaxVectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, LongVectorMaxTests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7102,7 +7102,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueLongVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7113,11 +7113,11 @@ public class LongMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, LongMaxVectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, LongVectorMaxTests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressLongMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskCompressLongVectorMaxTestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7145,7 +7145,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeLongVectorMaxTestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7159,7 +7159,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongLongMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeLongLongVectorMaxTestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7186,14 +7186,14 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundLongMaxVectorTestsSmokeTest(int length) { + static void loopBoundLongVectorMaxTestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongLongMaxVectorTestsSmokeTest(int _length) { + static void loopBoundLongLongVectorMaxTestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7201,21 +7201,21 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test - static void ElementSizeLongMaxVectorTestsSmokeTest() { + static void ElementSizeLongVectorMaxTestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Long.SIZE); } @Test - static void VectorShapeLongMaxVectorTestsSmokeTest() { + static void VectorShapeLongVectorMaxTestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_Max_BIT)); } @Test - static void ShapeWithLanesLongMaxVectorTestsSmokeTest() { + static void ShapeWithLanesLongVectorMaxTestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(long.class); @@ -7223,32 +7223,32 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test - static void ElementTypeLongMaxVectorTestsSmokeTest() { + static void ElementTypeLongVectorMaxTestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementType() == long.class); } @Test - static void SpeciesElementSizeLongMaxVectorTestsSmokeTest() { + static void SpeciesElementSizeLongVectorMaxTestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().elementSize() == Long.SIZE); } @Test - static void VectorTypeLongMaxVectorTestsSmokeTest() { + static void VectorTypeLongVectorMaxTestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesLongMaxVectorTestsSmokeTest() { + static void WithLanesLongVectorMaxTestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(long.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeLongMaxVectorTestsSmokeTest() { + static void WithShapeLongVectorMaxTestsSmokeTest() { LongVector av = LongVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7256,7 +7256,7 @@ public class LongMaxVectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueLongMaxVectorTestsSmokeTest() { + static void MaskAllTrueLongVectorMaxTestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Short128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ShortVector128LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Short128VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ShortVector128LoadStoreTests.java index 18974b65164..2c9a9198be9 100644 --- a/test/jdk/jdk/incubator/vector/Short128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVector128LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Short128VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation ShortVector128LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Short128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ShortVector128LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_128; diff --git a/test/jdk/jdk/incubator/vector/Short128VectorTests.java b/test/jdk/jdk/incubator/vector/ShortVector128Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Short128VectorTests.java rename to test/jdk/jdk/incubator/vector/ShortVector128Tests.java index 50dc1931663..7cf49513620 100644 --- a/test/jdk/jdk/incubator/vector/Short128VectorTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVector128Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Short128VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ShortVector128Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Short128VectorTests extends AbstractVectorTest { +public class ShortVector128Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_128; @@ -1696,7 +1696,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShort128VectorTests(IntFunction fa, IntFunction fb) { + static void ADDShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1709,7 +1709,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::ADD); + assertArraysEquals(r, a, b, ShortVector128Tests::ADD); } static short add(short a, short b) { @@ -1717,7 +1717,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void addShort128VectorTests(IntFunction fa, IntFunction fb) { + static void addShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1728,11 +1728,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short128VectorTests::add); + assertArraysEquals(r, a, b, ShortVector128Tests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1748,11 +1748,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::ADD); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1766,7 +1766,7 @@ public class Short128VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short128VectorTests::add); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::add); } static short SUB(short a, short b) { @@ -1774,7 +1774,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void SUBShort128VectorTests(IntFunction fa, IntFunction fb) { + static void SUBShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1787,7 +1787,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::SUB); + assertArraysEquals(r, a, b, ShortVector128Tests::SUB); } static short sub(short a, short b) { @@ -1795,7 +1795,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void subShort128VectorTests(IntFunction fa, IntFunction fb) { + static void subShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1806,11 +1806,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short128VectorTests::sub); + assertArraysEquals(r, a, b, ShortVector128Tests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void SUBShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1826,11 +1826,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::SUB); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::SUB); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1844,7 +1844,7 @@ public class Short128VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short128VectorTests::sub); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::sub); } static short MUL(short a, short b) { @@ -1852,7 +1852,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MULShort128VectorTests(IntFunction fa, IntFunction fb) { + static void MULShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1865,7 +1865,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::MUL); + assertArraysEquals(r, a, b, ShortVector128Tests::MUL); } static short mul(short a, short b) { @@ -1873,7 +1873,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShort128VectorTests(IntFunction fa, IntFunction fb) { + static void mulShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1884,11 +1884,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short128VectorTests::mul); + assertArraysEquals(r, a, b, ShortVector128Tests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void MULShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1904,11 +1904,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::MUL); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::MUL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1922,7 +1922,7 @@ public class Short128VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short128VectorTests::mul); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::mul); } static short DIV(short a, short b) { @@ -1930,7 +1930,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void DIVShort128VectorTests(IntFunction fa, IntFunction fb) { + static void DIVShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1945,7 +1945,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::DIV); + assertArraysEquals(r, a, b, ShortVector128Tests::DIV); } static short div(short a, short b) { @@ -1953,7 +1953,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void divShort128VectorTests(IntFunction fa, IntFunction fb) { + static void divShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1968,11 +1968,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::div); + assertArraysEquals(r, a, b, ShortVector128Tests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void DIVShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1990,11 +1990,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::DIV); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::DIV); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2012,7 +2012,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::div); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::div); } static short FIRST_NONZERO(short a, short b) { @@ -2020,7 +2020,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void FIRST_NONZEROShort128VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2033,11 +2033,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ShortVector128Tests::FIRST_NONZERO); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void FIRST_NONZEROShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2053,7 +2053,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::FIRST_NONZERO); } static short AND(short a, short b) { @@ -2061,7 +2061,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShort128VectorTests(IntFunction fa, IntFunction fb) { + static void ANDShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2074,7 +2074,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::AND); + assertArraysEquals(r, a, b, ShortVector128Tests::AND); } static short and(short a, short b) { @@ -2082,7 +2082,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void andShort128VectorTests(IntFunction fa, IntFunction fb) { + static void andShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2093,11 +2093,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short128VectorTests::and); + assertArraysEquals(r, a, b, ShortVector128Tests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2113,7 +2113,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::AND); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::AND); } static short AND_NOT(short a, short b) { @@ -2121,7 +2121,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void AND_NOTShort128VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2134,11 +2134,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::AND_NOT); + assertArraysEquals(r, a, b, ShortVector128Tests::AND_NOT); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void AND_NOTShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2154,7 +2154,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::AND_NOT); } static short OR(short a, short b) { @@ -2162,7 +2162,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort128VectorTests(IntFunction fa, IntFunction fb) { + static void ORShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2175,7 +2175,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::OR); + assertArraysEquals(r, a, b, ShortVector128Tests::OR); } static short or(short a, short b) { @@ -2183,7 +2183,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void orShort128VectorTests(IntFunction fa, IntFunction fb) { + static void orShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2194,11 +2194,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short128VectorTests::or); + assertArraysEquals(r, a, b, ShortVector128Tests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2214,7 +2214,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::OR); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::OR); } static short XOR(short a, short b) { @@ -2222,7 +2222,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void XORShort128VectorTests(IntFunction fa, IntFunction fb) { + static void XORShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2235,11 +2235,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::XOR); + assertArraysEquals(r, a, b, ShortVector128Tests::XOR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void XORShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2255,11 +2255,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::XOR); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::XOR); } @Test(dataProvider = "shortBinaryOpProvider") - static void addShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2269,11 +2269,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2286,11 +2286,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short128VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector128Tests::add); } @Test(dataProvider = "shortBinaryOpProvider") - static void subShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2300,11 +2300,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2317,11 +2317,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short128VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector128Tests::sub); } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2331,11 +2331,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2348,11 +2348,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short128VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector128Tests::mul); } @Test(dataProvider = "shortBinaryOpProvider") - static void divShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2364,11 +2364,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2383,11 +2383,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short128VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector128Tests::div); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2397,11 +2397,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void orShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2411,11 +2411,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::or); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2428,11 +2428,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short128VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector128Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2442,11 +2442,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void andShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2456,11 +2456,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::and); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2473,11 +2473,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short128VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector128Tests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2487,11 +2487,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Short128VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ShortVector128Tests::OR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2504,11 +2504,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Short128VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector128Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShort128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDShortVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2518,11 +2518,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Short128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ShortVector128Tests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShort128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDShortVector128TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2535,7 +2535,7 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Short128VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector128Tests::ADD); } static short LSHL(short a, short b) { @@ -2543,7 +2543,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShort128VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2556,11 +2556,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::LSHL); + assertArraysEquals(r, a, b, ShortVector128Tests::LSHL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2576,7 +2576,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::LSHL); } static short ASHR(short a, short b) { @@ -2584,7 +2584,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShort128VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2597,11 +2597,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::ASHR); + assertArraysEquals(r, a, b, ShortVector128Tests::ASHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2617,7 +2617,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::ASHR); } static short LSHR(short a, short b) { @@ -2625,7 +2625,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShort128VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2638,11 +2638,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::LSHR); + assertArraysEquals(r, a, b, ShortVector128Tests::LSHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2658,7 +2658,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::LSHR); } static short LSHL_unary(short a, short b) { @@ -2666,7 +2666,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShort128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLShortVector128TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2678,11 +2678,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short128VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ShortVector128Tests::LSHL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShort128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2697,7 +2697,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short128VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector128Tests::LSHL_unary); } static short LSHR_unary(short a, short b) { @@ -2705,7 +2705,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShort128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRShortVector128TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2717,11 +2717,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short128VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ShortVector128Tests::LSHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShort128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2736,7 +2736,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short128VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector128Tests::LSHR_unary); } static short ASHR_unary(short a, short b) { @@ -2744,7 +2744,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShort128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRShortVector128TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2756,11 +2756,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short128VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ShortVector128Tests::ASHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShort128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2775,7 +2775,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short128VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector128Tests::ASHR_unary); } static short ROR(short a, short b) { @@ -2783,7 +2783,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShort128VectorTests(IntFunction fa, IntFunction fb) { + static void RORShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2796,11 +2796,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::ROR); + assertArraysEquals(r, a, b, ShortVector128Tests::ROR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2816,7 +2816,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::ROR); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::ROR); } static short ROL(short a, short b) { @@ -2824,7 +2824,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShort128VectorTests(IntFunction fa, IntFunction fb) { + static void ROLShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2837,11 +2837,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::ROL); + assertArraysEquals(r, a, b, ShortVector128Tests::ROL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2857,7 +2857,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::ROL); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::ROL); } static short ROR_unary(short a, short b) { @@ -2865,7 +2865,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShort128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORShortVector128TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2877,11 +2877,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short128VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ShortVector128Tests::ROR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShort128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORShortVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2896,7 +2896,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short128VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector128Tests::ROR_unary); } static short ROL_unary(short a, short b) { @@ -2904,7 +2904,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShort128VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLShortVector128TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2916,11 +2916,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short128VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ShortVector128Tests::ROL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShort128VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLShortVector128TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2935,14 +2935,14 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short128VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector128Tests::ROL_unary); } static short LSHR_binary_const(short a) { return (short)(((a & 0xFFFF) >>> CONST_SHIFT)); } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHRShort128VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRShortVector128TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2953,11 +2953,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short128VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ShortVector128Tests::LSHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHRShort128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRShortVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2971,7 +2971,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short128VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector128Tests::LSHR_binary_const); } static short LSHL_binary_const(short a) { @@ -2979,7 +2979,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHLShort128VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLShortVector128TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2990,11 +2990,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short128VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ShortVector128Tests::LSHL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHLShort128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLShortVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3008,7 +3008,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short128VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector128Tests::LSHL_binary_const); } static short ASHR_binary_const(short a) { @@ -3016,7 +3016,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ASHRShort128VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRShortVector128TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3027,11 +3027,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short128VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ShortVector128Tests::ASHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ASHRShort128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRShortVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3045,7 +3045,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short128VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector128Tests::ASHR_binary_const); } static short ROR_binary_const(short a) { @@ -3053,7 +3053,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void RORShort128VectorTestsScalarShiftConst(IntFunction fa) { + static void RORShortVector128TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3064,11 +3064,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short128VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ShortVector128Tests::ROR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void RORShort128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORShortVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3082,7 +3082,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short128VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector128Tests::ROR_binary_const); } static short ROL_binary_const(short a) { @@ -3090,7 +3090,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ROLShort128VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLShortVector128TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3101,11 +3101,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short128VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ShortVector128Tests::ROL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ROLShort128VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLShortVector128TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3119,14 +3119,14 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short128VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector128Tests::ROL_binary_const); } static ShortVector bv_MIN = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MINShort128VectorTestsWithMemOp(IntFunction fa) { + static void MINShortVector128TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3137,13 +3137,13 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short128VectorTests::MIN); + assertArraysEquals(r, a, (short)10, ShortVector128Tests::MIN); } static ShortVector bv_min = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void minShort128VectorTestsWithMemOp(IntFunction fa) { + static void minShortVector128TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3154,13 +3154,13 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short128VectorTests::min); + assertArraysEquals(r, a, (short)10, ShortVector128Tests::min); } static ShortVector bv_MIN_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINShort128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINShortVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3173,13 +3173,13 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, Short128VectorTests::MIN); + assertArraysEquals(r, a, (short)10, mask, ShortVector128Tests::MIN); } static ShortVector bv_MAX = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MAXShort128VectorTestsWithMemOp(IntFunction fa) { + static void MAXShortVector128TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3190,13 +3190,13 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short128VectorTests::MAX); + assertArraysEquals(r, a, (short)10, ShortVector128Tests::MAX); } static ShortVector bv_max = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void maxShort128VectorTestsWithMemOp(IntFunction fa) { + static void maxShortVector128TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3207,13 +3207,13 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short128VectorTests::max); + assertArraysEquals(r, a, (short)10, ShortVector128Tests::max); } static ShortVector bv_MAX_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXShort128VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXShortVector128TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3226,7 +3226,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, Short128VectorTests::MAX); + assertArraysEquals(r, a, (short)10, mask, ShortVector128Tests::MAX); } static short MIN(short a, short b) { @@ -3234,7 +3234,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShort128VectorTests(IntFunction fa, IntFunction fb) { + static void MINShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3247,7 +3247,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::MIN); + assertArraysEquals(r, a, b, ShortVector128Tests::MIN); } static short min(short a, short b) { @@ -3255,7 +3255,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void minShort128VectorTests(IntFunction fa, IntFunction fb) { + static void minShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3266,7 +3266,7 @@ public class Short128VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short128VectorTests::min); + assertArraysEquals(r, a, b, ShortVector128Tests::min); } static short MAX(short a, short b) { @@ -3274,7 +3274,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShort128VectorTests(IntFunction fa, IntFunction fb) { + static void MAXShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3287,7 +3287,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::MAX); + assertArraysEquals(r, a, b, ShortVector128Tests::MAX); } static short max(short a, short b) { @@ -3295,7 +3295,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShort128VectorTests(IntFunction fa, IntFunction fb) { + static void maxShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3306,7 +3306,7 @@ public class Short128VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short128VectorTests::max); + assertArraysEquals(r, a, b, ShortVector128Tests::max); } static short UMIN(short a, short b) { @@ -3314,7 +3314,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMINShort128VectorTests(IntFunction fa, IntFunction fb) { + static void UMINShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3327,11 +3327,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::UMIN); + assertArraysEquals(r, a, b, ShortVector128Tests::UMIN); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMINShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3347,7 +3347,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::UMIN); } static short UMAX(short a, short b) { @@ -3355,7 +3355,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMAXShort128VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3368,11 +3368,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::UMAX); + assertArraysEquals(r, a, b, ShortVector128Tests::UMAX); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMAXShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3388,7 +3388,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::UMAX); } static short SADD(short a, short b) { @@ -3396,7 +3396,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SADDShort128VectorTests(IntFunction fa, IntFunction fb) { + static void SADDShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3409,11 +3409,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::SADD); + assertArraysEquals(r, a, b, ShortVector128Tests::SADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SADDShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3429,7 +3429,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::SADD); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::SADD); } static short SSUB(short a, short b) { @@ -3437,7 +3437,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SSUBShort128VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3450,11 +3450,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::SSUB); + assertArraysEquals(r, a, b, ShortVector128Tests::SSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SSUBShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3470,7 +3470,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::SSUB); } static short SUADD(short a, short b) { @@ -3478,7 +3478,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUADDShort128VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3491,11 +3491,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::SUADD); + assertArraysEquals(r, a, b, ShortVector128Tests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUADDShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3511,7 +3511,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::SUADD); } static short SUSUB(short a, short b) { @@ -3519,7 +3519,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUSUBShort128VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3532,11 +3532,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::SUSUB); + assertArraysEquals(r, a, b, ShortVector128Tests::SUSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUSUBShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3552,11 +3552,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::SUSUB); } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3566,11 +3566,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::MIN); } @Test(dataProvider = "shortBinaryOpProvider") - static void minShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3580,11 +3580,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::min); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::min); } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3594,11 +3594,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::MAX); } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3608,10 +3608,10 @@ public class Short128VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short128VectorTests::max); + assertBroadcastArraysEquals(r, a, b, ShortVector128Tests::max); } @Test(dataProvider = "shortSaturatingBinaryOpAssocProvider") - static void SUADDAssocShort128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocShortVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -3628,11 +3628,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Short128VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ShortVector128Tests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3653,7 +3653,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Short128VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ShortVector128Tests::SUADD); } static short ANDReduce(short[] a, int idx) { @@ -3675,7 +3675,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ANDReduceShort128VectorTests(IntFunction fa) { + static void ANDReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3691,7 +3691,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::ANDReduce, Short128VectorTests::ANDReduceAll); + ShortVector128Tests::ANDReduce, ShortVector128Tests::ANDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3737,7 +3737,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ANDReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3755,7 +3755,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::ANDReduceMasked, Short128VectorTests::ANDReduceAllMasked); + ShortVector128Tests::ANDReduceMasked, ShortVector128Tests::ANDReduceAllMasked); } static short ORReduce(short[] a, int idx) { @@ -3777,7 +3777,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ORReduceShort128VectorTests(IntFunction fa) { + static void ORReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3793,7 +3793,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::ORReduce, Short128VectorTests::ORReduceAll); + ShortVector128Tests::ORReduce, ShortVector128Tests::ORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3839,7 +3839,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ORReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3857,7 +3857,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::ORReduceMasked, Short128VectorTests::ORReduceAllMasked); + ShortVector128Tests::ORReduceMasked, ShortVector128Tests::ORReduceAllMasked); } static short XORReduce(short[] a, int idx) { @@ -3879,7 +3879,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void XORReduceShort128VectorTests(IntFunction fa) { + static void XORReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3895,7 +3895,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::XORReduce, Short128VectorTests::XORReduceAll); + ShortVector128Tests::XORReduce, ShortVector128Tests::XORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3941,7 +3941,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void XORReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3959,7 +3959,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::XORReduceMasked, Short128VectorTests::XORReduceAllMasked); + ShortVector128Tests::XORReduceMasked, ShortVector128Tests::XORReduceAllMasked); } static short ADDReduce(short[] a, int idx) { @@ -3981,7 +3981,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceShort128VectorTests(IntFunction fa) { + static void ADDReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3997,7 +3997,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::ADDReduce, Short128VectorTests::ADDReduceAll); + ShortVector128Tests::ADDReduce, ShortVector128Tests::ADDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4043,7 +4043,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4061,7 +4061,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::ADDReduceMasked, Short128VectorTests::ADDReduceAllMasked); + ShortVector128Tests::ADDReduceMasked, ShortVector128Tests::ADDReduceAllMasked); } static short MULReduce(short[] a, int idx) { @@ -4083,7 +4083,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MULReduceShort128VectorTests(IntFunction fa) { + static void MULReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4099,7 +4099,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::MULReduce, Short128VectorTests::MULReduceAll); + ShortVector128Tests::MULReduce, ShortVector128Tests::MULReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4145,7 +4145,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MULReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4163,7 +4163,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::MULReduceMasked, Short128VectorTests::MULReduceAllMasked); + ShortVector128Tests::MULReduceMasked, ShortVector128Tests::MULReduceAllMasked); } static short MINReduce(short[] a, int idx) { @@ -4185,7 +4185,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MINReduceShort128VectorTests(IntFunction fa) { + static void MINReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4201,7 +4201,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::MINReduce, Short128VectorTests::MINReduceAll); + ShortVector128Tests::MINReduce, ShortVector128Tests::MINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4247,7 +4247,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4265,7 +4265,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::MINReduceMasked, Short128VectorTests::MINReduceAllMasked); + ShortVector128Tests::MINReduceMasked, ShortVector128Tests::MINReduceAllMasked); } static short MAXReduce(short[] a, int idx) { @@ -4287,7 +4287,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MAXReduceShort128VectorTests(IntFunction fa) { + static void MAXReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4303,7 +4303,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::MAXReduce, Short128VectorTests::MAXReduceAll); + ShortVector128Tests::MAXReduce, ShortVector128Tests::MAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4349,7 +4349,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4367,7 +4367,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::MAXReduceMasked, Short128VectorTests::MAXReduceAllMasked); + ShortVector128Tests::MAXReduceMasked, ShortVector128Tests::MAXReduceAllMasked); } static short UMINReduce(short[] a, int idx) { @@ -4389,7 +4389,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMINReduceShort128VectorTests(IntFunction fa) { + static void UMINReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4405,7 +4405,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::UMINReduce, Short128VectorTests::UMINReduceAll); + ShortVector128Tests::UMINReduce, ShortVector128Tests::UMINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4451,7 +4451,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMINReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4469,7 +4469,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::UMINReduceMasked, Short128VectorTests::UMINReduceAllMasked); + ShortVector128Tests::UMINReduceMasked, ShortVector128Tests::UMINReduceAllMasked); } static short UMAXReduce(short[] a, int idx) { @@ -4491,7 +4491,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMAXReduceShort128VectorTests(IntFunction fa) { + static void UMAXReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4507,7 +4507,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::UMAXReduce, Short128VectorTests::UMAXReduceAll); + ShortVector128Tests::UMAXReduce, ShortVector128Tests::UMAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4553,7 +4553,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMAXReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4571,7 +4571,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::UMAXReduceMasked, Short128VectorTests::UMAXReduceAllMasked); + ShortVector128Tests::UMAXReduceMasked, ShortVector128Tests::UMAXReduceAllMasked); } static short FIRST_NONZEROReduce(short[] a, int idx) { @@ -4593,7 +4593,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void FIRST_NONZEROReduceShort128VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4609,7 +4609,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::FIRST_NONZEROReduce, Short128VectorTests::FIRST_NONZEROReduceAll); + ShortVector128Tests::FIRST_NONZEROReduce, ShortVector128Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4655,7 +4655,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void FIRST_NONZEROReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4673,7 +4673,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::FIRST_NONZEROReduceMasked, Short128VectorTests::FIRST_NONZEROReduceAllMasked); + ShortVector128Tests::FIRST_NONZEROReduceMasked, ShortVector128Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4686,7 +4686,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueShort128VectorTests(IntFunction fm) { + static void anyTrueShortVector128Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4697,7 +4697,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Short128VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ShortVector128Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4710,7 +4710,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueShort128VectorTests(IntFunction fm) { + static void allTrueShortVector128Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4721,7 +4721,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Short128VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ShortVector128Tests::allTrue); } static short SUADDReduce(short[] a, int idx) { @@ -4743,7 +4743,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingUnaryOpProvider") - static void SUADDReduceShort128VectorTests(IntFunction fa) { + static void SUADDReduceShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4759,7 +4759,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short128VectorTests::SUADDReduce, Short128VectorTests::SUADDReduceAll); + ShortVector128Tests::SUADDReduce, ShortVector128Tests::SUADDReduceAll); } @Test(dataProvider = "shortSaturatingUnaryOpProvider") @@ -4804,7 +4804,7 @@ public class Short128VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "shortSaturatingUnaryOpMaskProvider") - static void SUADDReduceShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4822,11 +4822,11 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::SUADDReduceMasked, Short128VectorTests::SUADDReduceAllMasked); + ShortVector128Tests::SUADDReduceMasked, ShortVector128Tests::SUADDReduceAllMasked); } @Test(dataProvider = "shortBinaryOpProvider") - static void withShort128VectorTests(IntFunction fa, IntFunction fb) { + static void withShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -4849,7 +4849,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_DEFAULTShort128VectorTests(IntFunction fa) { + static void IS_DEFAULTShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4866,7 +4866,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_DEFAULTMaskedShort128VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4890,7 +4890,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_NEGATIVEShort128VectorTests(IntFunction fa) { + static void IS_NEGATIVEShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4907,7 +4907,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_NEGATIVEMaskedShort128VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4927,7 +4927,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort128VectorTests(IntFunction fa, IntFunction fb) { + static void LTShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4946,7 +4946,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShort128VectorTests(IntFunction fa, IntFunction fb) { + static void ltShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4965,7 +4965,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4988,7 +4988,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GTShort128VectorTests(IntFunction fa, IntFunction fb) { + static void GTShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5007,7 +5007,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GTShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5030,7 +5030,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort128VectorTests(IntFunction fa, IntFunction fb) { + static void EQShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5049,7 +5049,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShort128VectorTests(IntFunction fa, IntFunction fb) { + static void eqShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5068,7 +5068,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5091,7 +5091,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void NEShort128VectorTests(IntFunction fa, IntFunction fb) { + static void NEShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5110,7 +5110,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void NEShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5133,7 +5133,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LEShort128VectorTests(IntFunction fa, IntFunction fb) { + static void LEShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5152,7 +5152,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LEShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5175,7 +5175,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GEShort128VectorTests(IntFunction fa, IntFunction fb) { + static void GEShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5194,7 +5194,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GEShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5217,7 +5217,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULTShort128VectorTests(IntFunction fa, IntFunction fb) { + static void ULTShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5236,7 +5236,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULTShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5259,7 +5259,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGTShort128VectorTests(IntFunction fa, IntFunction fb) { + static void UGTShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5278,7 +5278,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGTShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5301,7 +5301,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULEShort128VectorTests(IntFunction fa, IntFunction fb) { + static void ULEShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5320,7 +5320,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULEShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5343,7 +5343,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGEShort128VectorTests(IntFunction fa, IntFunction fb) { + static void UGEShortVector128Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5362,7 +5362,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGEShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5385,7 +5385,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5401,7 +5401,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5421,7 +5421,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5437,7 +5437,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTShortVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5457,7 +5457,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5473,7 +5473,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5493,7 +5493,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5509,7 +5509,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQShortVector128TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5533,7 +5533,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShort128VectorTests(IntFunction fa, IntFunction fb, + static void blendShortVector128Tests(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5549,11 +5549,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short128VectorTests::blend); + assertArraysEquals(r, a, b, mask, ShortVector128Tests::blend); } @Test(dataProvider = "shortUnaryOpShuffleProvider") - static void RearrangeShort128VectorTests(IntFunction fa, + static void RearrangeShortVector128Tests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5570,7 +5570,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpShuffleMaskProvider") - static void RearrangeShort128VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeShortVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -5588,7 +5588,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void compressShort128VectorTests(IntFunction fa, + static void compressShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5606,7 +5606,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void expandShort128VectorTests(IntFunction fa, + static void expandShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5624,7 +5624,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void getShort128VectorTests(IntFunction fa) { + static void getShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5780,7 +5780,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastShort128VectorTests(IntFunction fa) { + static void BroadcastShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5794,7 +5794,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZeroShort128VectorTests(IntFunction fa) { + static void ZeroShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5819,7 +5819,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void sliceUnaryShort128VectorTests(IntFunction fa) { + static void sliceUnaryShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5830,7 +5830,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Short128VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ShortVector128Tests::sliceUnary); } static short[] sliceBinary(short[] a, short[] b, int origin, int idx) { @@ -5847,7 +5847,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void sliceBinaryShort128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryShortVector128TestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5860,7 +5860,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Short128VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ShortVector128Tests::sliceBinary); } static short[] slice(short[] a, short[] b, int origin, boolean[] mask, int idx) { @@ -5877,7 +5877,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void sliceShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5894,7 +5894,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Short128VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ShortVector128Tests::slice); } static short[] unsliceUnary(short[] a, int origin, int idx) { @@ -5911,7 +5911,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void unsliceUnaryShort128VectorTests(IntFunction fa) { + static void unsliceUnaryShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5922,7 +5922,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Short128VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ShortVector128Tests::unsliceUnary); } static short[] unsliceBinary(short[] a, short[] b, int origin, int part, int idx) { @@ -5948,7 +5948,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void unsliceBinaryShort128VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryShortVector128TestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5962,7 +5962,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Short128VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ShortVector128Tests::unsliceBinary); } static short[] unslice(short[] a, short[] b, int origin, int part, boolean[] mask, int idx) { @@ -6002,7 +6002,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void unsliceShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6019,7 +6019,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Short128VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ShortVector128Tests::unslice); } static short BITWISE_BLEND(short a, short b, short c) { @@ -6031,7 +6031,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6046,11 +6046,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Short128VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ShortVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6063,11 +6063,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Short128VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ShortVector128Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort128VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector128TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6085,11 +6085,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Short128VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ShortVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6100,11 +6100,11 @@ public class Short128VectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Short128VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ShortVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6115,11 +6115,11 @@ public class Short128VectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Short128VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6130,11 +6130,11 @@ public class Short128VectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Short128VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ShortVector128Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort128VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector128TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6145,11 +6145,11 @@ public class Short128VectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Short128VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVector128Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6164,11 +6164,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Short128VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ShortVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort128VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector128TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6183,11 +6183,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Short128VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ShortVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Short128VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVector128Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort128VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector128TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6213,11 +6213,11 @@ public class Short128VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Short128VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVector128Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort128VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector128TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6231,7 +6231,7 @@ public class Short128VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Short128VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ShortVector128Tests::BITWISE_BLEND); } static short NEG(short a) { @@ -6243,7 +6243,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NEGShort128VectorTests(IntFunction fa) { + static void NEGShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6254,11 +6254,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::NEG); + assertArraysEquals(r, a, ShortVector128Tests::NEG); } @Test(dataProvider = "shortUnaryOpProvider") - static void negShort128VectorTests(IntFunction fa) { + static void negShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6269,11 +6269,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::neg); + assertArraysEquals(r, a, ShortVector128Tests::neg); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NEGMaskedShort128VectorTests(IntFunction fa, + static void NEGMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6287,7 +6287,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::NEG); + assertArraysEquals(r, a, mask, ShortVector128Tests::NEG); } static short ABS(short a) { @@ -6299,7 +6299,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ABSShort128VectorTests(IntFunction fa) { + static void ABSShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6310,11 +6310,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::ABS); + assertArraysEquals(r, a, ShortVector128Tests::ABS); } @Test(dataProvider = "shortUnaryOpProvider") - static void absShort128VectorTests(IntFunction fa) { + static void absShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6325,11 +6325,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::abs); + assertArraysEquals(r, a, ShortVector128Tests::abs); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ABSMaskedShort128VectorTests(IntFunction fa, + static void ABSMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6343,7 +6343,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::ABS); + assertArraysEquals(r, a, mask, ShortVector128Tests::ABS); } static short NOT(short a) { @@ -6355,7 +6355,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NOTShort128VectorTests(IntFunction fa) { + static void NOTShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6366,11 +6366,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::NOT); + assertArraysEquals(r, a, ShortVector128Tests::NOT); } @Test(dataProvider = "shortUnaryOpProvider") - static void notShort128VectorTests(IntFunction fa) { + static void notShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6381,11 +6381,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::not); + assertArraysEquals(r, a, ShortVector128Tests::not); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NOTMaskedShort128VectorTests(IntFunction fa, + static void NOTMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6399,7 +6399,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::NOT); + assertArraysEquals(r, a, mask, ShortVector128Tests::NOT); } static short ZOMO(short a) { @@ -6407,7 +6407,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZOMOShort128VectorTests(IntFunction fa) { + static void ZOMOShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6418,11 +6418,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::ZOMO); + assertArraysEquals(r, a, ShortVector128Tests::ZOMO); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ZOMOMaskedShort128VectorTests(IntFunction fa, + static void ZOMOMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6436,7 +6436,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::ZOMO); + assertArraysEquals(r, a, mask, ShortVector128Tests::ZOMO); } static short BIT_COUNT(short a) { @@ -6444,7 +6444,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BIT_COUNTShort128VectorTests(IntFunction fa) { + static void BIT_COUNTShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6455,11 +6455,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::BIT_COUNT); + assertArraysEquals(r, a, ShortVector128Tests::BIT_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void BIT_COUNTMaskedShort128VectorTests(IntFunction fa, + static void BIT_COUNTMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6473,7 +6473,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ShortVector128Tests::BIT_COUNT); } static short TRAILING_ZEROS_COUNT(short a) { @@ -6481,7 +6481,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void TRAILING_ZEROS_COUNTShort128VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6492,11 +6492,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVector128Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedShort128VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6510,7 +6510,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVector128Tests::TRAILING_ZEROS_COUNT); } static short LEADING_ZEROS_COUNT(short a) { @@ -6518,7 +6518,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LEADING_ZEROS_COUNTShort128VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6529,11 +6529,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVector128Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedShort128VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6547,7 +6547,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVector128Tests::LEADING_ZEROS_COUNT); } static short REVERSE(short a) { @@ -6555,7 +6555,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSEShort128VectorTests(IntFunction fa) { + static void REVERSEShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6566,11 +6566,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::REVERSE); + assertArraysEquals(r, a, ShortVector128Tests::REVERSE); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSEMaskedShort128VectorTests(IntFunction fa, + static void REVERSEMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6584,7 +6584,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::REVERSE); + assertArraysEquals(r, a, mask, ShortVector128Tests::REVERSE); } static short REVERSE_BYTES(short a) { @@ -6592,7 +6592,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSE_BYTESShort128VectorTests(IntFunction fa) { + static void REVERSE_BYTESShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6603,11 +6603,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ShortVector128Tests::REVERSE_BYTES); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedShort128VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedShortVector128Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6621,7 +6621,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short128VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ShortVector128Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6629,7 +6629,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandShort128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandShortVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6642,7 +6642,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::band); + assertArraysEquals(r, a, b, ShortVector128Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6650,7 +6650,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorShort128VectorTests(IntFunction fa, IntFunction fb) { + static void maskorShortVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6663,7 +6663,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::bor); + assertArraysEquals(r, a, b, ShortVector128Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6671,7 +6671,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorShort128VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorShortVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6684,7 +6684,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::bxor); + assertArraysEquals(r, a, b, ShortVector128Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6692,7 +6692,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotShort128VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotShortVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6705,7 +6705,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::bandNot); + assertArraysEquals(r, a, b, ShortVector128Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6713,7 +6713,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqShort128VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqShortVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6726,7 +6726,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short128VectorTests::beq); + assertArraysEquals(r, a, b, ShortVector128Tests::beq); } static boolean unot(boolean a) { @@ -6734,7 +6734,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotShort128VectorTests(IntFunction fa) { + static void masknotShortVector128Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6745,7 +6745,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short128VectorTests::unot); + assertArraysEquals(r, a, ShortVector128Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6762,7 +6762,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongShort128VectorTests(IntFunction fa) { + static void maskFromToLongShortVector128Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6776,7 +6776,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShort128VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltShortVector128TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6792,7 +6792,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShort128VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqShortVector128TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6808,7 +6808,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toIntArrayShort128VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayShortVector128TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6819,7 +6819,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toLongArrayShort128VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayShortVector128TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6830,7 +6830,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toDoubleArrayShort128VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayShortVector128TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6841,7 +6841,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toStringShort128VectorTestsSmokeTest(IntFunction fa) { + static void toStringShortVector128TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6854,7 +6854,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void hashCodeShort128VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeShortVector128TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6887,7 +6887,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceLongShort128VectorTests(IntFunction fa) { + static void ADDReduceLongShortVector128Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6903,7 +6903,7 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Short128VectorTests::ADDReduceLong, Short128VectorTests::ADDReduceAllLong); + ShortVector128Tests::ADDReduceLong, ShortVector128Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(short[] a, int idx, boolean[] mask) { @@ -6926,7 +6926,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceLongShort128VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongShortVector128TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6944,11 +6944,11 @@ public class Short128VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Short128VectorTests::ADDReduceLongMasked, Short128VectorTests::ADDReduceAllLongMasked); + ShortVector128Tests::ADDReduceLongMasked, ShortVector128Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastLongShort128VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongShortVector128TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -6959,7 +6959,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShort128VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendShortVector128TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6973,12 +6973,12 @@ public class Short128VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Short128VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector128Tests::blend); } @Test(dataProvider = "shortUnaryOpSelectFromProvider") - static void SelectFromShort128VectorTests(IntFunction fa, + static void SelectFromShortVector128Tests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); short[] order = fs.apply(a.length, SPECIES.length()); @@ -6994,7 +6994,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorShort128VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorShortVector128Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] idx = fc.apply(SPECIES.length()); @@ -7012,7 +7012,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpSelectFromMaskProvider") - static void SelectFromShort128VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromShortVector128TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -7031,7 +7031,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousShort128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousShortVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7047,7 +7047,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringShort128VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringShortVector128TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7061,7 +7061,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsShort128VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsShortVector128TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7075,7 +7075,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsShort128VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsShortVector128Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7091,7 +7091,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeShort128VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeShortVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7113,7 +7113,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountShort128VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountShortVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7124,7 +7124,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short128VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ShortVector128Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7138,7 +7138,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueShort128VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueShortVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7149,7 +7149,7 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short128VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ShortVector128Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7163,7 +7163,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueShort128VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueShortVector128TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7174,11 +7174,11 @@ public class Short128VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short128VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ShortVector128Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressShort128VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressShortVector128TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7206,7 +7206,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeShort128VectorTestsSmokeTest(int offset) { + static void indexInRangeShortVector128TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7220,7 +7220,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongShort128VectorTestsSmokeTest(int offset) { + static void indexInRangeLongShortVector128TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7247,14 +7247,14 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundShort128VectorTestsSmokeTest(int length) { + static void loopBoundShortVector128TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongShort128VectorTestsSmokeTest(int _length) { + static void loopBoundLongShortVector128TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7262,21 +7262,21 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeShort128VectorTestsSmokeTest() { + static void ElementSizeShortVector128TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Short.SIZE); } @Test - static void VectorShapeShort128VectorTestsSmokeTest() { + static void VectorShapeShortVector128TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_128_BIT)); } @Test - static void ShapeWithLanesShort128VectorTestsSmokeTest() { + static void ShapeWithLanesShortVector128TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(short.class); @@ -7284,32 +7284,32 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeShort128VectorTestsSmokeTest() { + static void ElementTypeShortVector128TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementType() == short.class); } @Test - static void SpeciesElementSizeShort128VectorTestsSmokeTest() { + static void SpeciesElementSizeShortVector128TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementSize() == Short.SIZE); } @Test - static void VectorTypeShort128VectorTestsSmokeTest() { + static void VectorTypeShortVector128TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesShort128VectorTestsSmokeTest() { + static void WithLanesShortVector128TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(short.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeShort128VectorTestsSmokeTest() { + static void WithShapeShortVector128TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7317,7 +7317,7 @@ public class Short128VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueShort128VectorTestsSmokeTest() { + static void MaskAllTrueShortVector128TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Short256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ShortVector256LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Short256VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ShortVector256LoadStoreTests.java index a7f1d67659e..70ed351908f 100644 --- a/test/jdk/jdk/incubator/vector/Short256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVector256LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Short256VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation ShortVector256LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Short256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ShortVector256LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_256; diff --git a/test/jdk/jdk/incubator/vector/Short256VectorTests.java b/test/jdk/jdk/incubator/vector/ShortVector256Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Short256VectorTests.java rename to test/jdk/jdk/incubator/vector/ShortVector256Tests.java index b23014665af..5104e3724f7 100644 --- a/test/jdk/jdk/incubator/vector/Short256VectorTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVector256Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Short256VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ShortVector256Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Short256VectorTests extends AbstractVectorTest { +public class ShortVector256Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_256; @@ -1696,7 +1696,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShort256VectorTests(IntFunction fa, IntFunction fb) { + static void ADDShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1709,7 +1709,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::ADD); + assertArraysEquals(r, a, b, ShortVector256Tests::ADD); } static short add(short a, short b) { @@ -1717,7 +1717,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void addShort256VectorTests(IntFunction fa, IntFunction fb) { + static void addShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1728,11 +1728,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short256VectorTests::add); + assertArraysEquals(r, a, b, ShortVector256Tests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1748,11 +1748,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::ADD); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1766,7 +1766,7 @@ public class Short256VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short256VectorTests::add); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::add); } static short SUB(short a, short b) { @@ -1774,7 +1774,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void SUBShort256VectorTests(IntFunction fa, IntFunction fb) { + static void SUBShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1787,7 +1787,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::SUB); + assertArraysEquals(r, a, b, ShortVector256Tests::SUB); } static short sub(short a, short b) { @@ -1795,7 +1795,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void subShort256VectorTests(IntFunction fa, IntFunction fb) { + static void subShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1806,11 +1806,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short256VectorTests::sub); + assertArraysEquals(r, a, b, ShortVector256Tests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void SUBShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1826,11 +1826,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::SUB); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::SUB); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1844,7 +1844,7 @@ public class Short256VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short256VectorTests::sub); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::sub); } static short MUL(short a, short b) { @@ -1852,7 +1852,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MULShort256VectorTests(IntFunction fa, IntFunction fb) { + static void MULShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1865,7 +1865,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::MUL); + assertArraysEquals(r, a, b, ShortVector256Tests::MUL); } static short mul(short a, short b) { @@ -1873,7 +1873,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShort256VectorTests(IntFunction fa, IntFunction fb) { + static void mulShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1884,11 +1884,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short256VectorTests::mul); + assertArraysEquals(r, a, b, ShortVector256Tests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void MULShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1904,11 +1904,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::MUL); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::MUL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1922,7 +1922,7 @@ public class Short256VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short256VectorTests::mul); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::mul); } static short DIV(short a, short b) { @@ -1930,7 +1930,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void DIVShort256VectorTests(IntFunction fa, IntFunction fb) { + static void DIVShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1945,7 +1945,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::DIV); + assertArraysEquals(r, a, b, ShortVector256Tests::DIV); } static short div(short a, short b) { @@ -1953,7 +1953,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void divShort256VectorTests(IntFunction fa, IntFunction fb) { + static void divShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1968,11 +1968,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::div); + assertArraysEquals(r, a, b, ShortVector256Tests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void DIVShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1990,11 +1990,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::DIV); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::DIV); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2012,7 +2012,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::div); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::div); } static short FIRST_NONZERO(short a, short b) { @@ -2020,7 +2020,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void FIRST_NONZEROShort256VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2033,11 +2033,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ShortVector256Tests::FIRST_NONZERO); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void FIRST_NONZEROShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2053,7 +2053,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::FIRST_NONZERO); } static short AND(short a, short b) { @@ -2061,7 +2061,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShort256VectorTests(IntFunction fa, IntFunction fb) { + static void ANDShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2074,7 +2074,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::AND); + assertArraysEquals(r, a, b, ShortVector256Tests::AND); } static short and(short a, short b) { @@ -2082,7 +2082,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void andShort256VectorTests(IntFunction fa, IntFunction fb) { + static void andShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2093,11 +2093,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short256VectorTests::and); + assertArraysEquals(r, a, b, ShortVector256Tests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2113,7 +2113,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::AND); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::AND); } static short AND_NOT(short a, short b) { @@ -2121,7 +2121,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void AND_NOTShort256VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2134,11 +2134,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::AND_NOT); + assertArraysEquals(r, a, b, ShortVector256Tests::AND_NOT); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void AND_NOTShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2154,7 +2154,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::AND_NOT); } static short OR(short a, short b) { @@ -2162,7 +2162,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort256VectorTests(IntFunction fa, IntFunction fb) { + static void ORShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2175,7 +2175,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::OR); + assertArraysEquals(r, a, b, ShortVector256Tests::OR); } static short or(short a, short b) { @@ -2183,7 +2183,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void orShort256VectorTests(IntFunction fa, IntFunction fb) { + static void orShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2194,11 +2194,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short256VectorTests::or); + assertArraysEquals(r, a, b, ShortVector256Tests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2214,7 +2214,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::OR); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::OR); } static short XOR(short a, short b) { @@ -2222,7 +2222,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void XORShort256VectorTests(IntFunction fa, IntFunction fb) { + static void XORShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2235,11 +2235,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::XOR); + assertArraysEquals(r, a, b, ShortVector256Tests::XOR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void XORShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2255,11 +2255,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::XOR); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::XOR); } @Test(dataProvider = "shortBinaryOpProvider") - static void addShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2269,11 +2269,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2286,11 +2286,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short256VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector256Tests::add); } @Test(dataProvider = "shortBinaryOpProvider") - static void subShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2300,11 +2300,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2317,11 +2317,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short256VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector256Tests::sub); } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2331,11 +2331,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2348,11 +2348,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short256VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector256Tests::mul); } @Test(dataProvider = "shortBinaryOpProvider") - static void divShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2364,11 +2364,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2383,11 +2383,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short256VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector256Tests::div); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2397,11 +2397,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void orShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2411,11 +2411,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::or); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2428,11 +2428,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short256VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector256Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2442,11 +2442,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void andShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2456,11 +2456,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::and); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2473,11 +2473,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short256VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector256Tests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2487,11 +2487,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Short256VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ShortVector256Tests::OR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2504,11 +2504,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Short256VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector256Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShort256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDShortVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2518,11 +2518,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Short256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ShortVector256Tests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShort256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDShortVector256TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2535,7 +2535,7 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Short256VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector256Tests::ADD); } static short LSHL(short a, short b) { @@ -2543,7 +2543,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShort256VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2556,11 +2556,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::LSHL); + assertArraysEquals(r, a, b, ShortVector256Tests::LSHL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2576,7 +2576,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::LSHL); } static short ASHR(short a, short b) { @@ -2584,7 +2584,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShort256VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2597,11 +2597,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::ASHR); + assertArraysEquals(r, a, b, ShortVector256Tests::ASHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2617,7 +2617,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::ASHR); } static short LSHR(short a, short b) { @@ -2625,7 +2625,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShort256VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2638,11 +2638,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::LSHR); + assertArraysEquals(r, a, b, ShortVector256Tests::LSHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2658,7 +2658,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::LSHR); } static short LSHL_unary(short a, short b) { @@ -2666,7 +2666,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShort256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLShortVector256TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2678,11 +2678,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short256VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ShortVector256Tests::LSHL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShort256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2697,7 +2697,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short256VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector256Tests::LSHL_unary); } static short LSHR_unary(short a, short b) { @@ -2705,7 +2705,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShort256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRShortVector256TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2717,11 +2717,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short256VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ShortVector256Tests::LSHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShort256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2736,7 +2736,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short256VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector256Tests::LSHR_unary); } static short ASHR_unary(short a, short b) { @@ -2744,7 +2744,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShort256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRShortVector256TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2756,11 +2756,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short256VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ShortVector256Tests::ASHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShort256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2775,7 +2775,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short256VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector256Tests::ASHR_unary); } static short ROR(short a, short b) { @@ -2783,7 +2783,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShort256VectorTests(IntFunction fa, IntFunction fb) { + static void RORShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2796,11 +2796,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::ROR); + assertArraysEquals(r, a, b, ShortVector256Tests::ROR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2816,7 +2816,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::ROR); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::ROR); } static short ROL(short a, short b) { @@ -2824,7 +2824,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShort256VectorTests(IntFunction fa, IntFunction fb) { + static void ROLShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2837,11 +2837,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::ROL); + assertArraysEquals(r, a, b, ShortVector256Tests::ROL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2857,7 +2857,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::ROL); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::ROL); } static short ROR_unary(short a, short b) { @@ -2865,7 +2865,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShort256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORShortVector256TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2877,11 +2877,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short256VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ShortVector256Tests::ROR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShort256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORShortVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2896,7 +2896,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short256VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector256Tests::ROR_unary); } static short ROL_unary(short a, short b) { @@ -2904,7 +2904,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShort256VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLShortVector256TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2916,11 +2916,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short256VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ShortVector256Tests::ROL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShort256VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLShortVector256TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2935,14 +2935,14 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short256VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector256Tests::ROL_unary); } static short LSHR_binary_const(short a) { return (short)(((a & 0xFFFF) >>> CONST_SHIFT)); } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHRShort256VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRShortVector256TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2953,11 +2953,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short256VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ShortVector256Tests::LSHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHRShort256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRShortVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2971,7 +2971,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short256VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector256Tests::LSHR_binary_const); } static short LSHL_binary_const(short a) { @@ -2979,7 +2979,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHLShort256VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLShortVector256TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2990,11 +2990,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short256VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ShortVector256Tests::LSHL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHLShort256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLShortVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3008,7 +3008,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short256VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector256Tests::LSHL_binary_const); } static short ASHR_binary_const(short a) { @@ -3016,7 +3016,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ASHRShort256VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRShortVector256TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3027,11 +3027,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short256VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ShortVector256Tests::ASHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ASHRShort256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRShortVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3045,7 +3045,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short256VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector256Tests::ASHR_binary_const); } static short ROR_binary_const(short a) { @@ -3053,7 +3053,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void RORShort256VectorTestsScalarShiftConst(IntFunction fa) { + static void RORShortVector256TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3064,11 +3064,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short256VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ShortVector256Tests::ROR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void RORShort256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORShortVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3082,7 +3082,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short256VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector256Tests::ROR_binary_const); } static short ROL_binary_const(short a) { @@ -3090,7 +3090,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ROLShort256VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLShortVector256TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3101,11 +3101,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short256VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ShortVector256Tests::ROL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ROLShort256VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLShortVector256TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3119,14 +3119,14 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short256VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector256Tests::ROL_binary_const); } static ShortVector bv_MIN = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MINShort256VectorTestsWithMemOp(IntFunction fa) { + static void MINShortVector256TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3137,13 +3137,13 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short256VectorTests::MIN); + assertArraysEquals(r, a, (short)10, ShortVector256Tests::MIN); } static ShortVector bv_min = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void minShort256VectorTestsWithMemOp(IntFunction fa) { + static void minShortVector256TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3154,13 +3154,13 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short256VectorTests::min); + assertArraysEquals(r, a, (short)10, ShortVector256Tests::min); } static ShortVector bv_MIN_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINShort256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINShortVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3173,13 +3173,13 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, Short256VectorTests::MIN); + assertArraysEquals(r, a, (short)10, mask, ShortVector256Tests::MIN); } static ShortVector bv_MAX = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MAXShort256VectorTestsWithMemOp(IntFunction fa) { + static void MAXShortVector256TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3190,13 +3190,13 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short256VectorTests::MAX); + assertArraysEquals(r, a, (short)10, ShortVector256Tests::MAX); } static ShortVector bv_max = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void maxShort256VectorTestsWithMemOp(IntFunction fa) { + static void maxShortVector256TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3207,13 +3207,13 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short256VectorTests::max); + assertArraysEquals(r, a, (short)10, ShortVector256Tests::max); } static ShortVector bv_MAX_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXShort256VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXShortVector256TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3226,7 +3226,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, Short256VectorTests::MAX); + assertArraysEquals(r, a, (short)10, mask, ShortVector256Tests::MAX); } static short MIN(short a, short b) { @@ -3234,7 +3234,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShort256VectorTests(IntFunction fa, IntFunction fb) { + static void MINShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3247,7 +3247,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::MIN); + assertArraysEquals(r, a, b, ShortVector256Tests::MIN); } static short min(short a, short b) { @@ -3255,7 +3255,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void minShort256VectorTests(IntFunction fa, IntFunction fb) { + static void minShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3266,7 +3266,7 @@ public class Short256VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short256VectorTests::min); + assertArraysEquals(r, a, b, ShortVector256Tests::min); } static short MAX(short a, short b) { @@ -3274,7 +3274,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShort256VectorTests(IntFunction fa, IntFunction fb) { + static void MAXShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3287,7 +3287,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::MAX); + assertArraysEquals(r, a, b, ShortVector256Tests::MAX); } static short max(short a, short b) { @@ -3295,7 +3295,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShort256VectorTests(IntFunction fa, IntFunction fb) { + static void maxShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3306,7 +3306,7 @@ public class Short256VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short256VectorTests::max); + assertArraysEquals(r, a, b, ShortVector256Tests::max); } static short UMIN(short a, short b) { @@ -3314,7 +3314,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMINShort256VectorTests(IntFunction fa, IntFunction fb) { + static void UMINShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3327,11 +3327,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::UMIN); + assertArraysEquals(r, a, b, ShortVector256Tests::UMIN); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMINShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3347,7 +3347,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::UMIN); } static short UMAX(short a, short b) { @@ -3355,7 +3355,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMAXShort256VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3368,11 +3368,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::UMAX); + assertArraysEquals(r, a, b, ShortVector256Tests::UMAX); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMAXShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3388,7 +3388,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::UMAX); } static short SADD(short a, short b) { @@ -3396,7 +3396,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SADDShort256VectorTests(IntFunction fa, IntFunction fb) { + static void SADDShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3409,11 +3409,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::SADD); + assertArraysEquals(r, a, b, ShortVector256Tests::SADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SADDShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3429,7 +3429,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::SADD); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::SADD); } static short SSUB(short a, short b) { @@ -3437,7 +3437,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SSUBShort256VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3450,11 +3450,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::SSUB); + assertArraysEquals(r, a, b, ShortVector256Tests::SSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SSUBShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3470,7 +3470,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::SSUB); } static short SUADD(short a, short b) { @@ -3478,7 +3478,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUADDShort256VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3491,11 +3491,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::SUADD); + assertArraysEquals(r, a, b, ShortVector256Tests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUADDShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3511,7 +3511,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::SUADD); } static short SUSUB(short a, short b) { @@ -3519,7 +3519,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUSUBShort256VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3532,11 +3532,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::SUSUB); + assertArraysEquals(r, a, b, ShortVector256Tests::SUSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUSUBShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3552,11 +3552,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::SUSUB); } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3566,11 +3566,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::MIN); } @Test(dataProvider = "shortBinaryOpProvider") - static void minShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3580,11 +3580,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::min); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::min); } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3594,11 +3594,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::MAX); } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3608,10 +3608,10 @@ public class Short256VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short256VectorTests::max); + assertBroadcastArraysEquals(r, a, b, ShortVector256Tests::max); } @Test(dataProvider = "shortSaturatingBinaryOpAssocProvider") - static void SUADDAssocShort256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocShortVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -3628,11 +3628,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Short256VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ShortVector256Tests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3653,7 +3653,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Short256VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ShortVector256Tests::SUADD); } static short ANDReduce(short[] a, int idx) { @@ -3675,7 +3675,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ANDReduceShort256VectorTests(IntFunction fa) { + static void ANDReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3691,7 +3691,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::ANDReduce, Short256VectorTests::ANDReduceAll); + ShortVector256Tests::ANDReduce, ShortVector256Tests::ANDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3737,7 +3737,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ANDReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3755,7 +3755,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::ANDReduceMasked, Short256VectorTests::ANDReduceAllMasked); + ShortVector256Tests::ANDReduceMasked, ShortVector256Tests::ANDReduceAllMasked); } static short ORReduce(short[] a, int idx) { @@ -3777,7 +3777,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ORReduceShort256VectorTests(IntFunction fa) { + static void ORReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3793,7 +3793,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::ORReduce, Short256VectorTests::ORReduceAll); + ShortVector256Tests::ORReduce, ShortVector256Tests::ORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3839,7 +3839,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ORReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3857,7 +3857,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::ORReduceMasked, Short256VectorTests::ORReduceAllMasked); + ShortVector256Tests::ORReduceMasked, ShortVector256Tests::ORReduceAllMasked); } static short XORReduce(short[] a, int idx) { @@ -3879,7 +3879,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void XORReduceShort256VectorTests(IntFunction fa) { + static void XORReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3895,7 +3895,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::XORReduce, Short256VectorTests::XORReduceAll); + ShortVector256Tests::XORReduce, ShortVector256Tests::XORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3941,7 +3941,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void XORReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3959,7 +3959,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::XORReduceMasked, Short256VectorTests::XORReduceAllMasked); + ShortVector256Tests::XORReduceMasked, ShortVector256Tests::XORReduceAllMasked); } static short ADDReduce(short[] a, int idx) { @@ -3981,7 +3981,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceShort256VectorTests(IntFunction fa) { + static void ADDReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3997,7 +3997,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::ADDReduce, Short256VectorTests::ADDReduceAll); + ShortVector256Tests::ADDReduce, ShortVector256Tests::ADDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4043,7 +4043,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4061,7 +4061,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::ADDReduceMasked, Short256VectorTests::ADDReduceAllMasked); + ShortVector256Tests::ADDReduceMasked, ShortVector256Tests::ADDReduceAllMasked); } static short MULReduce(short[] a, int idx) { @@ -4083,7 +4083,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MULReduceShort256VectorTests(IntFunction fa) { + static void MULReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4099,7 +4099,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::MULReduce, Short256VectorTests::MULReduceAll); + ShortVector256Tests::MULReduce, ShortVector256Tests::MULReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4145,7 +4145,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MULReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4163,7 +4163,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::MULReduceMasked, Short256VectorTests::MULReduceAllMasked); + ShortVector256Tests::MULReduceMasked, ShortVector256Tests::MULReduceAllMasked); } static short MINReduce(short[] a, int idx) { @@ -4185,7 +4185,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MINReduceShort256VectorTests(IntFunction fa) { + static void MINReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4201,7 +4201,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::MINReduce, Short256VectorTests::MINReduceAll); + ShortVector256Tests::MINReduce, ShortVector256Tests::MINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4247,7 +4247,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4265,7 +4265,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::MINReduceMasked, Short256VectorTests::MINReduceAllMasked); + ShortVector256Tests::MINReduceMasked, ShortVector256Tests::MINReduceAllMasked); } static short MAXReduce(short[] a, int idx) { @@ -4287,7 +4287,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MAXReduceShort256VectorTests(IntFunction fa) { + static void MAXReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4303,7 +4303,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::MAXReduce, Short256VectorTests::MAXReduceAll); + ShortVector256Tests::MAXReduce, ShortVector256Tests::MAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4349,7 +4349,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4367,7 +4367,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::MAXReduceMasked, Short256VectorTests::MAXReduceAllMasked); + ShortVector256Tests::MAXReduceMasked, ShortVector256Tests::MAXReduceAllMasked); } static short UMINReduce(short[] a, int idx) { @@ -4389,7 +4389,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMINReduceShort256VectorTests(IntFunction fa) { + static void UMINReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4405,7 +4405,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::UMINReduce, Short256VectorTests::UMINReduceAll); + ShortVector256Tests::UMINReduce, ShortVector256Tests::UMINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4451,7 +4451,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMINReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4469,7 +4469,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::UMINReduceMasked, Short256VectorTests::UMINReduceAllMasked); + ShortVector256Tests::UMINReduceMasked, ShortVector256Tests::UMINReduceAllMasked); } static short UMAXReduce(short[] a, int idx) { @@ -4491,7 +4491,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMAXReduceShort256VectorTests(IntFunction fa) { + static void UMAXReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4507,7 +4507,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::UMAXReduce, Short256VectorTests::UMAXReduceAll); + ShortVector256Tests::UMAXReduce, ShortVector256Tests::UMAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4553,7 +4553,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMAXReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4571,7 +4571,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::UMAXReduceMasked, Short256VectorTests::UMAXReduceAllMasked); + ShortVector256Tests::UMAXReduceMasked, ShortVector256Tests::UMAXReduceAllMasked); } static short FIRST_NONZEROReduce(short[] a, int idx) { @@ -4593,7 +4593,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void FIRST_NONZEROReduceShort256VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4609,7 +4609,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::FIRST_NONZEROReduce, Short256VectorTests::FIRST_NONZEROReduceAll); + ShortVector256Tests::FIRST_NONZEROReduce, ShortVector256Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4655,7 +4655,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void FIRST_NONZEROReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4673,7 +4673,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::FIRST_NONZEROReduceMasked, Short256VectorTests::FIRST_NONZEROReduceAllMasked); + ShortVector256Tests::FIRST_NONZEROReduceMasked, ShortVector256Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4686,7 +4686,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueShort256VectorTests(IntFunction fm) { + static void anyTrueShortVector256Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4697,7 +4697,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Short256VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ShortVector256Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4710,7 +4710,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueShort256VectorTests(IntFunction fm) { + static void allTrueShortVector256Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4721,7 +4721,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Short256VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ShortVector256Tests::allTrue); } static short SUADDReduce(short[] a, int idx) { @@ -4743,7 +4743,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingUnaryOpProvider") - static void SUADDReduceShort256VectorTests(IntFunction fa) { + static void SUADDReduceShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4759,7 +4759,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short256VectorTests::SUADDReduce, Short256VectorTests::SUADDReduceAll); + ShortVector256Tests::SUADDReduce, ShortVector256Tests::SUADDReduceAll); } @Test(dataProvider = "shortSaturatingUnaryOpProvider") @@ -4804,7 +4804,7 @@ public class Short256VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "shortSaturatingUnaryOpMaskProvider") - static void SUADDReduceShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4822,11 +4822,11 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::SUADDReduceMasked, Short256VectorTests::SUADDReduceAllMasked); + ShortVector256Tests::SUADDReduceMasked, ShortVector256Tests::SUADDReduceAllMasked); } @Test(dataProvider = "shortBinaryOpProvider") - static void withShort256VectorTests(IntFunction fa, IntFunction fb) { + static void withShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -4849,7 +4849,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_DEFAULTShort256VectorTests(IntFunction fa) { + static void IS_DEFAULTShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4866,7 +4866,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_DEFAULTMaskedShort256VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4890,7 +4890,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_NEGATIVEShort256VectorTests(IntFunction fa) { + static void IS_NEGATIVEShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4907,7 +4907,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_NEGATIVEMaskedShort256VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4927,7 +4927,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort256VectorTests(IntFunction fa, IntFunction fb) { + static void LTShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4946,7 +4946,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShort256VectorTests(IntFunction fa, IntFunction fb) { + static void ltShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4965,7 +4965,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4988,7 +4988,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GTShort256VectorTests(IntFunction fa, IntFunction fb) { + static void GTShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5007,7 +5007,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GTShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5030,7 +5030,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort256VectorTests(IntFunction fa, IntFunction fb) { + static void EQShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5049,7 +5049,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShort256VectorTests(IntFunction fa, IntFunction fb) { + static void eqShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5068,7 +5068,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5091,7 +5091,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void NEShort256VectorTests(IntFunction fa, IntFunction fb) { + static void NEShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5110,7 +5110,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void NEShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5133,7 +5133,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LEShort256VectorTests(IntFunction fa, IntFunction fb) { + static void LEShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5152,7 +5152,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LEShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5175,7 +5175,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GEShort256VectorTests(IntFunction fa, IntFunction fb) { + static void GEShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5194,7 +5194,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GEShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5217,7 +5217,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULTShort256VectorTests(IntFunction fa, IntFunction fb) { + static void ULTShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5236,7 +5236,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULTShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5259,7 +5259,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGTShort256VectorTests(IntFunction fa, IntFunction fb) { + static void UGTShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5278,7 +5278,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGTShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5301,7 +5301,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULEShort256VectorTests(IntFunction fa, IntFunction fb) { + static void ULEShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5320,7 +5320,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULEShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5343,7 +5343,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGEShort256VectorTests(IntFunction fa, IntFunction fb) { + static void UGEShortVector256Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5362,7 +5362,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGEShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5385,7 +5385,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5401,7 +5401,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5421,7 +5421,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5437,7 +5437,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTShortVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5457,7 +5457,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5473,7 +5473,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5493,7 +5493,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5509,7 +5509,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQShortVector256TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5533,7 +5533,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShort256VectorTests(IntFunction fa, IntFunction fb, + static void blendShortVector256Tests(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5549,11 +5549,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short256VectorTests::blend); + assertArraysEquals(r, a, b, mask, ShortVector256Tests::blend); } @Test(dataProvider = "shortUnaryOpShuffleProvider") - static void RearrangeShort256VectorTests(IntFunction fa, + static void RearrangeShortVector256Tests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5570,7 +5570,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpShuffleMaskProvider") - static void RearrangeShort256VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeShortVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -5588,7 +5588,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void compressShort256VectorTests(IntFunction fa, + static void compressShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5606,7 +5606,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void expandShort256VectorTests(IntFunction fa, + static void expandShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5624,7 +5624,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void getShort256VectorTests(IntFunction fa) { + static void getShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5780,7 +5780,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastShort256VectorTests(IntFunction fa) { + static void BroadcastShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5794,7 +5794,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZeroShort256VectorTests(IntFunction fa) { + static void ZeroShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5819,7 +5819,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void sliceUnaryShort256VectorTests(IntFunction fa) { + static void sliceUnaryShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5830,7 +5830,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Short256VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ShortVector256Tests::sliceUnary); } static short[] sliceBinary(short[] a, short[] b, int origin, int idx) { @@ -5847,7 +5847,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void sliceBinaryShort256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryShortVector256TestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5860,7 +5860,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Short256VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ShortVector256Tests::sliceBinary); } static short[] slice(short[] a, short[] b, int origin, boolean[] mask, int idx) { @@ -5877,7 +5877,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void sliceShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5894,7 +5894,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Short256VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ShortVector256Tests::slice); } static short[] unsliceUnary(short[] a, int origin, int idx) { @@ -5911,7 +5911,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void unsliceUnaryShort256VectorTests(IntFunction fa) { + static void unsliceUnaryShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5922,7 +5922,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Short256VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ShortVector256Tests::unsliceUnary); } static short[] unsliceBinary(short[] a, short[] b, int origin, int part, int idx) { @@ -5948,7 +5948,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void unsliceBinaryShort256VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryShortVector256TestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5962,7 +5962,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Short256VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ShortVector256Tests::unsliceBinary); } static short[] unslice(short[] a, short[] b, int origin, int part, boolean[] mask, int idx) { @@ -6002,7 +6002,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void unsliceShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6019,7 +6019,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Short256VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ShortVector256Tests::unslice); } static short BITWISE_BLEND(short a, short b, short c) { @@ -6031,7 +6031,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6046,11 +6046,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Short256VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ShortVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6063,11 +6063,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Short256VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ShortVector256Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort256VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector256TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6085,11 +6085,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Short256VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ShortVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6100,11 +6100,11 @@ public class Short256VectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Short256VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ShortVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6115,11 +6115,11 @@ public class Short256VectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Short256VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6130,11 +6130,11 @@ public class Short256VectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Short256VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ShortVector256Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort256VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector256TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6145,11 +6145,11 @@ public class Short256VectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Short256VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVector256Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6164,11 +6164,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Short256VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ShortVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector256TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6183,11 +6183,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Short256VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ShortVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Short256VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVector256Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort256VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector256TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6213,11 +6213,11 @@ public class Short256VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Short256VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVector256Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector256TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6231,7 +6231,7 @@ public class Short256VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Short256VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ShortVector256Tests::BITWISE_BLEND); } static short NEG(short a) { @@ -6243,7 +6243,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NEGShort256VectorTests(IntFunction fa) { + static void NEGShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6254,11 +6254,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::NEG); + assertArraysEquals(r, a, ShortVector256Tests::NEG); } @Test(dataProvider = "shortUnaryOpProvider") - static void negShort256VectorTests(IntFunction fa) { + static void negShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6269,11 +6269,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::neg); + assertArraysEquals(r, a, ShortVector256Tests::neg); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NEGMaskedShort256VectorTests(IntFunction fa, + static void NEGMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6287,7 +6287,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::NEG); + assertArraysEquals(r, a, mask, ShortVector256Tests::NEG); } static short ABS(short a) { @@ -6299,7 +6299,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ABSShort256VectorTests(IntFunction fa) { + static void ABSShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6310,11 +6310,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::ABS); + assertArraysEquals(r, a, ShortVector256Tests::ABS); } @Test(dataProvider = "shortUnaryOpProvider") - static void absShort256VectorTests(IntFunction fa) { + static void absShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6325,11 +6325,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::abs); + assertArraysEquals(r, a, ShortVector256Tests::abs); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ABSMaskedShort256VectorTests(IntFunction fa, + static void ABSMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6343,7 +6343,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::ABS); + assertArraysEquals(r, a, mask, ShortVector256Tests::ABS); } static short NOT(short a) { @@ -6355,7 +6355,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NOTShort256VectorTests(IntFunction fa) { + static void NOTShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6366,11 +6366,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::NOT); + assertArraysEquals(r, a, ShortVector256Tests::NOT); } @Test(dataProvider = "shortUnaryOpProvider") - static void notShort256VectorTests(IntFunction fa) { + static void notShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6381,11 +6381,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::not); + assertArraysEquals(r, a, ShortVector256Tests::not); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NOTMaskedShort256VectorTests(IntFunction fa, + static void NOTMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6399,7 +6399,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::NOT); + assertArraysEquals(r, a, mask, ShortVector256Tests::NOT); } static short ZOMO(short a) { @@ -6407,7 +6407,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZOMOShort256VectorTests(IntFunction fa) { + static void ZOMOShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6418,11 +6418,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::ZOMO); + assertArraysEquals(r, a, ShortVector256Tests::ZOMO); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ZOMOMaskedShort256VectorTests(IntFunction fa, + static void ZOMOMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6436,7 +6436,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::ZOMO); + assertArraysEquals(r, a, mask, ShortVector256Tests::ZOMO); } static short BIT_COUNT(short a) { @@ -6444,7 +6444,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BIT_COUNTShort256VectorTests(IntFunction fa) { + static void BIT_COUNTShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6455,11 +6455,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::BIT_COUNT); + assertArraysEquals(r, a, ShortVector256Tests::BIT_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void BIT_COUNTMaskedShort256VectorTests(IntFunction fa, + static void BIT_COUNTMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6473,7 +6473,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ShortVector256Tests::BIT_COUNT); } static short TRAILING_ZEROS_COUNT(short a) { @@ -6481,7 +6481,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void TRAILING_ZEROS_COUNTShort256VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6492,11 +6492,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVector256Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedShort256VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6510,7 +6510,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVector256Tests::TRAILING_ZEROS_COUNT); } static short LEADING_ZEROS_COUNT(short a) { @@ -6518,7 +6518,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LEADING_ZEROS_COUNTShort256VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6529,11 +6529,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVector256Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedShort256VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6547,7 +6547,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVector256Tests::LEADING_ZEROS_COUNT); } static short REVERSE(short a) { @@ -6555,7 +6555,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSEShort256VectorTests(IntFunction fa) { + static void REVERSEShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6566,11 +6566,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::REVERSE); + assertArraysEquals(r, a, ShortVector256Tests::REVERSE); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSEMaskedShort256VectorTests(IntFunction fa, + static void REVERSEMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6584,7 +6584,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::REVERSE); + assertArraysEquals(r, a, mask, ShortVector256Tests::REVERSE); } static short REVERSE_BYTES(short a) { @@ -6592,7 +6592,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSE_BYTESShort256VectorTests(IntFunction fa) { + static void REVERSE_BYTESShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6603,11 +6603,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ShortVector256Tests::REVERSE_BYTES); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedShort256VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedShortVector256Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6621,7 +6621,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short256VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ShortVector256Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6629,7 +6629,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandShort256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandShortVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6642,7 +6642,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::band); + assertArraysEquals(r, a, b, ShortVector256Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6650,7 +6650,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorShort256VectorTests(IntFunction fa, IntFunction fb) { + static void maskorShortVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6663,7 +6663,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::bor); + assertArraysEquals(r, a, b, ShortVector256Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6671,7 +6671,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorShort256VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorShortVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6684,7 +6684,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::bxor); + assertArraysEquals(r, a, b, ShortVector256Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6692,7 +6692,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotShort256VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotShortVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6705,7 +6705,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::bandNot); + assertArraysEquals(r, a, b, ShortVector256Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6713,7 +6713,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqShort256VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqShortVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6726,7 +6726,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short256VectorTests::beq); + assertArraysEquals(r, a, b, ShortVector256Tests::beq); } static boolean unot(boolean a) { @@ -6734,7 +6734,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotShort256VectorTests(IntFunction fa) { + static void masknotShortVector256Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6745,7 +6745,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short256VectorTests::unot); + assertArraysEquals(r, a, ShortVector256Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6762,7 +6762,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongShort256VectorTests(IntFunction fa) { + static void maskFromToLongShortVector256Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6776,7 +6776,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShort256VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltShortVector256TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6792,7 +6792,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShort256VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqShortVector256TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6808,7 +6808,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toIntArrayShort256VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayShortVector256TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6819,7 +6819,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toLongArrayShort256VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayShortVector256TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6830,7 +6830,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toDoubleArrayShort256VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayShortVector256TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6841,7 +6841,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toStringShort256VectorTestsSmokeTest(IntFunction fa) { + static void toStringShortVector256TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6854,7 +6854,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void hashCodeShort256VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeShortVector256TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6887,7 +6887,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceLongShort256VectorTests(IntFunction fa) { + static void ADDReduceLongShortVector256Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6903,7 +6903,7 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Short256VectorTests::ADDReduceLong, Short256VectorTests::ADDReduceAllLong); + ShortVector256Tests::ADDReduceLong, ShortVector256Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(short[] a, int idx, boolean[] mask) { @@ -6926,7 +6926,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceLongShort256VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongShortVector256TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6944,11 +6944,11 @@ public class Short256VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Short256VectorTests::ADDReduceLongMasked, Short256VectorTests::ADDReduceAllLongMasked); + ShortVector256Tests::ADDReduceLongMasked, ShortVector256Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastLongShort256VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongShortVector256TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -6959,7 +6959,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShort256VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendShortVector256TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6973,12 +6973,12 @@ public class Short256VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Short256VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector256Tests::blend); } @Test(dataProvider = "shortUnaryOpSelectFromProvider") - static void SelectFromShort256VectorTests(IntFunction fa, + static void SelectFromShortVector256Tests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); short[] order = fs.apply(a.length, SPECIES.length()); @@ -6994,7 +6994,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorShort256VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorShortVector256Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] idx = fc.apply(SPECIES.length()); @@ -7012,7 +7012,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpSelectFromMaskProvider") - static void SelectFromShort256VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromShortVector256TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -7031,7 +7031,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousShort256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousShortVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7047,7 +7047,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringShort256VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringShortVector256TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7061,7 +7061,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsShort256VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsShortVector256TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7075,7 +7075,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsShort256VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsShortVector256Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7091,7 +7091,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeShort256VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeShortVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7113,7 +7113,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountShort256VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountShortVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7124,7 +7124,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short256VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ShortVector256Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7138,7 +7138,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueShort256VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueShortVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7149,7 +7149,7 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short256VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ShortVector256Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7163,7 +7163,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueShort256VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueShortVector256TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7174,11 +7174,11 @@ public class Short256VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short256VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ShortVector256Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressShort256VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressShortVector256TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7206,7 +7206,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeShort256VectorTestsSmokeTest(int offset) { + static void indexInRangeShortVector256TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7220,7 +7220,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongShort256VectorTestsSmokeTest(int offset) { + static void indexInRangeLongShortVector256TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7247,14 +7247,14 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundShort256VectorTestsSmokeTest(int length) { + static void loopBoundShortVector256TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongShort256VectorTestsSmokeTest(int _length) { + static void loopBoundLongShortVector256TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7262,21 +7262,21 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeShort256VectorTestsSmokeTest() { + static void ElementSizeShortVector256TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Short.SIZE); } @Test - static void VectorShapeShort256VectorTestsSmokeTest() { + static void VectorShapeShortVector256TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_256_BIT)); } @Test - static void ShapeWithLanesShort256VectorTestsSmokeTest() { + static void ShapeWithLanesShortVector256TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(short.class); @@ -7284,32 +7284,32 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeShort256VectorTestsSmokeTest() { + static void ElementTypeShortVector256TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementType() == short.class); } @Test - static void SpeciesElementSizeShort256VectorTestsSmokeTest() { + static void SpeciesElementSizeShortVector256TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementSize() == Short.SIZE); } @Test - static void VectorTypeShort256VectorTestsSmokeTest() { + static void VectorTypeShortVector256TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesShort256VectorTestsSmokeTest() { + static void WithLanesShortVector256TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(short.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeShort256VectorTestsSmokeTest() { + static void WithShapeShortVector256TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7317,7 +7317,7 @@ public class Short256VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueShort256VectorTestsSmokeTest() { + static void MaskAllTrueShortVector256TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Short512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ShortVector512LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Short512VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ShortVector512LoadStoreTests.java index accbe0008b5..74e485e3391 100644 --- a/test/jdk/jdk/incubator/vector/Short512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVector512LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Short512VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation ShortVector512LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Short512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ShortVector512LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_512; diff --git a/test/jdk/jdk/incubator/vector/Short512VectorTests.java b/test/jdk/jdk/incubator/vector/ShortVector512Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Short512VectorTests.java rename to test/jdk/jdk/incubator/vector/ShortVector512Tests.java index 7a08de22cb8..69dc6d8019f 100644 --- a/test/jdk/jdk/incubator/vector/Short512VectorTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVector512Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Short512VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ShortVector512Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Short512VectorTests extends AbstractVectorTest { +public class ShortVector512Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_512; @@ -1696,7 +1696,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShort512VectorTests(IntFunction fa, IntFunction fb) { + static void ADDShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1709,7 +1709,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::ADD); + assertArraysEquals(r, a, b, ShortVector512Tests::ADD); } static short add(short a, short b) { @@ -1717,7 +1717,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void addShort512VectorTests(IntFunction fa, IntFunction fb) { + static void addShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1728,11 +1728,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short512VectorTests::add); + assertArraysEquals(r, a, b, ShortVector512Tests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1748,11 +1748,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::ADD); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1766,7 +1766,7 @@ public class Short512VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short512VectorTests::add); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::add); } static short SUB(short a, short b) { @@ -1774,7 +1774,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void SUBShort512VectorTests(IntFunction fa, IntFunction fb) { + static void SUBShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1787,7 +1787,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::SUB); + assertArraysEquals(r, a, b, ShortVector512Tests::SUB); } static short sub(short a, short b) { @@ -1795,7 +1795,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void subShort512VectorTests(IntFunction fa, IntFunction fb) { + static void subShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1806,11 +1806,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short512VectorTests::sub); + assertArraysEquals(r, a, b, ShortVector512Tests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void SUBShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1826,11 +1826,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::SUB); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::SUB); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1844,7 +1844,7 @@ public class Short512VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short512VectorTests::sub); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::sub); } static short MUL(short a, short b) { @@ -1852,7 +1852,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MULShort512VectorTests(IntFunction fa, IntFunction fb) { + static void MULShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1865,7 +1865,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::MUL); + assertArraysEquals(r, a, b, ShortVector512Tests::MUL); } static short mul(short a, short b) { @@ -1873,7 +1873,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShort512VectorTests(IntFunction fa, IntFunction fb) { + static void mulShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1884,11 +1884,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short512VectorTests::mul); + assertArraysEquals(r, a, b, ShortVector512Tests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void MULShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1904,11 +1904,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::MUL); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::MUL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1922,7 +1922,7 @@ public class Short512VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short512VectorTests::mul); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::mul); } static short DIV(short a, short b) { @@ -1930,7 +1930,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void DIVShort512VectorTests(IntFunction fa, IntFunction fb) { + static void DIVShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1945,7 +1945,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::DIV); + assertArraysEquals(r, a, b, ShortVector512Tests::DIV); } static short div(short a, short b) { @@ -1953,7 +1953,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void divShort512VectorTests(IntFunction fa, IntFunction fb) { + static void divShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1968,11 +1968,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::div); + assertArraysEquals(r, a, b, ShortVector512Tests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void DIVShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1990,11 +1990,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::DIV); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::DIV); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2012,7 +2012,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::div); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::div); } static short FIRST_NONZERO(short a, short b) { @@ -2020,7 +2020,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void FIRST_NONZEROShort512VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2033,11 +2033,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ShortVector512Tests::FIRST_NONZERO); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void FIRST_NONZEROShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2053,7 +2053,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::FIRST_NONZERO); } static short AND(short a, short b) { @@ -2061,7 +2061,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShort512VectorTests(IntFunction fa, IntFunction fb) { + static void ANDShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2074,7 +2074,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::AND); + assertArraysEquals(r, a, b, ShortVector512Tests::AND); } static short and(short a, short b) { @@ -2082,7 +2082,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void andShort512VectorTests(IntFunction fa, IntFunction fb) { + static void andShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2093,11 +2093,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short512VectorTests::and); + assertArraysEquals(r, a, b, ShortVector512Tests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2113,7 +2113,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::AND); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::AND); } static short AND_NOT(short a, short b) { @@ -2121,7 +2121,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void AND_NOTShort512VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2134,11 +2134,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::AND_NOT); + assertArraysEquals(r, a, b, ShortVector512Tests::AND_NOT); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void AND_NOTShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2154,7 +2154,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::AND_NOT); } static short OR(short a, short b) { @@ -2162,7 +2162,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort512VectorTests(IntFunction fa, IntFunction fb) { + static void ORShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2175,7 +2175,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::OR); + assertArraysEquals(r, a, b, ShortVector512Tests::OR); } static short or(short a, short b) { @@ -2183,7 +2183,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void orShort512VectorTests(IntFunction fa, IntFunction fb) { + static void orShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2194,11 +2194,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short512VectorTests::or); + assertArraysEquals(r, a, b, ShortVector512Tests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2214,7 +2214,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::OR); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::OR); } static short XOR(short a, short b) { @@ -2222,7 +2222,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void XORShort512VectorTests(IntFunction fa, IntFunction fb) { + static void XORShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2235,11 +2235,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::XOR); + assertArraysEquals(r, a, b, ShortVector512Tests::XOR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void XORShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2255,11 +2255,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::XOR); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::XOR); } @Test(dataProvider = "shortBinaryOpProvider") - static void addShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2269,11 +2269,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2286,11 +2286,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector512Tests::add); } @Test(dataProvider = "shortBinaryOpProvider") - static void subShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2300,11 +2300,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2317,11 +2317,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector512Tests::sub); } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2331,11 +2331,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2348,11 +2348,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector512Tests::mul); } @Test(dataProvider = "shortBinaryOpProvider") - static void divShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2364,11 +2364,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2383,11 +2383,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector512Tests::div); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2397,11 +2397,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void orShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2411,11 +2411,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::or); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2428,11 +2428,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector512Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2442,11 +2442,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void andShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2456,11 +2456,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::and); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2473,11 +2473,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector512Tests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2487,11 +2487,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Short512VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ShortVector512Tests::OR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2504,11 +2504,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Short512VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector512Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShort512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDShortVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2518,11 +2518,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Short512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ShortVector512Tests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShort512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDShortVector512TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2535,7 +2535,7 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Short512VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector512Tests::ADD); } static short LSHL(short a, short b) { @@ -2543,7 +2543,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShort512VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2556,11 +2556,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::LSHL); + assertArraysEquals(r, a, b, ShortVector512Tests::LSHL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2576,7 +2576,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::LSHL); } static short ASHR(short a, short b) { @@ -2584,7 +2584,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShort512VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2597,11 +2597,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::ASHR); + assertArraysEquals(r, a, b, ShortVector512Tests::ASHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2617,7 +2617,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::ASHR); } static short LSHR(short a, short b) { @@ -2625,7 +2625,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShort512VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2638,11 +2638,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::LSHR); + assertArraysEquals(r, a, b, ShortVector512Tests::LSHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2658,7 +2658,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::LSHR); } static short LSHL_unary(short a, short b) { @@ -2666,7 +2666,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShort512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLShortVector512TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2678,11 +2678,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short512VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ShortVector512Tests::LSHL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShort512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2697,7 +2697,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector512Tests::LSHL_unary); } static short LSHR_unary(short a, short b) { @@ -2705,7 +2705,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShort512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRShortVector512TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2717,11 +2717,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short512VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ShortVector512Tests::LSHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShort512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2736,7 +2736,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector512Tests::LSHR_unary); } static short ASHR_unary(short a, short b) { @@ -2744,7 +2744,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShort512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRShortVector512TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2756,11 +2756,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short512VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ShortVector512Tests::ASHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShort512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2775,7 +2775,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector512Tests::ASHR_unary); } static short ROR(short a, short b) { @@ -2783,7 +2783,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShort512VectorTests(IntFunction fa, IntFunction fb) { + static void RORShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2796,11 +2796,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::ROR); + assertArraysEquals(r, a, b, ShortVector512Tests::ROR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2816,7 +2816,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::ROR); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::ROR); } static short ROL(short a, short b) { @@ -2824,7 +2824,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShort512VectorTests(IntFunction fa, IntFunction fb) { + static void ROLShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2837,11 +2837,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::ROL); + assertArraysEquals(r, a, b, ShortVector512Tests::ROL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2857,7 +2857,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::ROL); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::ROL); } static short ROR_unary(short a, short b) { @@ -2865,7 +2865,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShort512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORShortVector512TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2877,11 +2877,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short512VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ShortVector512Tests::ROR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShort512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORShortVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2896,7 +2896,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector512Tests::ROR_unary); } static short ROL_unary(short a, short b) { @@ -2904,7 +2904,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShort512VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLShortVector512TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2916,11 +2916,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short512VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ShortVector512Tests::ROL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShort512VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLShortVector512TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2935,14 +2935,14 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector512Tests::ROL_unary); } static short LSHR_binary_const(short a) { return (short)(((a & 0xFFFF) >>> CONST_SHIFT)); } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHRShort512VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRShortVector512TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2953,11 +2953,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short512VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ShortVector512Tests::LSHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHRShort512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRShortVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2971,7 +2971,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short512VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector512Tests::LSHR_binary_const); } static short LSHL_binary_const(short a) { @@ -2979,7 +2979,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHLShort512VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLShortVector512TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2990,11 +2990,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short512VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ShortVector512Tests::LSHL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHLShort512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLShortVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3008,7 +3008,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short512VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector512Tests::LSHL_binary_const); } static short ASHR_binary_const(short a) { @@ -3016,7 +3016,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ASHRShort512VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRShortVector512TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3027,11 +3027,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short512VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ShortVector512Tests::ASHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ASHRShort512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRShortVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3045,7 +3045,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short512VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector512Tests::ASHR_binary_const); } static short ROR_binary_const(short a) { @@ -3053,7 +3053,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void RORShort512VectorTestsScalarShiftConst(IntFunction fa) { + static void RORShortVector512TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3064,11 +3064,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short512VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ShortVector512Tests::ROR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void RORShort512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORShortVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3082,7 +3082,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short512VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector512Tests::ROR_binary_const); } static short ROL_binary_const(short a) { @@ -3090,7 +3090,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ROLShort512VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLShortVector512TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3101,11 +3101,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short512VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ShortVector512Tests::ROL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ROLShort512VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLShortVector512TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3119,14 +3119,14 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short512VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector512Tests::ROL_binary_const); } static ShortVector bv_MIN = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MINShort512VectorTestsWithMemOp(IntFunction fa) { + static void MINShortVector512TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3137,13 +3137,13 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short512VectorTests::MIN); + assertArraysEquals(r, a, (short)10, ShortVector512Tests::MIN); } static ShortVector bv_min = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void minShort512VectorTestsWithMemOp(IntFunction fa) { + static void minShortVector512TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3154,13 +3154,13 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short512VectorTests::min); + assertArraysEquals(r, a, (short)10, ShortVector512Tests::min); } static ShortVector bv_MIN_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINShort512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINShortVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3173,13 +3173,13 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, Short512VectorTests::MIN); + assertArraysEquals(r, a, (short)10, mask, ShortVector512Tests::MIN); } static ShortVector bv_MAX = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MAXShort512VectorTestsWithMemOp(IntFunction fa) { + static void MAXShortVector512TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3190,13 +3190,13 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short512VectorTests::MAX); + assertArraysEquals(r, a, (short)10, ShortVector512Tests::MAX); } static ShortVector bv_max = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void maxShort512VectorTestsWithMemOp(IntFunction fa) { + static void maxShortVector512TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3207,13 +3207,13 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short512VectorTests::max); + assertArraysEquals(r, a, (short)10, ShortVector512Tests::max); } static ShortVector bv_MAX_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXShort512VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXShortVector512TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3226,7 +3226,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, Short512VectorTests::MAX); + assertArraysEquals(r, a, (short)10, mask, ShortVector512Tests::MAX); } static short MIN(short a, short b) { @@ -3234,7 +3234,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShort512VectorTests(IntFunction fa, IntFunction fb) { + static void MINShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3247,7 +3247,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::MIN); + assertArraysEquals(r, a, b, ShortVector512Tests::MIN); } static short min(short a, short b) { @@ -3255,7 +3255,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void minShort512VectorTests(IntFunction fa, IntFunction fb) { + static void minShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3266,7 +3266,7 @@ public class Short512VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short512VectorTests::min); + assertArraysEquals(r, a, b, ShortVector512Tests::min); } static short MAX(short a, short b) { @@ -3274,7 +3274,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShort512VectorTests(IntFunction fa, IntFunction fb) { + static void MAXShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3287,7 +3287,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::MAX); + assertArraysEquals(r, a, b, ShortVector512Tests::MAX); } static short max(short a, short b) { @@ -3295,7 +3295,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShort512VectorTests(IntFunction fa, IntFunction fb) { + static void maxShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3306,7 +3306,7 @@ public class Short512VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short512VectorTests::max); + assertArraysEquals(r, a, b, ShortVector512Tests::max); } static short UMIN(short a, short b) { @@ -3314,7 +3314,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMINShort512VectorTests(IntFunction fa, IntFunction fb) { + static void UMINShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3327,11 +3327,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::UMIN); + assertArraysEquals(r, a, b, ShortVector512Tests::UMIN); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMINShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3347,7 +3347,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::UMIN); } static short UMAX(short a, short b) { @@ -3355,7 +3355,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMAXShort512VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3368,11 +3368,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::UMAX); + assertArraysEquals(r, a, b, ShortVector512Tests::UMAX); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMAXShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3388,7 +3388,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::UMAX); } static short SADD(short a, short b) { @@ -3396,7 +3396,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SADDShort512VectorTests(IntFunction fa, IntFunction fb) { + static void SADDShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3409,11 +3409,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::SADD); + assertArraysEquals(r, a, b, ShortVector512Tests::SADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SADDShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3429,7 +3429,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::SADD); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::SADD); } static short SSUB(short a, short b) { @@ -3437,7 +3437,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SSUBShort512VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3450,11 +3450,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::SSUB); + assertArraysEquals(r, a, b, ShortVector512Tests::SSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SSUBShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3470,7 +3470,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::SSUB); } static short SUADD(short a, short b) { @@ -3478,7 +3478,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUADDShort512VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3491,11 +3491,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::SUADD); + assertArraysEquals(r, a, b, ShortVector512Tests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUADDShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3511,7 +3511,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::SUADD); } static short SUSUB(short a, short b) { @@ -3519,7 +3519,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUSUBShort512VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3532,11 +3532,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::SUSUB); + assertArraysEquals(r, a, b, ShortVector512Tests::SUSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUSUBShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3552,11 +3552,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::SUSUB); } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3566,11 +3566,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::MIN); } @Test(dataProvider = "shortBinaryOpProvider") - static void minShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3580,11 +3580,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::min); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::min); } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3594,11 +3594,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::MAX); } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3608,10 +3608,10 @@ public class Short512VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short512VectorTests::max); + assertBroadcastArraysEquals(r, a, b, ShortVector512Tests::max); } @Test(dataProvider = "shortSaturatingBinaryOpAssocProvider") - static void SUADDAssocShort512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocShortVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -3628,11 +3628,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Short512VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ShortVector512Tests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3653,7 +3653,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Short512VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ShortVector512Tests::SUADD); } static short ANDReduce(short[] a, int idx) { @@ -3675,7 +3675,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ANDReduceShort512VectorTests(IntFunction fa) { + static void ANDReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3691,7 +3691,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::ANDReduce, Short512VectorTests::ANDReduceAll); + ShortVector512Tests::ANDReduce, ShortVector512Tests::ANDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3737,7 +3737,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ANDReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3755,7 +3755,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::ANDReduceMasked, Short512VectorTests::ANDReduceAllMasked); + ShortVector512Tests::ANDReduceMasked, ShortVector512Tests::ANDReduceAllMasked); } static short ORReduce(short[] a, int idx) { @@ -3777,7 +3777,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ORReduceShort512VectorTests(IntFunction fa) { + static void ORReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3793,7 +3793,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::ORReduce, Short512VectorTests::ORReduceAll); + ShortVector512Tests::ORReduce, ShortVector512Tests::ORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3839,7 +3839,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ORReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3857,7 +3857,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::ORReduceMasked, Short512VectorTests::ORReduceAllMasked); + ShortVector512Tests::ORReduceMasked, ShortVector512Tests::ORReduceAllMasked); } static short XORReduce(short[] a, int idx) { @@ -3879,7 +3879,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void XORReduceShort512VectorTests(IntFunction fa) { + static void XORReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3895,7 +3895,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::XORReduce, Short512VectorTests::XORReduceAll); + ShortVector512Tests::XORReduce, ShortVector512Tests::XORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3941,7 +3941,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void XORReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3959,7 +3959,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::XORReduceMasked, Short512VectorTests::XORReduceAllMasked); + ShortVector512Tests::XORReduceMasked, ShortVector512Tests::XORReduceAllMasked); } static short ADDReduce(short[] a, int idx) { @@ -3981,7 +3981,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceShort512VectorTests(IntFunction fa) { + static void ADDReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3997,7 +3997,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::ADDReduce, Short512VectorTests::ADDReduceAll); + ShortVector512Tests::ADDReduce, ShortVector512Tests::ADDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4043,7 +4043,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4061,7 +4061,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::ADDReduceMasked, Short512VectorTests::ADDReduceAllMasked); + ShortVector512Tests::ADDReduceMasked, ShortVector512Tests::ADDReduceAllMasked); } static short MULReduce(short[] a, int idx) { @@ -4083,7 +4083,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MULReduceShort512VectorTests(IntFunction fa) { + static void MULReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4099,7 +4099,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::MULReduce, Short512VectorTests::MULReduceAll); + ShortVector512Tests::MULReduce, ShortVector512Tests::MULReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4145,7 +4145,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MULReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4163,7 +4163,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::MULReduceMasked, Short512VectorTests::MULReduceAllMasked); + ShortVector512Tests::MULReduceMasked, ShortVector512Tests::MULReduceAllMasked); } static short MINReduce(short[] a, int idx) { @@ -4185,7 +4185,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MINReduceShort512VectorTests(IntFunction fa) { + static void MINReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4201,7 +4201,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::MINReduce, Short512VectorTests::MINReduceAll); + ShortVector512Tests::MINReduce, ShortVector512Tests::MINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4247,7 +4247,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4265,7 +4265,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::MINReduceMasked, Short512VectorTests::MINReduceAllMasked); + ShortVector512Tests::MINReduceMasked, ShortVector512Tests::MINReduceAllMasked); } static short MAXReduce(short[] a, int idx) { @@ -4287,7 +4287,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MAXReduceShort512VectorTests(IntFunction fa) { + static void MAXReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4303,7 +4303,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::MAXReduce, Short512VectorTests::MAXReduceAll); + ShortVector512Tests::MAXReduce, ShortVector512Tests::MAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4349,7 +4349,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4367,7 +4367,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::MAXReduceMasked, Short512VectorTests::MAXReduceAllMasked); + ShortVector512Tests::MAXReduceMasked, ShortVector512Tests::MAXReduceAllMasked); } static short UMINReduce(short[] a, int idx) { @@ -4389,7 +4389,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMINReduceShort512VectorTests(IntFunction fa) { + static void UMINReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4405,7 +4405,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::UMINReduce, Short512VectorTests::UMINReduceAll); + ShortVector512Tests::UMINReduce, ShortVector512Tests::UMINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4451,7 +4451,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMINReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4469,7 +4469,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::UMINReduceMasked, Short512VectorTests::UMINReduceAllMasked); + ShortVector512Tests::UMINReduceMasked, ShortVector512Tests::UMINReduceAllMasked); } static short UMAXReduce(short[] a, int idx) { @@ -4491,7 +4491,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMAXReduceShort512VectorTests(IntFunction fa) { + static void UMAXReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4507,7 +4507,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::UMAXReduce, Short512VectorTests::UMAXReduceAll); + ShortVector512Tests::UMAXReduce, ShortVector512Tests::UMAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4553,7 +4553,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMAXReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4571,7 +4571,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::UMAXReduceMasked, Short512VectorTests::UMAXReduceAllMasked); + ShortVector512Tests::UMAXReduceMasked, ShortVector512Tests::UMAXReduceAllMasked); } static short FIRST_NONZEROReduce(short[] a, int idx) { @@ -4593,7 +4593,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void FIRST_NONZEROReduceShort512VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4609,7 +4609,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::FIRST_NONZEROReduce, Short512VectorTests::FIRST_NONZEROReduceAll); + ShortVector512Tests::FIRST_NONZEROReduce, ShortVector512Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4655,7 +4655,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void FIRST_NONZEROReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4673,7 +4673,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::FIRST_NONZEROReduceMasked, Short512VectorTests::FIRST_NONZEROReduceAllMasked); + ShortVector512Tests::FIRST_NONZEROReduceMasked, ShortVector512Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4686,7 +4686,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueShort512VectorTests(IntFunction fm) { + static void anyTrueShortVector512Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4697,7 +4697,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Short512VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ShortVector512Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4710,7 +4710,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueShort512VectorTests(IntFunction fm) { + static void allTrueShortVector512Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4721,7 +4721,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Short512VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ShortVector512Tests::allTrue); } static short SUADDReduce(short[] a, int idx) { @@ -4743,7 +4743,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingUnaryOpProvider") - static void SUADDReduceShort512VectorTests(IntFunction fa) { + static void SUADDReduceShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4759,7 +4759,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short512VectorTests::SUADDReduce, Short512VectorTests::SUADDReduceAll); + ShortVector512Tests::SUADDReduce, ShortVector512Tests::SUADDReduceAll); } @Test(dataProvider = "shortSaturatingUnaryOpProvider") @@ -4804,7 +4804,7 @@ public class Short512VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "shortSaturatingUnaryOpMaskProvider") - static void SUADDReduceShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4822,11 +4822,11 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::SUADDReduceMasked, Short512VectorTests::SUADDReduceAllMasked); + ShortVector512Tests::SUADDReduceMasked, ShortVector512Tests::SUADDReduceAllMasked); } @Test(dataProvider = "shortBinaryOpProvider") - static void withShort512VectorTests(IntFunction fa, IntFunction fb) { + static void withShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -4849,7 +4849,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_DEFAULTShort512VectorTests(IntFunction fa) { + static void IS_DEFAULTShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4866,7 +4866,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_DEFAULTMaskedShort512VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4890,7 +4890,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_NEGATIVEShort512VectorTests(IntFunction fa) { + static void IS_NEGATIVEShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4907,7 +4907,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_NEGATIVEMaskedShort512VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4927,7 +4927,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort512VectorTests(IntFunction fa, IntFunction fb) { + static void LTShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4946,7 +4946,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShort512VectorTests(IntFunction fa, IntFunction fb) { + static void ltShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4965,7 +4965,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4988,7 +4988,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GTShort512VectorTests(IntFunction fa, IntFunction fb) { + static void GTShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5007,7 +5007,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GTShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5030,7 +5030,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort512VectorTests(IntFunction fa, IntFunction fb) { + static void EQShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5049,7 +5049,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShort512VectorTests(IntFunction fa, IntFunction fb) { + static void eqShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5068,7 +5068,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5091,7 +5091,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void NEShort512VectorTests(IntFunction fa, IntFunction fb) { + static void NEShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5110,7 +5110,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void NEShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5133,7 +5133,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LEShort512VectorTests(IntFunction fa, IntFunction fb) { + static void LEShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5152,7 +5152,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LEShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5175,7 +5175,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GEShort512VectorTests(IntFunction fa, IntFunction fb) { + static void GEShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5194,7 +5194,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GEShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5217,7 +5217,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULTShort512VectorTests(IntFunction fa, IntFunction fb) { + static void ULTShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5236,7 +5236,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULTShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5259,7 +5259,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGTShort512VectorTests(IntFunction fa, IntFunction fb) { + static void UGTShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5278,7 +5278,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGTShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5301,7 +5301,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULEShort512VectorTests(IntFunction fa, IntFunction fb) { + static void ULEShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5320,7 +5320,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULEShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5343,7 +5343,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGEShort512VectorTests(IntFunction fa, IntFunction fb) { + static void UGEShortVector512Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5362,7 +5362,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGEShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5385,7 +5385,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5401,7 +5401,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5421,7 +5421,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5437,7 +5437,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTShortVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5457,7 +5457,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5473,7 +5473,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5493,7 +5493,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5509,7 +5509,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQShortVector512TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5533,7 +5533,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShort512VectorTests(IntFunction fa, IntFunction fb, + static void blendShortVector512Tests(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5549,11 +5549,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short512VectorTests::blend); + assertArraysEquals(r, a, b, mask, ShortVector512Tests::blend); } @Test(dataProvider = "shortUnaryOpShuffleProvider") - static void RearrangeShort512VectorTests(IntFunction fa, + static void RearrangeShortVector512Tests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5570,7 +5570,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpShuffleMaskProvider") - static void RearrangeShort512VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeShortVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -5588,7 +5588,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void compressShort512VectorTests(IntFunction fa, + static void compressShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5606,7 +5606,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void expandShort512VectorTests(IntFunction fa, + static void expandShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5624,7 +5624,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void getShort512VectorTests(IntFunction fa) { + static void getShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5780,7 +5780,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastShort512VectorTests(IntFunction fa) { + static void BroadcastShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5794,7 +5794,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZeroShort512VectorTests(IntFunction fa) { + static void ZeroShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5819,7 +5819,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void sliceUnaryShort512VectorTests(IntFunction fa) { + static void sliceUnaryShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5830,7 +5830,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Short512VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ShortVector512Tests::sliceUnary); } static short[] sliceBinary(short[] a, short[] b, int origin, int idx) { @@ -5847,7 +5847,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void sliceBinaryShort512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryShortVector512TestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5860,7 +5860,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Short512VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ShortVector512Tests::sliceBinary); } static short[] slice(short[] a, short[] b, int origin, boolean[] mask, int idx) { @@ -5877,7 +5877,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void sliceShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5894,7 +5894,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Short512VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ShortVector512Tests::slice); } static short[] unsliceUnary(short[] a, int origin, int idx) { @@ -5911,7 +5911,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void unsliceUnaryShort512VectorTests(IntFunction fa) { + static void unsliceUnaryShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5922,7 +5922,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Short512VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ShortVector512Tests::unsliceUnary); } static short[] unsliceBinary(short[] a, short[] b, int origin, int part, int idx) { @@ -5948,7 +5948,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void unsliceBinaryShort512VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryShortVector512TestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5962,7 +5962,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Short512VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ShortVector512Tests::unsliceBinary); } static short[] unslice(short[] a, short[] b, int origin, int part, boolean[] mask, int idx) { @@ -6002,7 +6002,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void unsliceShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6019,7 +6019,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Short512VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ShortVector512Tests::unslice); } static short BITWISE_BLEND(short a, short b, short c) { @@ -6031,7 +6031,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6046,11 +6046,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Short512VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ShortVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6063,11 +6063,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Short512VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ShortVector512Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort512VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector512TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6085,11 +6085,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Short512VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ShortVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6100,11 +6100,11 @@ public class Short512VectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Short512VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ShortVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6115,11 +6115,11 @@ public class Short512VectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Short512VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6130,11 +6130,11 @@ public class Short512VectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Short512VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ShortVector512Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort512VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector512TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6145,11 +6145,11 @@ public class Short512VectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Short512VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVector512Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6164,11 +6164,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Short512VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ShortVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort512VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector512TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6183,11 +6183,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Short512VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ShortVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Short512VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVector512Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort512VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector512TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6213,11 +6213,11 @@ public class Short512VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Short512VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVector512Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort512VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector512TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6231,7 +6231,7 @@ public class Short512VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Short512VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ShortVector512Tests::BITWISE_BLEND); } static short NEG(short a) { @@ -6243,7 +6243,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NEGShort512VectorTests(IntFunction fa) { + static void NEGShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6254,11 +6254,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::NEG); + assertArraysEquals(r, a, ShortVector512Tests::NEG); } @Test(dataProvider = "shortUnaryOpProvider") - static void negShort512VectorTests(IntFunction fa) { + static void negShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6269,11 +6269,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::neg); + assertArraysEquals(r, a, ShortVector512Tests::neg); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NEGMaskedShort512VectorTests(IntFunction fa, + static void NEGMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6287,7 +6287,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::NEG); + assertArraysEquals(r, a, mask, ShortVector512Tests::NEG); } static short ABS(short a) { @@ -6299,7 +6299,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ABSShort512VectorTests(IntFunction fa) { + static void ABSShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6310,11 +6310,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::ABS); + assertArraysEquals(r, a, ShortVector512Tests::ABS); } @Test(dataProvider = "shortUnaryOpProvider") - static void absShort512VectorTests(IntFunction fa) { + static void absShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6325,11 +6325,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::abs); + assertArraysEquals(r, a, ShortVector512Tests::abs); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ABSMaskedShort512VectorTests(IntFunction fa, + static void ABSMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6343,7 +6343,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::ABS); + assertArraysEquals(r, a, mask, ShortVector512Tests::ABS); } static short NOT(short a) { @@ -6355,7 +6355,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NOTShort512VectorTests(IntFunction fa) { + static void NOTShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6366,11 +6366,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::NOT); + assertArraysEquals(r, a, ShortVector512Tests::NOT); } @Test(dataProvider = "shortUnaryOpProvider") - static void notShort512VectorTests(IntFunction fa) { + static void notShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6381,11 +6381,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::not); + assertArraysEquals(r, a, ShortVector512Tests::not); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NOTMaskedShort512VectorTests(IntFunction fa, + static void NOTMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6399,7 +6399,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::NOT); + assertArraysEquals(r, a, mask, ShortVector512Tests::NOT); } static short ZOMO(short a) { @@ -6407,7 +6407,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZOMOShort512VectorTests(IntFunction fa) { + static void ZOMOShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6418,11 +6418,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::ZOMO); + assertArraysEquals(r, a, ShortVector512Tests::ZOMO); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ZOMOMaskedShort512VectorTests(IntFunction fa, + static void ZOMOMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6436,7 +6436,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::ZOMO); + assertArraysEquals(r, a, mask, ShortVector512Tests::ZOMO); } static short BIT_COUNT(short a) { @@ -6444,7 +6444,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BIT_COUNTShort512VectorTests(IntFunction fa) { + static void BIT_COUNTShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6455,11 +6455,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::BIT_COUNT); + assertArraysEquals(r, a, ShortVector512Tests::BIT_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void BIT_COUNTMaskedShort512VectorTests(IntFunction fa, + static void BIT_COUNTMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6473,7 +6473,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ShortVector512Tests::BIT_COUNT); } static short TRAILING_ZEROS_COUNT(short a) { @@ -6481,7 +6481,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void TRAILING_ZEROS_COUNTShort512VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6492,11 +6492,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVector512Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedShort512VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6510,7 +6510,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVector512Tests::TRAILING_ZEROS_COUNT); } static short LEADING_ZEROS_COUNT(short a) { @@ -6518,7 +6518,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LEADING_ZEROS_COUNTShort512VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6529,11 +6529,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVector512Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedShort512VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6547,7 +6547,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVector512Tests::LEADING_ZEROS_COUNT); } static short REVERSE(short a) { @@ -6555,7 +6555,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSEShort512VectorTests(IntFunction fa) { + static void REVERSEShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6566,11 +6566,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::REVERSE); + assertArraysEquals(r, a, ShortVector512Tests::REVERSE); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSEMaskedShort512VectorTests(IntFunction fa, + static void REVERSEMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6584,7 +6584,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::REVERSE); + assertArraysEquals(r, a, mask, ShortVector512Tests::REVERSE); } static short REVERSE_BYTES(short a) { @@ -6592,7 +6592,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSE_BYTESShort512VectorTests(IntFunction fa) { + static void REVERSE_BYTESShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6603,11 +6603,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ShortVector512Tests::REVERSE_BYTES); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedShort512VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedShortVector512Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6621,7 +6621,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short512VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ShortVector512Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6629,7 +6629,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandShort512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandShortVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6642,7 +6642,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::band); + assertArraysEquals(r, a, b, ShortVector512Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6650,7 +6650,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorShort512VectorTests(IntFunction fa, IntFunction fb) { + static void maskorShortVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6663,7 +6663,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::bor); + assertArraysEquals(r, a, b, ShortVector512Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6671,7 +6671,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorShort512VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorShortVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6684,7 +6684,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::bxor); + assertArraysEquals(r, a, b, ShortVector512Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6692,7 +6692,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotShort512VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotShortVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6705,7 +6705,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::bandNot); + assertArraysEquals(r, a, b, ShortVector512Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6713,7 +6713,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqShort512VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqShortVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6726,7 +6726,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short512VectorTests::beq); + assertArraysEquals(r, a, b, ShortVector512Tests::beq); } static boolean unot(boolean a) { @@ -6734,7 +6734,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotShort512VectorTests(IntFunction fa) { + static void masknotShortVector512Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6745,7 +6745,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short512VectorTests::unot); + assertArraysEquals(r, a, ShortVector512Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6762,7 +6762,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongShort512VectorTests(IntFunction fa) { + static void maskFromToLongShortVector512Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6776,7 +6776,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShort512VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltShortVector512TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6792,7 +6792,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqShortVector512TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6808,7 +6808,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toIntArrayShort512VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayShortVector512TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6819,7 +6819,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toLongArrayShort512VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayShortVector512TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6830,7 +6830,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toDoubleArrayShort512VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayShortVector512TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6841,7 +6841,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toStringShort512VectorTestsSmokeTest(IntFunction fa) { + static void toStringShortVector512TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6854,7 +6854,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void hashCodeShort512VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeShortVector512TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6887,7 +6887,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceLongShort512VectorTests(IntFunction fa) { + static void ADDReduceLongShortVector512Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6903,7 +6903,7 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Short512VectorTests::ADDReduceLong, Short512VectorTests::ADDReduceAllLong); + ShortVector512Tests::ADDReduceLong, ShortVector512Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(short[] a, int idx, boolean[] mask) { @@ -6926,7 +6926,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceLongShort512VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongShortVector512TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6944,11 +6944,11 @@ public class Short512VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Short512VectorTests::ADDReduceLongMasked, Short512VectorTests::ADDReduceAllLongMasked); + ShortVector512Tests::ADDReduceLongMasked, ShortVector512Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastLongShort512VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongShortVector512TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -6959,7 +6959,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShort512VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendShortVector512TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6973,12 +6973,12 @@ public class Short512VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Short512VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector512Tests::blend); } @Test(dataProvider = "shortUnaryOpSelectFromProvider") - static void SelectFromShort512VectorTests(IntFunction fa, + static void SelectFromShortVector512Tests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); short[] order = fs.apply(a.length, SPECIES.length()); @@ -6994,7 +6994,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorShort512VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorShortVector512Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] idx = fc.apply(SPECIES.length()); @@ -7012,7 +7012,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpSelectFromMaskProvider") - static void SelectFromShort512VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromShortVector512TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -7031,7 +7031,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousShort512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousShortVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7047,7 +7047,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringShort512VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringShortVector512TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7061,7 +7061,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsShort512VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsShortVector512TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7075,7 +7075,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsShort512VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsShortVector512Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7091,7 +7091,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeShort512VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeShortVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7113,7 +7113,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountShort512VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountShortVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7124,7 +7124,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short512VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ShortVector512Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7138,7 +7138,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueShort512VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueShortVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7149,7 +7149,7 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short512VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ShortVector512Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7163,7 +7163,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueShort512VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueShortVector512TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7174,11 +7174,11 @@ public class Short512VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short512VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ShortVector512Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressShort512VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressShortVector512TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7206,7 +7206,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeShort512VectorTestsSmokeTest(int offset) { + static void indexInRangeShortVector512TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7220,7 +7220,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongShort512VectorTestsSmokeTest(int offset) { + static void indexInRangeLongShortVector512TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7247,14 +7247,14 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundShort512VectorTestsSmokeTest(int length) { + static void loopBoundShortVector512TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongShort512VectorTestsSmokeTest(int _length) { + static void loopBoundLongShortVector512TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7262,21 +7262,21 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeShort512VectorTestsSmokeTest() { + static void ElementSizeShortVector512TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Short.SIZE); } @Test - static void VectorShapeShort512VectorTestsSmokeTest() { + static void VectorShapeShortVector512TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_512_BIT)); } @Test - static void ShapeWithLanesShort512VectorTestsSmokeTest() { + static void ShapeWithLanesShortVector512TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(short.class); @@ -7284,32 +7284,32 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeShort512VectorTestsSmokeTest() { + static void ElementTypeShortVector512TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementType() == short.class); } @Test - static void SpeciesElementSizeShort512VectorTestsSmokeTest() { + static void SpeciesElementSizeShortVector512TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementSize() == Short.SIZE); } @Test - static void VectorTypeShort512VectorTestsSmokeTest() { + static void VectorTypeShortVector512TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesShort512VectorTestsSmokeTest() { + static void WithLanesShortVector512TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(short.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeShort512VectorTestsSmokeTest() { + static void WithShapeShortVector512TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7317,7 +7317,7 @@ public class Short512VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueShort512VectorTestsSmokeTest() { + static void MaskAllTrueShortVector512TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/Short64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ShortVector64LoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/Short64VectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ShortVector64LoadStoreTests.java index 063b3e8ca61..d48c781886c 100644 --- a/test/jdk/jdk/incubator/vector/Short64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVector64LoadStoreTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation - * @run testng/othervm -XX:-TieredCompilation Short64VectorLoadStoreTests + * @run testng/othervm -XX:-TieredCompilation ShortVector64LoadStoreTests * */ @@ -50,7 +50,7 @@ import java.util.List; import java.util.function.*; @Test -public class Short64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ShortVector64LoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_64; diff --git a/test/jdk/jdk/incubator/vector/Short64VectorTests.java b/test/jdk/jdk/incubator/vector/ShortVector64Tests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/Short64VectorTests.java rename to test/jdk/jdk/incubator/vector/ShortVector64Tests.java index 4181dbce164..dd9f7125853 100644 --- a/test/jdk/jdk/incubator/vector/Short64VectorTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVector64Tests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Short64VectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ShortVector64Tests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class Short64VectorTests extends AbstractVectorTest { +public class ShortVector64Tests extends AbstractVectorTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_64; @@ -1696,7 +1696,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShort64VectorTests(IntFunction fa, IntFunction fb) { + static void ADDShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1709,7 +1709,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::ADD); + assertArraysEquals(r, a, b, ShortVector64Tests::ADD); } static short add(short a, short b) { @@ -1717,7 +1717,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void addShort64VectorTests(IntFunction fa, IntFunction fb) { + static void addShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1728,11 +1728,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short64VectorTests::add); + assertArraysEquals(r, a, b, ShortVector64Tests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1748,11 +1748,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::ADD); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void addShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1766,7 +1766,7 @@ public class Short64VectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short64VectorTests::add); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::add); } static short SUB(short a, short b) { @@ -1774,7 +1774,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void SUBShort64VectorTests(IntFunction fa, IntFunction fb) { + static void SUBShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1787,7 +1787,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::SUB); + assertArraysEquals(r, a, b, ShortVector64Tests::SUB); } static short sub(short a, short b) { @@ -1795,7 +1795,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void subShort64VectorTests(IntFunction fa, IntFunction fb) { + static void subShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1806,11 +1806,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short64VectorTests::sub); + assertArraysEquals(r, a, b, ShortVector64Tests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void SUBShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1826,11 +1826,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::SUB); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::SUB); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void subShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1844,7 +1844,7 @@ public class Short64VectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short64VectorTests::sub); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::sub); } static short MUL(short a, short b) { @@ -1852,7 +1852,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MULShort64VectorTests(IntFunction fa, IntFunction fb) { + static void MULShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1865,7 +1865,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::MUL); + assertArraysEquals(r, a, b, ShortVector64Tests::MUL); } static short mul(short a, short b) { @@ -1873,7 +1873,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShort64VectorTests(IntFunction fa, IntFunction fb) { + static void mulShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1884,11 +1884,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short64VectorTests::mul); + assertArraysEquals(r, a, b, ShortVector64Tests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void MULShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1904,11 +1904,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::MUL); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::MUL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1922,7 +1922,7 @@ public class Short64VectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, Short64VectorTests::mul); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::mul); } static short DIV(short a, short b) { @@ -1930,7 +1930,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void DIVShort64VectorTests(IntFunction fa, IntFunction fb) { + static void DIVShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1945,7 +1945,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::DIV); + assertArraysEquals(r, a, b, ShortVector64Tests::DIV); } static short div(short a, short b) { @@ -1953,7 +1953,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void divShort64VectorTests(IntFunction fa, IntFunction fb) { + static void divShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1968,11 +1968,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::div); + assertArraysEquals(r, a, b, ShortVector64Tests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void DIVShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1990,11 +1990,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::DIV); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::DIV); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void divShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2012,7 +2012,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::div); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::div); } static short FIRST_NONZERO(short a, short b) { @@ -2020,7 +2020,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void FIRST_NONZEROShort64VectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2033,11 +2033,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ShortVector64Tests::FIRST_NONZERO); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void FIRST_NONZEROShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2053,7 +2053,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::FIRST_NONZERO); } static short AND(short a, short b) { @@ -2061,7 +2061,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShort64VectorTests(IntFunction fa, IntFunction fb) { + static void ANDShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2074,7 +2074,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::AND); + assertArraysEquals(r, a, b, ShortVector64Tests::AND); } static short and(short a, short b) { @@ -2082,7 +2082,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void andShort64VectorTests(IntFunction fa, IntFunction fb) { + static void andShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2093,11 +2093,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short64VectorTests::and); + assertArraysEquals(r, a, b, ShortVector64Tests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2113,7 +2113,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::AND); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::AND); } static short AND_NOT(short a, short b) { @@ -2121,7 +2121,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void AND_NOTShort64VectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2134,11 +2134,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::AND_NOT); + assertArraysEquals(r, a, b, ShortVector64Tests::AND_NOT); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void AND_NOTShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2154,7 +2154,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::AND_NOT); } static short OR(short a, short b) { @@ -2162,7 +2162,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort64VectorTests(IntFunction fa, IntFunction fb) { + static void ORShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2175,7 +2175,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::OR); + assertArraysEquals(r, a, b, ShortVector64Tests::OR); } static short or(short a, short b) { @@ -2183,7 +2183,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void orShort64VectorTests(IntFunction fa, IntFunction fb) { + static void orShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2194,11 +2194,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short64VectorTests::or); + assertArraysEquals(r, a, b, ShortVector64Tests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2214,7 +2214,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::OR); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::OR); } static short XOR(short a, short b) { @@ -2222,7 +2222,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void XORShort64VectorTests(IntFunction fa, IntFunction fb) { + static void XORShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2235,11 +2235,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::XOR); + assertArraysEquals(r, a, b, ShortVector64Tests::XOR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void XORShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2255,11 +2255,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::XOR); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::XOR); } @Test(dataProvider = "shortBinaryOpProvider") - static void addShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2269,11 +2269,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2286,11 +2286,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short64VectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector64Tests::add); } @Test(dataProvider = "shortBinaryOpProvider") - static void subShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2300,11 +2300,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2317,11 +2317,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short64VectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector64Tests::sub); } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2331,11 +2331,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2348,11 +2348,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short64VectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector64Tests::mul); } @Test(dataProvider = "shortBinaryOpProvider") - static void divShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2364,11 +2364,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2383,11 +2383,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short64VectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector64Tests::div); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2397,11 +2397,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void orShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2411,11 +2411,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::or); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2428,11 +2428,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short64VectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector64Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2442,11 +2442,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void andShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2456,11 +2456,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::and); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2473,11 +2473,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, Short64VectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ShortVector64Tests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShort64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2487,11 +2487,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Short64VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ShortVector64Tests::OR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShort64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2504,11 +2504,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Short64VectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector64Tests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShort64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDShortVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2518,11 +2518,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, Short64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ShortVector64Tests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShort64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDShortVector64TestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2535,7 +2535,7 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, Short64VectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector64Tests::ADD); } static short LSHL(short a, short b) { @@ -2543,7 +2543,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShort64VectorTests(IntFunction fa, IntFunction fb) { + static void LSHLShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2556,11 +2556,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::LSHL); + assertArraysEquals(r, a, b, ShortVector64Tests::LSHL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2576,7 +2576,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::LSHL); } static short ASHR(short a, short b) { @@ -2584,7 +2584,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShort64VectorTests(IntFunction fa, IntFunction fb) { + static void ASHRShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2597,11 +2597,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::ASHR); + assertArraysEquals(r, a, b, ShortVector64Tests::ASHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2617,7 +2617,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::ASHR); } static short LSHR(short a, short b) { @@ -2625,7 +2625,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShort64VectorTests(IntFunction fa, IntFunction fb) { + static void LSHRShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2638,11 +2638,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::LSHR); + assertArraysEquals(r, a, b, ShortVector64Tests::LSHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2658,7 +2658,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::LSHR); } static short LSHL_unary(short a, short b) { @@ -2666,7 +2666,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShort64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLShortVector64TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2678,11 +2678,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short64VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ShortVector64Tests::LSHL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShort64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2697,7 +2697,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short64VectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector64Tests::LSHL_unary); } static short LSHR_unary(short a, short b) { @@ -2705,7 +2705,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShort64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRShortVector64TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2717,11 +2717,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short64VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ShortVector64Tests::LSHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShort64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2736,7 +2736,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short64VectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector64Tests::LSHR_unary); } static short ASHR_unary(short a, short b) { @@ -2744,7 +2744,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShort64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRShortVector64TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2756,11 +2756,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short64VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ShortVector64Tests::ASHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShort64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2775,7 +2775,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short64VectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector64Tests::ASHR_unary); } static short ROR(short a, short b) { @@ -2783,7 +2783,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShort64VectorTests(IntFunction fa, IntFunction fb) { + static void RORShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2796,11 +2796,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::ROR); + assertArraysEquals(r, a, b, ShortVector64Tests::ROR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2816,7 +2816,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::ROR); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::ROR); } static short ROL(short a, short b) { @@ -2824,7 +2824,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShort64VectorTests(IntFunction fa, IntFunction fb) { + static void ROLShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2837,11 +2837,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::ROL); + assertArraysEquals(r, a, b, ShortVector64Tests::ROL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2857,7 +2857,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::ROL); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::ROL); } static short ROR_unary(short a, short b) { @@ -2865,7 +2865,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShort64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORShortVector64TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2877,11 +2877,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short64VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ShortVector64Tests::ROR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShort64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORShortVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2896,7 +2896,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short64VectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector64Tests::ROR_unary); } static short ROL_unary(short a, short b) { @@ -2904,7 +2904,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShort64VectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLShortVector64TestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2916,11 +2916,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, Short64VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ShortVector64Tests::ROL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShort64VectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLShortVector64TestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2935,14 +2935,14 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, Short64VectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVector64Tests::ROL_unary); } static short LSHR_binary_const(short a) { return (short)(((a & 0xFFFF) >>> CONST_SHIFT)); } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHRShort64VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRShortVector64TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2953,11 +2953,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short64VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ShortVector64Tests::LSHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHRShort64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRShortVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2971,7 +2971,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short64VectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector64Tests::LSHR_binary_const); } static short LSHL_binary_const(short a) { @@ -2979,7 +2979,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHLShort64VectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLShortVector64TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2990,11 +2990,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short64VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ShortVector64Tests::LSHL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHLShort64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLShortVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3008,7 +3008,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short64VectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector64Tests::LSHL_binary_const); } static short ASHR_binary_const(short a) { @@ -3016,7 +3016,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ASHRShort64VectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRShortVector64TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3027,11 +3027,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short64VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ShortVector64Tests::ASHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ASHRShort64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRShortVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3045,7 +3045,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short64VectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector64Tests::ASHR_binary_const); } static short ROR_binary_const(short a) { @@ -3053,7 +3053,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void RORShort64VectorTestsScalarShiftConst(IntFunction fa) { + static void RORShortVector64TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3064,11 +3064,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short64VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ShortVector64Tests::ROR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void RORShort64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORShortVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3082,7 +3082,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short64VectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector64Tests::ROR_binary_const); } static short ROL_binary_const(short a) { @@ -3090,7 +3090,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ROLShort64VectorTestsScalarShiftConst(IntFunction fa) { + static void ROLShortVector64TestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3101,11 +3101,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, Short64VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ShortVector64Tests::ROL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ROLShort64VectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLShortVector64TestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3119,14 +3119,14 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, Short64VectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVector64Tests::ROL_binary_const); } static ShortVector bv_MIN = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MINShort64VectorTestsWithMemOp(IntFunction fa) { + static void MINShortVector64TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3137,13 +3137,13 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short64VectorTests::MIN); + assertArraysEquals(r, a, (short)10, ShortVector64Tests::MIN); } static ShortVector bv_min = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void minShort64VectorTestsWithMemOp(IntFunction fa) { + static void minShortVector64TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3154,13 +3154,13 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short64VectorTests::min); + assertArraysEquals(r, a, (short)10, ShortVector64Tests::min); } static ShortVector bv_MIN_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINShort64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINShortVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3173,13 +3173,13 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, Short64VectorTests::MIN); + assertArraysEquals(r, a, (short)10, mask, ShortVector64Tests::MIN); } static ShortVector bv_MAX = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MAXShort64VectorTestsWithMemOp(IntFunction fa) { + static void MAXShortVector64TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3190,13 +3190,13 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short64VectorTests::MAX); + assertArraysEquals(r, a, (short)10, ShortVector64Tests::MAX); } static ShortVector bv_max = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void maxShort64VectorTestsWithMemOp(IntFunction fa) { + static void maxShortVector64TestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3207,13 +3207,13 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, Short64VectorTests::max); + assertArraysEquals(r, a, (short)10, ShortVector64Tests::max); } static ShortVector bv_MAX_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXShort64VectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXShortVector64TestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3226,7 +3226,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, Short64VectorTests::MAX); + assertArraysEquals(r, a, (short)10, mask, ShortVector64Tests::MAX); } static short MIN(short a, short b) { @@ -3234,7 +3234,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShort64VectorTests(IntFunction fa, IntFunction fb) { + static void MINShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3247,7 +3247,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::MIN); + assertArraysEquals(r, a, b, ShortVector64Tests::MIN); } static short min(short a, short b) { @@ -3255,7 +3255,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void minShort64VectorTests(IntFunction fa, IntFunction fb) { + static void minShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3266,7 +3266,7 @@ public class Short64VectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short64VectorTests::min); + assertArraysEquals(r, a, b, ShortVector64Tests::min); } static short MAX(short a, short b) { @@ -3274,7 +3274,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShort64VectorTests(IntFunction fa, IntFunction fb) { + static void MAXShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3287,7 +3287,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::MAX); + assertArraysEquals(r, a, b, ShortVector64Tests::MAX); } static short max(short a, short b) { @@ -3295,7 +3295,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShort64VectorTests(IntFunction fa, IntFunction fb) { + static void maxShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3306,7 +3306,7 @@ public class Short64VectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, Short64VectorTests::max); + assertArraysEquals(r, a, b, ShortVector64Tests::max); } static short UMIN(short a, short b) { @@ -3314,7 +3314,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMINShort64VectorTests(IntFunction fa, IntFunction fb) { + static void UMINShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3327,11 +3327,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::UMIN); + assertArraysEquals(r, a, b, ShortVector64Tests::UMIN); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMINShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3347,7 +3347,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::UMIN); } static short UMAX(short a, short b) { @@ -3355,7 +3355,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMAXShort64VectorTests(IntFunction fa, IntFunction fb) { + static void UMAXShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3368,11 +3368,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::UMAX); + assertArraysEquals(r, a, b, ShortVector64Tests::UMAX); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMAXShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3388,7 +3388,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::UMAX); } static short SADD(short a, short b) { @@ -3396,7 +3396,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SADDShort64VectorTests(IntFunction fa, IntFunction fb) { + static void SADDShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3409,11 +3409,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::SADD); + assertArraysEquals(r, a, b, ShortVector64Tests::SADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SADDShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3429,7 +3429,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::SADD); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::SADD); } static short SSUB(short a, short b) { @@ -3437,7 +3437,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SSUBShort64VectorTests(IntFunction fa, IntFunction fb) { + static void SSUBShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3450,11 +3450,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::SSUB); + assertArraysEquals(r, a, b, ShortVector64Tests::SSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SSUBShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3470,7 +3470,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::SSUB); } static short SUADD(short a, short b) { @@ -3478,7 +3478,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUADDShort64VectorTests(IntFunction fa, IntFunction fb) { + static void SUADDShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3491,11 +3491,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::SUADD); + assertArraysEquals(r, a, b, ShortVector64Tests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUADDShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3511,7 +3511,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::SUADD); } static short SUSUB(short a, short b) { @@ -3519,7 +3519,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUSUBShort64VectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3532,11 +3532,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::SUSUB); + assertArraysEquals(r, a, b, ShortVector64Tests::SUSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUSUBShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3552,11 +3552,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::SUSUB); } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3566,11 +3566,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::MIN); } @Test(dataProvider = "shortBinaryOpProvider") - static void minShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3580,11 +3580,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::min); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::min); } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3594,11 +3594,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::MAX); } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3608,10 +3608,10 @@ public class Short64VectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, Short64VectorTests::max); + assertBroadcastArraysEquals(r, a, b, ShortVector64Tests::max); } @Test(dataProvider = "shortSaturatingBinaryOpAssocProvider") - static void SUADDAssocShort64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocShortVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -3628,11 +3628,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, Short64VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ShortVector64Tests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3653,7 +3653,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Short64VectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ShortVector64Tests::SUADD); } static short ANDReduce(short[] a, int idx) { @@ -3675,7 +3675,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ANDReduceShort64VectorTests(IntFunction fa) { + static void ANDReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3691,7 +3691,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::ANDReduce, Short64VectorTests::ANDReduceAll); + ShortVector64Tests::ANDReduce, ShortVector64Tests::ANDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3737,7 +3737,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ANDReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3755,7 +3755,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::ANDReduceMasked, Short64VectorTests::ANDReduceAllMasked); + ShortVector64Tests::ANDReduceMasked, ShortVector64Tests::ANDReduceAllMasked); } static short ORReduce(short[] a, int idx) { @@ -3777,7 +3777,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ORReduceShort64VectorTests(IntFunction fa) { + static void ORReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3793,7 +3793,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::ORReduce, Short64VectorTests::ORReduceAll); + ShortVector64Tests::ORReduce, ShortVector64Tests::ORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3839,7 +3839,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ORReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3857,7 +3857,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::ORReduceMasked, Short64VectorTests::ORReduceAllMasked); + ShortVector64Tests::ORReduceMasked, ShortVector64Tests::ORReduceAllMasked); } static short XORReduce(short[] a, int idx) { @@ -3879,7 +3879,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void XORReduceShort64VectorTests(IntFunction fa) { + static void XORReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3895,7 +3895,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::XORReduce, Short64VectorTests::XORReduceAll); + ShortVector64Tests::XORReduce, ShortVector64Tests::XORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3941,7 +3941,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void XORReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3959,7 +3959,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::XORReduceMasked, Short64VectorTests::XORReduceAllMasked); + ShortVector64Tests::XORReduceMasked, ShortVector64Tests::XORReduceAllMasked); } static short ADDReduce(short[] a, int idx) { @@ -3981,7 +3981,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceShort64VectorTests(IntFunction fa) { + static void ADDReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3997,7 +3997,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::ADDReduce, Short64VectorTests::ADDReduceAll); + ShortVector64Tests::ADDReduce, ShortVector64Tests::ADDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4043,7 +4043,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4061,7 +4061,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::ADDReduceMasked, Short64VectorTests::ADDReduceAllMasked); + ShortVector64Tests::ADDReduceMasked, ShortVector64Tests::ADDReduceAllMasked); } static short MULReduce(short[] a, int idx) { @@ -4083,7 +4083,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MULReduceShort64VectorTests(IntFunction fa) { + static void MULReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4099,7 +4099,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::MULReduce, Short64VectorTests::MULReduceAll); + ShortVector64Tests::MULReduce, ShortVector64Tests::MULReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4145,7 +4145,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MULReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4163,7 +4163,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::MULReduceMasked, Short64VectorTests::MULReduceAllMasked); + ShortVector64Tests::MULReduceMasked, ShortVector64Tests::MULReduceAllMasked); } static short MINReduce(short[] a, int idx) { @@ -4185,7 +4185,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MINReduceShort64VectorTests(IntFunction fa) { + static void MINReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4201,7 +4201,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::MINReduce, Short64VectorTests::MINReduceAll); + ShortVector64Tests::MINReduce, ShortVector64Tests::MINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4247,7 +4247,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4265,7 +4265,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::MINReduceMasked, Short64VectorTests::MINReduceAllMasked); + ShortVector64Tests::MINReduceMasked, ShortVector64Tests::MINReduceAllMasked); } static short MAXReduce(short[] a, int idx) { @@ -4287,7 +4287,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MAXReduceShort64VectorTests(IntFunction fa) { + static void MAXReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4303,7 +4303,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::MAXReduce, Short64VectorTests::MAXReduceAll); + ShortVector64Tests::MAXReduce, ShortVector64Tests::MAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4349,7 +4349,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4367,7 +4367,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::MAXReduceMasked, Short64VectorTests::MAXReduceAllMasked); + ShortVector64Tests::MAXReduceMasked, ShortVector64Tests::MAXReduceAllMasked); } static short UMINReduce(short[] a, int idx) { @@ -4389,7 +4389,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMINReduceShort64VectorTests(IntFunction fa) { + static void UMINReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4405,7 +4405,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::UMINReduce, Short64VectorTests::UMINReduceAll); + ShortVector64Tests::UMINReduce, ShortVector64Tests::UMINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4451,7 +4451,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMINReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4469,7 +4469,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::UMINReduceMasked, Short64VectorTests::UMINReduceAllMasked); + ShortVector64Tests::UMINReduceMasked, ShortVector64Tests::UMINReduceAllMasked); } static short UMAXReduce(short[] a, int idx) { @@ -4491,7 +4491,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMAXReduceShort64VectorTests(IntFunction fa) { + static void UMAXReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4507,7 +4507,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::UMAXReduce, Short64VectorTests::UMAXReduceAll); + ShortVector64Tests::UMAXReduce, ShortVector64Tests::UMAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4553,7 +4553,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMAXReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4571,7 +4571,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::UMAXReduceMasked, Short64VectorTests::UMAXReduceAllMasked); + ShortVector64Tests::UMAXReduceMasked, ShortVector64Tests::UMAXReduceAllMasked); } static short FIRST_NONZEROReduce(short[] a, int idx) { @@ -4593,7 +4593,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void FIRST_NONZEROReduceShort64VectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4609,7 +4609,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::FIRST_NONZEROReduce, Short64VectorTests::FIRST_NONZEROReduceAll); + ShortVector64Tests::FIRST_NONZEROReduce, ShortVector64Tests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4655,7 +4655,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void FIRST_NONZEROReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4673,7 +4673,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::FIRST_NONZEROReduceMasked, Short64VectorTests::FIRST_NONZEROReduceAllMasked); + ShortVector64Tests::FIRST_NONZEROReduceMasked, ShortVector64Tests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4686,7 +4686,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueShort64VectorTests(IntFunction fm) { + static void anyTrueShortVector64Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4697,7 +4697,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Short64VectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ShortVector64Tests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4710,7 +4710,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueShort64VectorTests(IntFunction fm) { + static void allTrueShortVector64Tests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4721,7 +4721,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, Short64VectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ShortVector64Tests::allTrue); } static short SUADDReduce(short[] a, int idx) { @@ -4743,7 +4743,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingUnaryOpProvider") - static void SUADDReduceShort64VectorTests(IntFunction fa) { + static void SUADDReduceShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4759,7 +4759,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - Short64VectorTests::SUADDReduce, Short64VectorTests::SUADDReduceAll); + ShortVector64Tests::SUADDReduce, ShortVector64Tests::SUADDReduceAll); } @Test(dataProvider = "shortSaturatingUnaryOpProvider") @@ -4804,7 +4804,7 @@ public class Short64VectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "shortSaturatingUnaryOpMaskProvider") - static void SUADDReduceShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4822,11 +4822,11 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::SUADDReduceMasked, Short64VectorTests::SUADDReduceAllMasked); + ShortVector64Tests::SUADDReduceMasked, ShortVector64Tests::SUADDReduceAllMasked); } @Test(dataProvider = "shortBinaryOpProvider") - static void withShort64VectorTests(IntFunction fa, IntFunction fb) { + static void withShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -4849,7 +4849,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_DEFAULTShort64VectorTests(IntFunction fa) { + static void IS_DEFAULTShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4866,7 +4866,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_DEFAULTMaskedShort64VectorTests(IntFunction fa, + static void IS_DEFAULTMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4890,7 +4890,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_NEGATIVEShort64VectorTests(IntFunction fa) { + static void IS_NEGATIVEShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4907,7 +4907,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_NEGATIVEMaskedShort64VectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4927,7 +4927,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort64VectorTests(IntFunction fa, IntFunction fb) { + static void LTShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4946,7 +4946,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShort64VectorTests(IntFunction fa, IntFunction fb) { + static void ltShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4965,7 +4965,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4988,7 +4988,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GTShort64VectorTests(IntFunction fa, IntFunction fb) { + static void GTShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5007,7 +5007,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GTShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5030,7 +5030,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort64VectorTests(IntFunction fa, IntFunction fb) { + static void EQShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5049,7 +5049,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShort64VectorTests(IntFunction fa, IntFunction fb) { + static void eqShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5068,7 +5068,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5091,7 +5091,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void NEShort64VectorTests(IntFunction fa, IntFunction fb) { + static void NEShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5110,7 +5110,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void NEShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5133,7 +5133,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LEShort64VectorTests(IntFunction fa, IntFunction fb) { + static void LEShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5152,7 +5152,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LEShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5175,7 +5175,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GEShort64VectorTests(IntFunction fa, IntFunction fb) { + static void GEShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5194,7 +5194,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GEShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5217,7 +5217,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULTShort64VectorTests(IntFunction fa, IntFunction fb) { + static void ULTShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5236,7 +5236,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULTShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5259,7 +5259,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGTShort64VectorTests(IntFunction fa, IntFunction fb) { + static void UGTShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5278,7 +5278,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGTShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5301,7 +5301,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULEShort64VectorTests(IntFunction fa, IntFunction fb) { + static void ULEShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5320,7 +5320,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULEShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5343,7 +5343,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGEShort64VectorTests(IntFunction fa, IntFunction fb) { + static void UGEShortVector64Tests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5362,7 +5362,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGEShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5385,7 +5385,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5401,7 +5401,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5421,7 +5421,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShort64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5437,7 +5437,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShort64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTShortVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5457,7 +5457,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5473,7 +5473,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5493,7 +5493,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShort64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5509,7 +5509,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShort64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQShortVector64TestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5533,7 +5533,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShort64VectorTests(IntFunction fa, IntFunction fb, + static void blendShortVector64Tests(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5549,11 +5549,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, Short64VectorTests::blend); + assertArraysEquals(r, a, b, mask, ShortVector64Tests::blend); } @Test(dataProvider = "shortUnaryOpShuffleProvider") - static void RearrangeShort64VectorTests(IntFunction fa, + static void RearrangeShortVector64Tests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5570,7 +5570,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpShuffleMaskProvider") - static void RearrangeShort64VectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeShortVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -5588,7 +5588,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void compressShort64VectorTests(IntFunction fa, + static void compressShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5606,7 +5606,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void expandShort64VectorTests(IntFunction fa, + static void expandShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5624,7 +5624,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void getShort64VectorTests(IntFunction fa) { + static void getShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5780,7 +5780,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastShort64VectorTests(IntFunction fa) { + static void BroadcastShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5794,7 +5794,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZeroShort64VectorTests(IntFunction fa) { + static void ZeroShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5819,7 +5819,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void sliceUnaryShort64VectorTests(IntFunction fa) { + static void sliceUnaryShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5830,7 +5830,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Short64VectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ShortVector64Tests::sliceUnary); } static short[] sliceBinary(short[] a, short[] b, int origin, int idx) { @@ -5847,7 +5847,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void sliceBinaryShort64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryShortVector64TestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5860,7 +5860,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, Short64VectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ShortVector64Tests::sliceBinary); } static short[] slice(short[] a, short[] b, int origin, boolean[] mask, int idx) { @@ -5877,7 +5877,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void sliceShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5894,7 +5894,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, Short64VectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ShortVector64Tests::slice); } static short[] unsliceUnary(short[] a, int origin, int idx) { @@ -5911,7 +5911,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void unsliceUnaryShort64VectorTests(IntFunction fa) { + static void unsliceUnaryShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5922,7 +5922,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, Short64VectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ShortVector64Tests::unsliceUnary); } static short[] unsliceBinary(short[] a, short[] b, int origin, int part, int idx) { @@ -5948,7 +5948,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void unsliceBinaryShort64VectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryShortVector64TestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5962,7 +5962,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, Short64VectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ShortVector64Tests::unsliceBinary); } static short[] unslice(short[] a, short[] b, int origin, int part, boolean[] mask, int idx) { @@ -6002,7 +6002,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void unsliceShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6019,7 +6019,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, Short64VectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ShortVector64Tests::unslice); } static short BITWISE_BLEND(short a, short b, short c) { @@ -6031,7 +6031,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6046,11 +6046,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, Short64VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ShortVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6063,11 +6063,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, Short64VectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ShortVector64Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort64VectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector64TestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6085,11 +6085,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, Short64VectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ShortVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6100,11 +6100,11 @@ public class Short64VectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Short64VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ShortVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6115,11 +6115,11 @@ public class Short64VectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Short64VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6130,11 +6130,11 @@ public class Short64VectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, Short64VectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ShortVector64Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort64VectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector64TestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6145,11 +6145,11 @@ public class Short64VectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, Short64VectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVector64Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6164,11 +6164,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, Short64VectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ShortVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort64VectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector64TestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6183,11 +6183,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, Short64VectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ShortVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShort64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6198,11 +6198,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Short64VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVector64Tests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShort64VectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVector64TestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6213,11 +6213,11 @@ public class Short64VectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, Short64VectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVector64Tests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShort64VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVector64TestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6231,7 +6231,7 @@ public class Short64VectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Short64VectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ShortVector64Tests::BITWISE_BLEND); } static short NEG(short a) { @@ -6243,7 +6243,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NEGShort64VectorTests(IntFunction fa) { + static void NEGShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6254,11 +6254,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::NEG); + assertArraysEquals(r, a, ShortVector64Tests::NEG); } @Test(dataProvider = "shortUnaryOpProvider") - static void negShort64VectorTests(IntFunction fa) { + static void negShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6269,11 +6269,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::neg); + assertArraysEquals(r, a, ShortVector64Tests::neg); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NEGMaskedShort64VectorTests(IntFunction fa, + static void NEGMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6287,7 +6287,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::NEG); + assertArraysEquals(r, a, mask, ShortVector64Tests::NEG); } static short ABS(short a) { @@ -6299,7 +6299,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ABSShort64VectorTests(IntFunction fa) { + static void ABSShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6310,11 +6310,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::ABS); + assertArraysEquals(r, a, ShortVector64Tests::ABS); } @Test(dataProvider = "shortUnaryOpProvider") - static void absShort64VectorTests(IntFunction fa) { + static void absShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6325,11 +6325,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::abs); + assertArraysEquals(r, a, ShortVector64Tests::abs); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ABSMaskedShort64VectorTests(IntFunction fa, + static void ABSMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6343,7 +6343,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::ABS); + assertArraysEquals(r, a, mask, ShortVector64Tests::ABS); } static short NOT(short a) { @@ -6355,7 +6355,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NOTShort64VectorTests(IntFunction fa) { + static void NOTShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6366,11 +6366,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::NOT); + assertArraysEquals(r, a, ShortVector64Tests::NOT); } @Test(dataProvider = "shortUnaryOpProvider") - static void notShort64VectorTests(IntFunction fa) { + static void notShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6381,11 +6381,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::not); + assertArraysEquals(r, a, ShortVector64Tests::not); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NOTMaskedShort64VectorTests(IntFunction fa, + static void NOTMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6399,7 +6399,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::NOT); + assertArraysEquals(r, a, mask, ShortVector64Tests::NOT); } static short ZOMO(short a) { @@ -6407,7 +6407,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZOMOShort64VectorTests(IntFunction fa) { + static void ZOMOShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6418,11 +6418,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::ZOMO); + assertArraysEquals(r, a, ShortVector64Tests::ZOMO); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ZOMOMaskedShort64VectorTests(IntFunction fa, + static void ZOMOMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6436,7 +6436,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::ZOMO); + assertArraysEquals(r, a, mask, ShortVector64Tests::ZOMO); } static short BIT_COUNT(short a) { @@ -6444,7 +6444,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BIT_COUNTShort64VectorTests(IntFunction fa) { + static void BIT_COUNTShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6455,11 +6455,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::BIT_COUNT); + assertArraysEquals(r, a, ShortVector64Tests::BIT_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void BIT_COUNTMaskedShort64VectorTests(IntFunction fa, + static void BIT_COUNTMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6473,7 +6473,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ShortVector64Tests::BIT_COUNT); } static short TRAILING_ZEROS_COUNT(short a) { @@ -6481,7 +6481,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void TRAILING_ZEROS_COUNTShort64VectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6492,11 +6492,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVector64Tests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedShort64VectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6510,7 +6510,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVector64Tests::TRAILING_ZEROS_COUNT); } static short LEADING_ZEROS_COUNT(short a) { @@ -6518,7 +6518,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LEADING_ZEROS_COUNTShort64VectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6529,11 +6529,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVector64Tests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedShort64VectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6547,7 +6547,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVector64Tests::LEADING_ZEROS_COUNT); } static short REVERSE(short a) { @@ -6555,7 +6555,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSEShort64VectorTests(IntFunction fa) { + static void REVERSEShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6566,11 +6566,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::REVERSE); + assertArraysEquals(r, a, ShortVector64Tests::REVERSE); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSEMaskedShort64VectorTests(IntFunction fa, + static void REVERSEMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6584,7 +6584,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::REVERSE); + assertArraysEquals(r, a, mask, ShortVector64Tests::REVERSE); } static short REVERSE_BYTES(short a) { @@ -6592,7 +6592,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSE_BYTESShort64VectorTests(IntFunction fa) { + static void REVERSE_BYTESShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6603,11 +6603,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ShortVector64Tests::REVERSE_BYTES); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedShort64VectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedShortVector64Tests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6621,7 +6621,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, Short64VectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ShortVector64Tests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6629,7 +6629,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandShort64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandShortVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6642,7 +6642,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::band); + assertArraysEquals(r, a, b, ShortVector64Tests::band); } static boolean bor(boolean a, boolean b) { @@ -6650,7 +6650,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorShort64VectorTests(IntFunction fa, IntFunction fb) { + static void maskorShortVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6663,7 +6663,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::bor); + assertArraysEquals(r, a, b, ShortVector64Tests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6671,7 +6671,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorShort64VectorTests(IntFunction fa, IntFunction fb) { + static void maskxorShortVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6684,7 +6684,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::bxor); + assertArraysEquals(r, a, b, ShortVector64Tests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6692,7 +6692,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotShort64VectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotShortVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6705,7 +6705,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::bandNot); + assertArraysEquals(r, a, b, ShortVector64Tests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6713,7 +6713,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqShort64VectorTests(IntFunction fa, IntFunction fb) { + static void maskeqShortVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6726,7 +6726,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, Short64VectorTests::beq); + assertArraysEquals(r, a, b, ShortVector64Tests::beq); } static boolean unot(boolean a) { @@ -6734,7 +6734,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotShort64VectorTests(IntFunction fa) { + static void masknotShortVector64Tests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6745,7 +6745,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, Short64VectorTests::unot); + assertArraysEquals(r, a, ShortVector64Tests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6762,7 +6762,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongShort64VectorTests(IntFunction fa) { + static void maskFromToLongShortVector64Tests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6776,7 +6776,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShort64VectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltShortVector64TestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6792,7 +6792,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShort64VectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqShortVector64TestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6808,7 +6808,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toIntArrayShort64VectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayShortVector64TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6819,7 +6819,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toLongArrayShort64VectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayShortVector64TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6830,7 +6830,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toDoubleArrayShort64VectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayShortVector64TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6841,7 +6841,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toStringShort64VectorTestsSmokeTest(IntFunction fa) { + static void toStringShortVector64TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6854,7 +6854,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void hashCodeShort64VectorTestsSmokeTest(IntFunction fa) { + static void hashCodeShortVector64TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6887,7 +6887,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceLongShort64VectorTests(IntFunction fa) { + static void ADDReduceLongShortVector64Tests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6903,7 +6903,7 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - Short64VectorTests::ADDReduceLong, Short64VectorTests::ADDReduceAllLong); + ShortVector64Tests::ADDReduceLong, ShortVector64Tests::ADDReduceAllLong); } static long ADDReduceLongMasked(short[] a, int idx, boolean[] mask) { @@ -6926,7 +6926,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceLongShort64VectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongShortVector64TestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6944,11 +6944,11 @@ public class Short64VectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - Short64VectorTests::ADDReduceLongMasked, Short64VectorTests::ADDReduceAllLongMasked); + ShortVector64Tests::ADDReduceLongMasked, ShortVector64Tests::ADDReduceAllLongMasked); } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastLongShort64VectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongShortVector64TestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -6959,7 +6959,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShort64VectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendShortVector64TestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6973,12 +6973,12 @@ public class Short64VectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, Short64VectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVector64Tests::blend); } @Test(dataProvider = "shortUnaryOpSelectFromProvider") - static void SelectFromShort64VectorTests(IntFunction fa, + static void SelectFromShortVector64Tests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); short[] order = fs.apply(a.length, SPECIES.length()); @@ -6994,7 +6994,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorShort64VectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorShortVector64Tests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] idx = fc.apply(SPECIES.length()); @@ -7012,7 +7012,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpSelectFromMaskProvider") - static void SelectFromShort64VectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromShortVector64TestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -7031,7 +7031,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousShort64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousShortVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7047,7 +7047,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringShort64VectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringShortVector64TestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7061,7 +7061,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsShort64VectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsShortVector64TestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7075,7 +7075,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsShort64VectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsShortVector64Tests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7091,7 +7091,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeShort64VectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeShortVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7113,7 +7113,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountShort64VectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountShortVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7124,7 +7124,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short64VectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ShortVector64Tests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7138,7 +7138,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueShort64VectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueShortVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7149,7 +7149,7 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short64VectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ShortVector64Tests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7163,7 +7163,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueShort64VectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueShortVector64TestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7174,11 +7174,11 @@ public class Short64VectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, Short64VectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ShortVector64Tests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressShort64VectorTestsSmokeTest(IntFunction fa) { + static void maskCompressShortVector64TestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7206,7 +7206,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeShort64VectorTestsSmokeTest(int offset) { + static void indexInRangeShortVector64TestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7220,7 +7220,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongShort64VectorTestsSmokeTest(int offset) { + static void indexInRangeLongShortVector64TestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7247,14 +7247,14 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundShort64VectorTestsSmokeTest(int length) { + static void loopBoundShortVector64TestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongShort64VectorTestsSmokeTest(int _length) { + static void loopBoundLongShortVector64TestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7262,21 +7262,21 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test - static void ElementSizeShort64VectorTestsSmokeTest() { + static void ElementSizeShortVector64TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Short.SIZE); } @Test - static void VectorShapeShort64VectorTestsSmokeTest() { + static void VectorShapeShortVector64TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_64_BIT)); } @Test - static void ShapeWithLanesShort64VectorTestsSmokeTest() { + static void ShapeWithLanesShortVector64TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(short.class); @@ -7284,32 +7284,32 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test - static void ElementTypeShort64VectorTestsSmokeTest() { + static void ElementTypeShortVector64TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementType() == short.class); } @Test - static void SpeciesElementSizeShort64VectorTestsSmokeTest() { + static void SpeciesElementSizeShortVector64TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementSize() == Short.SIZE); } @Test - static void VectorTypeShort64VectorTestsSmokeTest() { + static void VectorTypeShortVector64TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesShort64VectorTestsSmokeTest() { + static void WithLanesShortVector64TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(short.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeShort64VectorTestsSmokeTest() { + static void WithShapeShortVector64TestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7317,7 +7317,7 @@ public class Short64VectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueShort64VectorTestsSmokeTest() { + static void MaskAllTrueShortVector64TestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/ShortMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ShortVectorMaxLoadStoreTests.java similarity index 99% rename from test/jdk/jdk/incubator/vector/ShortMaxVectorLoadStoreTests.java rename to test/jdk/jdk/incubator/vector/ShortVectorMaxLoadStoreTests.java index ebed7dd0226..24683f1e5d7 100644 --- a/test/jdk/jdk/incubator/vector/ShortMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVectorMaxLoadStoreTests.java @@ -28,7 +28,7 @@ * @library /test/lib * @modules jdk.incubator.vector java.base/jdk.internal.vm.annotation * @run testng/othervm --add-opens jdk.incubator.vector/jdk.incubator.vector=ALL-UNNAMED - * -XX:-TieredCompilation ShortMaxVectorLoadStoreTests + * -XX:-TieredCompilation ShortVectorMaxLoadStoreTests * */ @@ -52,7 +52,7 @@ import java.util.List; import java.util.function.*; @Test -public class ShortMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { +public class ShortVectorMaxLoadStoreTests extends AbstractVectorLoadStoreTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_MAX; diff --git a/test/jdk/jdk/incubator/vector/ShortMaxVectorTests.java b/test/jdk/jdk/incubator/vector/ShortVectorMaxTests.java similarity index 90% rename from test/jdk/jdk/incubator/vector/ShortMaxVectorTests.java rename to test/jdk/jdk/incubator/vector/ShortVectorMaxTests.java index f71cf3ca322..65234fb3173 100644 --- a/test/jdk/jdk/incubator/vector/ShortMaxVectorTests.java +++ b/test/jdk/jdk/incubator/vector/ShortVectorMaxTests.java @@ -27,7 +27,7 @@ * * @library /test/lib * @modules jdk.incubator.vector - * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ShortMaxVectorTests + * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation ShortVectorMaxTests */ // -- This file was mechanically generated: Do not edit! -- // @@ -56,7 +56,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @Test -public class ShortMaxVectorTests extends AbstractVectorTest { +public class ShortVectorMaxTests extends AbstractVectorTest { static final VectorSpecies SPECIES = ShortVector.SPECIES_MAX; @@ -1702,7 +1702,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ADDShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1715,7 +1715,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::ADD); + assertArraysEquals(r, a, b, ShortVectorMaxTests::ADD); } static short add(short a, short b) { @@ -1723,7 +1723,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void addShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void addShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1734,11 +1734,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.add(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ShortMaxVectorTests::add); + assertArraysEquals(r, a, b, ShortVectorMaxTests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ADDShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1754,11 +1754,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ADD); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void addShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1772,7 +1772,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.add(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::add); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::add); } static short SUB(short a, short b) { @@ -1780,7 +1780,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void SUBShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUBShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1793,7 +1793,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::SUB); + assertArraysEquals(r, a, b, ShortVectorMaxTests::SUB); } static short sub(short a, short b) { @@ -1801,7 +1801,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void subShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void subShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1812,11 +1812,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.sub(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ShortMaxVectorTests::sub); + assertArraysEquals(r, a, b, ShortVectorMaxTests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void SUBShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUBShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1832,11 +1832,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::SUB); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::SUB); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void subShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1850,7 +1850,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.sub(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::sub); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::sub); } static short MUL(short a, short b) { @@ -1858,7 +1858,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MULShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MULShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1871,7 +1871,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::MUL); + assertArraysEquals(r, a, b, ShortVectorMaxTests::MUL); } static short mul(short a, short b) { @@ -1879,7 +1879,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void mulShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1890,11 +1890,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.mul(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ShortMaxVectorTests::mul); + assertArraysEquals(r, a, b, ShortVectorMaxTests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void MULShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void MULShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1910,11 +1910,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::MUL); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::MUL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void mulShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1928,7 +1928,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.mul(bv, vmask).intoArray(r, i); } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::mul); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::mul); } static short DIV(short a, short b) { @@ -1936,7 +1936,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void DIVShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void DIVShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1951,7 +1951,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::DIV); + assertArraysEquals(r, a, b, ShortVectorMaxTests::DIV); } static short div(short a, short b) { @@ -1959,7 +1959,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void divShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void divShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -1974,11 +1974,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::div); + assertArraysEquals(r, a, b, ShortVectorMaxTests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void DIVShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void DIVShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -1996,11 +1996,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::DIV); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::DIV); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void divShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2018,7 +2018,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::div); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::div); } static short FIRST_NONZERO(short a, short b) { @@ -2026,7 +2026,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void FIRST_NONZEROShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void FIRST_NONZEROShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2039,11 +2039,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, ShortVectorMaxTests::FIRST_NONZERO); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void FIRST_NONZEROShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void FIRST_NONZEROShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2059,7 +2059,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::FIRST_NONZERO); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::FIRST_NONZERO); } static short AND(short a, short b) { @@ -2067,7 +2067,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ANDShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2080,7 +2080,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::AND); + assertArraysEquals(r, a, b, ShortVectorMaxTests::AND); } static short and(short a, short b) { @@ -2088,7 +2088,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void andShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void andShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2099,11 +2099,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.and(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ShortMaxVectorTests::and); + assertArraysEquals(r, a, b, ShortVectorMaxTests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ANDShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2119,7 +2119,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::AND); } static short AND_NOT(short a, short b) { @@ -2127,7 +2127,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void AND_NOTShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void AND_NOTShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2140,11 +2140,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::AND_NOT); + assertArraysEquals(r, a, b, ShortVectorMaxTests::AND_NOT); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void AND_NOTShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void AND_NOTShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2160,7 +2160,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND_NOT); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::AND_NOT); } static short OR(short a, short b) { @@ -2168,7 +2168,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ORShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2181,7 +2181,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::OR); + assertArraysEquals(r, a, b, ShortVectorMaxTests::OR); } static short or(short a, short b) { @@ -2189,7 +2189,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void orShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void orShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2200,11 +2200,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.or(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ShortMaxVectorTests::or); + assertArraysEquals(r, a, b, ShortVectorMaxTests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ORShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2220,7 +2220,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::OR); } static short XOR(short a, short b) { @@ -2228,7 +2228,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void XORShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void XORShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2241,11 +2241,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::XOR); + assertArraysEquals(r, a, b, ShortVectorMaxTests::XOR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void XORShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void XORShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2261,11 +2261,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::XOR); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::XOR); } @Test(dataProvider = "shortBinaryOpProvider") - static void addShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void addShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2275,11 +2275,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.add(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::add); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void addShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void addShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2292,11 +2292,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.add(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::add); + assertBroadcastArraysEquals(r, a, b, mask, ShortVectorMaxTests::add); } @Test(dataProvider = "shortBinaryOpProvider") - static void subShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void subShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2306,11 +2306,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.sub(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::sub); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void subShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void subShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2323,11 +2323,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.sub(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::sub); + assertBroadcastArraysEquals(r, a, b, mask, ShortVectorMaxTests::sub); } @Test(dataProvider = "shortBinaryOpProvider") - static void mulShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void mulShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2337,11 +2337,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.mul(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::mul); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void mulShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void mulShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2354,11 +2354,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.mul(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::mul); + assertBroadcastArraysEquals(r, a, b, mask, ShortVectorMaxTests::mul); } @Test(dataProvider = "shortBinaryOpProvider") - static void divShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void divShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2370,11 +2370,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.div(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::div); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void divShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void divShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2389,11 +2389,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.div(b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::div); + assertBroadcastArraysEquals(r, a, b, mask, ShortVectorMaxTests::div); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2403,11 +2403,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::OR); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void orShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void orShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2417,11 +2417,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.or(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::or); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::or); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2434,11 +2434,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR); + assertBroadcastArraysEquals(r, a, b, mask, ShortVectorMaxTests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ANDShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ANDShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2448,11 +2448,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::AND); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void andShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void andShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2462,11 +2462,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.and(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::and); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::and); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ANDShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void ANDShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2479,11 +2479,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND); + assertBroadcastArraysEquals(r, a, b, mask, ShortVectorMaxTests::AND); } @Test(dataProvider = "shortBinaryOpProvider") - static void ORShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ORShortVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2493,11 +2493,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, ShortMaxVectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, ShortVectorMaxTests::OR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ORShortMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ORShortVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2510,11 +2510,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVectorMaxTests::OR); } @Test(dataProvider = "shortBinaryOpProvider") - static void ADDShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void ADDShortVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2524,11 +2524,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, ShortMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, ShortVectorMaxTests::ADD); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ADDShortMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, + static void ADDShortVectorMaxTestsBroadcastMaskedLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2541,7 +2541,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i); } - assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::ADD); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVectorMaxTests::ADD); } static short LSHL(short a, short b) { @@ -2549,7 +2549,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LSHLShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2562,11 +2562,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::LSHL); + assertArraysEquals(r, a, b, ShortVectorMaxTests::LSHL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2582,7 +2582,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHL); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::LSHL); } static short ASHR(short a, short b) { @@ -2590,7 +2590,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ASHRShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2603,11 +2603,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::ASHR); + assertArraysEquals(r, a, b, ShortVectorMaxTests::ASHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2623,7 +2623,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ASHR); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::ASHR); } static short LSHR(short a, short b) { @@ -2631,7 +2631,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LSHRShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2644,11 +2644,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::LSHR); + assertArraysEquals(r, a, b, ShortVectorMaxTests::LSHR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2664,7 +2664,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHR); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::LSHR); } static short LSHL_unary(short a, short b) { @@ -2672,7 +2672,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHLShortMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHLShortVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2684,11 +2684,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, ShortVectorMaxTests::LSHL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHLShortMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHLShortVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2703,7 +2703,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVectorMaxTests::LSHL_unary); } static short LSHR_unary(short a, short b) { @@ -2711,7 +2711,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void LSHRShortMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void LSHRShortVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2723,11 +2723,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, ShortVectorMaxTests::LSHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void LSHRShortMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void LSHRShortVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2742,7 +2742,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVectorMaxTests::LSHR_unary); } static short ASHR_unary(short a, short b) { @@ -2750,7 +2750,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ASHRShortMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ASHRShortVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2762,11 +2762,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, ShortVectorMaxTests::ASHR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ASHRShortMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ASHRShortVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2781,7 +2781,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ASHR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVectorMaxTests::ASHR_unary); } static short ROR(short a, short b) { @@ -2789,7 +2789,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void RORShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2802,11 +2802,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::ROR); + assertArraysEquals(r, a, b, ShortVectorMaxTests::ROR); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void RORShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2822,7 +2822,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROR); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::ROR); } static short ROL(short a, short b) { @@ -2830,7 +2830,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ROLShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2843,11 +2843,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::ROL); + assertArraysEquals(r, a, b, ShortVectorMaxTests::ROL); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ROLShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2863,7 +2863,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROL); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::ROL); } static short ROR_unary(short a, short b) { @@ -2871,7 +2871,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void RORShortMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void RORShortVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2883,11 +2883,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, ShortVectorMaxTests::ROR_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void RORShortMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void RORShortVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2902,7 +2902,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROR_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVectorMaxTests::ROR_unary); } static short ROL_unary(short a, short b) { @@ -2910,7 +2910,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void ROLShortMaxVectorTestsScalarShift(IntFunction fa, IntFunction fb) { + static void ROLShortVectorMaxTestsScalarShift(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2922,11 +2922,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, ShortVectorMaxTests::ROL_unary); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void ROLShortMaxVectorTestsScalarShiftMasked(IntFunction fa, IntFunction fb, + static void ROLShortVectorMaxTestsScalarShiftMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -2941,14 +2941,14 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROL_unary); + assertShiftArraysEquals(r, a, b, mask, ShortVectorMaxTests::ROL_unary); } static short LSHR_binary_const(short a) { return (short)(((a & 0xFFFF) >>> CONST_SHIFT)); } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHRShortMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void LSHRShortVectorMaxTestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2959,11 +2959,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ShortMaxVectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, ShortVectorMaxTests::LSHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHRShortMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHRShortVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2977,7 +2977,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::LSHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVectorMaxTests::LSHR_binary_const); } static short LSHL_binary_const(short a) { @@ -2985,7 +2985,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LSHLShortMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void LSHLShortVectorMaxTestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -2996,11 +2996,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ShortMaxVectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, ShortVectorMaxTests::LSHL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LSHLShortMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void LSHLShortVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3014,7 +3014,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::LSHL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVectorMaxTests::LSHL_binary_const); } static short ASHR_binary_const(short a) { @@ -3022,7 +3022,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ASHRShortMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void ASHRShortVectorMaxTestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3033,11 +3033,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ShortMaxVectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, ShortVectorMaxTests::ASHR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ASHRShortMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ASHRShortVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3051,7 +3051,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ASHR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVectorMaxTests::ASHR_binary_const); } static short ROR_binary_const(short a) { @@ -3059,7 +3059,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void RORShortMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void RORShortVectorMaxTestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3070,11 +3070,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ShortMaxVectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, ShortVectorMaxTests::ROR_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void RORShortMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void RORShortVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3088,7 +3088,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ROR_binary_const); + assertShiftConstEquals(r, a, mask, ShortVectorMaxTests::ROR_binary_const); } static short ROL_binary_const(short a) { @@ -3096,7 +3096,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ROLShortMaxVectorTestsScalarShiftConst(IntFunction fa) { + static void ROLShortVectorMaxTestsScalarShiftConst(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3107,11 +3107,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, ShortMaxVectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, ShortVectorMaxTests::ROL_binary_const); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ROLShortMaxVectorTestsScalarShiftMaskedConst(IntFunction fa, + static void ROLShortVectorMaxTestsScalarShiftMaskedConst(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3125,14 +3125,14 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ROL_binary_const); + assertShiftConstEquals(r, a, mask, ShortVectorMaxTests::ROL_binary_const); } static ShortVector bv_MIN = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MINShortMaxVectorTestsWithMemOp(IntFunction fa) { + static void MINShortVectorMaxTestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3143,13 +3143,13 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, ShortMaxVectorTests::MIN); + assertArraysEquals(r, a, (short)10, ShortVectorMaxTests::MIN); } static ShortVector bv_min = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void minShortMaxVectorTestsWithMemOp(IntFunction fa) { + static void minShortVectorMaxTestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3160,13 +3160,13 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, ShortMaxVectorTests::min); + assertArraysEquals(r, a, (short)10, ShortVectorMaxTests::min); } static ShortVector bv_MIN_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINShortMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MINShortVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3179,13 +3179,13 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, ShortMaxVectorTests::MIN); + assertArraysEquals(r, a, (short)10, mask, ShortVectorMaxTests::MIN); } static ShortVector bv_MAX = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void MAXShortMaxVectorTestsWithMemOp(IntFunction fa) { + static void MAXShortVectorMaxTestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3196,13 +3196,13 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, ShortMaxVectorTests::MAX); + assertArraysEquals(r, a, (short)10, ShortVectorMaxTests::MAX); } static ShortVector bv_max = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpProvider") - static void maxShortMaxVectorTestsWithMemOp(IntFunction fa) { + static void maxShortVectorMaxTestsWithMemOp(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3213,13 +3213,13 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, ShortMaxVectorTests::max); + assertArraysEquals(r, a, (short)10, ShortVectorMaxTests::max); } static ShortVector bv_MAX_M = ShortVector.broadcast(SPECIES, (short)10); @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXShortMaxVectorTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { + static void MAXShortVectorMaxTestsMaskedWithMemOp(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3232,7 +3232,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, (short)10, mask, ShortMaxVectorTests::MAX); + assertArraysEquals(r, a, (short)10, mask, ShortVectorMaxTests::MAX); } static short MIN(short a, short b) { @@ -3240,7 +3240,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MINShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3253,7 +3253,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::MIN); + assertArraysEquals(r, a, b, ShortVectorMaxTests::MIN); } static short min(short a, short b) { @@ -3261,7 +3261,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void minShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void minShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3272,7 +3272,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.min(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ShortMaxVectorTests::min); + assertArraysEquals(r, a, b, ShortVectorMaxTests::min); } static short MAX(short a, short b) { @@ -3280,7 +3280,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void MAXShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3293,7 +3293,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::MAX); + assertArraysEquals(r, a, b, ShortVectorMaxTests::MAX); } static short max(short a, short b) { @@ -3301,7 +3301,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maxShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3312,7 +3312,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.max(bv).intoArray(r, i); } - assertArraysEquals(r, a, b, ShortMaxVectorTests::max); + assertArraysEquals(r, a, b, ShortVectorMaxTests::max); } static short UMIN(short a, short b) { @@ -3320,7 +3320,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMINShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UMINShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3333,11 +3333,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::UMIN); + assertArraysEquals(r, a, b, ShortVectorMaxTests::UMIN); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMINShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMINShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3353,7 +3353,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::UMIN); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::UMIN); } static short UMAX(short a, short b) { @@ -3361,7 +3361,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void UMAXShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UMAXShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3374,11 +3374,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::UMAX); + assertArraysEquals(r, a, b, ShortVectorMaxTests::UMAX); } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void UMAXShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UMAXShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3394,7 +3394,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::UMAX); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::UMAX); } static short SADD(short a, short b) { @@ -3402,7 +3402,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SADDShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SADDShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3415,11 +3415,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::SADD); + assertArraysEquals(r, a, b, ShortVectorMaxTests::SADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SADDShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SADDShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3435,7 +3435,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::SADD); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::SADD); } static short SSUB(short a, short b) { @@ -3443,7 +3443,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SSUBShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SSUBShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3456,11 +3456,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::SSUB); + assertArraysEquals(r, a, b, ShortVectorMaxTests::SSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SSUBShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SSUBShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3476,7 +3476,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::SSUB); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::SSUB); } static short SUADD(short a, short b) { @@ -3484,7 +3484,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUADDShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUADDShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3497,11 +3497,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::SUADD); + assertArraysEquals(r, a, b, ShortVectorMaxTests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUADDShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3517,7 +3517,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::SUADD); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::SUADD); } static short SUSUB(short a, short b) { @@ -3525,7 +3525,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingBinaryOpProvider") - static void SUSUBShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void SUSUBShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3538,11 +3538,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::SUSUB); + assertArraysEquals(r, a, b, ShortVectorMaxTests::SUSUB); } @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider") - static void SUSUBShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUSUBShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3558,11 +3558,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::SUSUB); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::SUSUB); } @Test(dataProvider = "shortBinaryOpProvider") - static void MINShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MINShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3572,11 +3572,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::MIN); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::MIN); } @Test(dataProvider = "shortBinaryOpProvider") - static void minShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void minShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3586,11 +3586,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.min(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::min); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::min); } @Test(dataProvider = "shortBinaryOpProvider") - static void MAXShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void MAXShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3600,11 +3600,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::MAX); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::MAX); } @Test(dataProvider = "shortBinaryOpProvider") - static void maxShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void maxShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -3614,10 +3614,10 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.max(b[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::max); + assertBroadcastArraysEquals(r, a, b, ShortVectorMaxTests::max); } @Test(dataProvider = "shortSaturatingBinaryOpAssocProvider") - static void SUADDAssocShortMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SUADDAssocShortVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -3634,11 +3634,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, ShortMaxVectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, ShortVectorMaxTests::SUADD); } @Test(dataProvider = "shortSaturatingBinaryOpAssocMaskProvider") - static void SUADDAssocShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void SUADDAssocShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -3659,7 +3659,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ShortMaxVectorTests::SUADD); + assertArraysEqualsAssociative(rl, rr, a, b, c, mask, ShortVectorMaxTests::SUADD); } static short ANDReduce(short[] a, int idx) { @@ -3681,7 +3681,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ANDReduceShortMaxVectorTests(IntFunction fa) { + static void ANDReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3697,7 +3697,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::ANDReduce, ShortMaxVectorTests::ANDReduceAll); + ShortVectorMaxTests::ANDReduce, ShortVectorMaxTests::ANDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3743,7 +3743,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ANDReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ANDReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3761,7 +3761,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::ANDReduceMasked, ShortMaxVectorTests::ANDReduceAllMasked); + ShortVectorMaxTests::ANDReduceMasked, ShortVectorMaxTests::ANDReduceAllMasked); } static short ORReduce(short[] a, int idx) { @@ -3783,7 +3783,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ORReduceShortMaxVectorTests(IntFunction fa) { + static void ORReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3799,7 +3799,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::ORReduce, ShortMaxVectorTests::ORReduceAll); + ShortVectorMaxTests::ORReduce, ShortVectorMaxTests::ORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3845,7 +3845,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ORReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ORReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3863,7 +3863,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::ORReduceMasked, ShortMaxVectorTests::ORReduceAllMasked); + ShortVectorMaxTests::ORReduceMasked, ShortVectorMaxTests::ORReduceAllMasked); } static short XORReduce(short[] a, int idx) { @@ -3885,7 +3885,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void XORReduceShortMaxVectorTests(IntFunction fa) { + static void XORReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -3901,7 +3901,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::XORReduce, ShortMaxVectorTests::XORReduceAll); + ShortVectorMaxTests::XORReduce, ShortVectorMaxTests::XORReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -3947,7 +3947,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void XORReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void XORReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -3965,7 +3965,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::XORReduceMasked, ShortMaxVectorTests::XORReduceAllMasked); + ShortVectorMaxTests::XORReduceMasked, ShortVectorMaxTests::XORReduceAllMasked); } static short ADDReduce(short[] a, int idx) { @@ -3987,7 +3987,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceShortMaxVectorTests(IntFunction fa) { + static void ADDReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4003,7 +4003,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::ADDReduce, ShortMaxVectorTests::ADDReduceAll); + ShortVectorMaxTests::ADDReduce, ShortVectorMaxTests::ADDReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4049,7 +4049,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4067,7 +4067,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::ADDReduceMasked, ShortMaxVectorTests::ADDReduceAllMasked); + ShortVectorMaxTests::ADDReduceMasked, ShortVectorMaxTests::ADDReduceAllMasked); } static short MULReduce(short[] a, int idx) { @@ -4089,7 +4089,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MULReduceShortMaxVectorTests(IntFunction fa) { + static void MULReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4105,7 +4105,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::MULReduce, ShortMaxVectorTests::MULReduceAll); + ShortVectorMaxTests::MULReduce, ShortVectorMaxTests::MULReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4151,7 +4151,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MULReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MULReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4169,7 +4169,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::MULReduceMasked, ShortMaxVectorTests::MULReduceAllMasked); + ShortVectorMaxTests::MULReduceMasked, ShortVectorMaxTests::MULReduceAllMasked); } static short MINReduce(short[] a, int idx) { @@ -4191,7 +4191,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MINReduceShortMaxVectorTests(IntFunction fa) { + static void MINReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4207,7 +4207,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::MINReduce, ShortMaxVectorTests::MINReduceAll); + ShortVectorMaxTests::MINReduce, ShortVectorMaxTests::MINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4253,7 +4253,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MINReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MINReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4271,7 +4271,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::MINReduceMasked, ShortMaxVectorTests::MINReduceAllMasked); + ShortVectorMaxTests::MINReduceMasked, ShortVectorMaxTests::MINReduceAllMasked); } static short MAXReduce(short[] a, int idx) { @@ -4293,7 +4293,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void MAXReduceShortMaxVectorTests(IntFunction fa) { + static void MAXReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4309,7 +4309,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::MAXReduce, ShortMaxVectorTests::MAXReduceAll); + ShortVectorMaxTests::MAXReduce, ShortVectorMaxTests::MAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4355,7 +4355,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void MAXReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void MAXReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4373,7 +4373,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::MAXReduceMasked, ShortMaxVectorTests::MAXReduceAllMasked); + ShortVectorMaxTests::MAXReduceMasked, ShortVectorMaxTests::MAXReduceAllMasked); } static short UMINReduce(short[] a, int idx) { @@ -4395,7 +4395,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMINReduceShortMaxVectorTests(IntFunction fa) { + static void UMINReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4411,7 +4411,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::UMINReduce, ShortMaxVectorTests::UMINReduceAll); + ShortVectorMaxTests::UMINReduce, ShortVectorMaxTests::UMINReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4457,7 +4457,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMINReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMINReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4475,7 +4475,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::UMINReduceMasked, ShortMaxVectorTests::UMINReduceAllMasked); + ShortVectorMaxTests::UMINReduceMasked, ShortVectorMaxTests::UMINReduceAllMasked); } static short UMAXReduce(short[] a, int idx) { @@ -4497,7 +4497,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void UMAXReduceShortMaxVectorTests(IntFunction fa) { + static void UMAXReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4513,7 +4513,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::UMAXReduce, ShortMaxVectorTests::UMAXReduceAll); + ShortVectorMaxTests::UMAXReduce, ShortVectorMaxTests::UMAXReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4559,7 +4559,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void UMAXReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void UMAXReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4577,7 +4577,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::UMAXReduceMasked, ShortMaxVectorTests::UMAXReduceAllMasked); + ShortVectorMaxTests::UMAXReduceMasked, ShortVectorMaxTests::UMAXReduceAllMasked); } static short FIRST_NONZEROReduce(short[] a, int idx) { @@ -4599,7 +4599,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void FIRST_NONZEROReduceShortMaxVectorTests(IntFunction fa) { + static void FIRST_NONZEROReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4615,7 +4615,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::FIRST_NONZEROReduce, ShortMaxVectorTests::FIRST_NONZEROReduceAll); + ShortVectorMaxTests::FIRST_NONZEROReduce, ShortVectorMaxTests::FIRST_NONZEROReduceAll); } @Test(dataProvider = "shortUnaryOpProvider") @@ -4661,7 +4661,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void FIRST_NONZEROReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void FIRST_NONZEROReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4679,7 +4679,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::FIRST_NONZEROReduceMasked, ShortMaxVectorTests::FIRST_NONZEROReduceAllMasked); + ShortVectorMaxTests::FIRST_NONZEROReduceMasked, ShortVectorMaxTests::FIRST_NONZEROReduceAllMasked); } static boolean anyTrue(boolean[] a, int idx) { @@ -4692,7 +4692,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void anyTrueShortMaxVectorTests(IntFunction fm) { + static void anyTrueShortVectorMaxTests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4703,7 +4703,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, ShortMaxVectorTests::anyTrue); + assertReductionBoolArraysEquals(r, mask, ShortVectorMaxTests::anyTrue); } static boolean allTrue(boolean[] a, int idx) { @@ -4716,7 +4716,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolUnaryOpProvider") - static void allTrueShortMaxVectorTests(IntFunction fm) { + static void allTrueShortVectorMaxTests(IntFunction fm) { boolean[] mask = fm.apply(SPECIES.length()); boolean[] r = fmr.apply(SPECIES.length()); @@ -4727,7 +4727,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertReductionBoolArraysEquals(r, mask, ShortMaxVectorTests::allTrue); + assertReductionBoolArraysEquals(r, mask, ShortVectorMaxTests::allTrue); } static short SUADDReduce(short[] a, int idx) { @@ -4749,7 +4749,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSaturatingUnaryOpProvider") - static void SUADDReduceShortMaxVectorTests(IntFunction fa) { + static void SUADDReduceShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); short ra = 0; @@ -4765,7 +4765,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEquals(r, ra, a, - ShortMaxVectorTests::SUADDReduce, ShortMaxVectorTests::SUADDReduceAll); + ShortVectorMaxTests::SUADDReduce, ShortVectorMaxTests::SUADDReduceAll); } @Test(dataProvider = "shortSaturatingUnaryOpProvider") @@ -4810,7 +4810,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { return res; } @Test(dataProvider = "shortSaturatingUnaryOpMaskProvider") - static void SUADDReduceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void SUADDReduceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4828,11 +4828,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::SUADDReduceMasked, ShortMaxVectorTests::SUADDReduceAllMasked); + ShortVectorMaxTests::SUADDReduceMasked, ShortVectorMaxTests::SUADDReduceAllMasked); } @Test(dataProvider = "shortBinaryOpProvider") - static void withShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void withShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -4855,7 +4855,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_DEFAULTShortMaxVectorTests(IntFunction fa) { + static void IS_DEFAULTShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4872,7 +4872,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_DEFAULTMaskedShortMaxVectorTests(IntFunction fa, + static void IS_DEFAULTMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4896,7 +4896,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpProvider") - static void IS_NEGATIVEShortMaxVectorTests(IntFunction fa) { + static void IS_NEGATIVEShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int ic = 0; ic < INVOC_COUNT; ic++) { @@ -4913,7 +4913,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTestOpMaskProvider") - static void IS_NEGATIVEMaskedShortMaxVectorTests(IntFunction fa, + static void IS_NEGATIVEMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -4933,7 +4933,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LTShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4952,7 +4952,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ltShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4971,7 +4971,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LTShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -4994,7 +4994,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GTShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GTShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5013,7 +5013,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GTShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GTShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5036,7 +5036,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void EQShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5055,7 +5055,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void eqShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5074,7 +5074,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void EQShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5097,7 +5097,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void NEShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void NEShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5116,7 +5116,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void NEShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void NEShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5139,7 +5139,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LEShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void LEShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5158,7 +5158,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LEShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void LEShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5181,7 +5181,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void GEShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void GEShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5200,7 +5200,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void GEShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void GEShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5223,7 +5223,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULTShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ULTShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5242,7 +5242,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULTShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULTShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5265,7 +5265,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGTShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UGTShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5284,7 +5284,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGTShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGTShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5307,7 +5307,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ULEShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void ULEShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5326,7 +5326,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void ULEShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void ULEShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5349,7 +5349,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void UGEShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void UGEShortVectorMaxTests(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5368,7 +5368,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void UGEShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void UGEShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5391,7 +5391,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5407,7 +5407,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void LTShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5427,7 +5427,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void LTShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void LTShortVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5443,7 +5443,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void LTShortMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void LTShortVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5463,7 +5463,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5479,7 +5479,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, + static void EQShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5499,7 +5499,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void EQShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { + static void EQShortVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5515,7 +5515,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpMaskProvider") - static void EQShortMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction fa, + static void EQShortVectorMaxTestsBroadcastLongMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5539,7 +5539,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShortMaxVectorTests(IntFunction fa, IntFunction fb, + static void blendShortVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5555,11 +5555,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::blend); + assertArraysEquals(r, a, b, mask, ShortVectorMaxTests::blend); } @Test(dataProvider = "shortUnaryOpShuffleProvider") - static void RearrangeShortMaxVectorTests(IntFunction fa, + static void RearrangeShortVectorMaxTests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); int[] order = fs.apply(a.length, SPECIES.length()); @@ -5576,7 +5576,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpShuffleMaskProvider") - static void RearrangeShortMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void RearrangeShortVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -5594,7 +5594,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void compressShortMaxVectorTests(IntFunction fa, + static void compressShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5612,7 +5612,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void expandShortMaxVectorTests(IntFunction fa, + static void expandShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5630,7 +5630,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void getShortMaxVectorTests(IntFunction fa) { + static void getShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -5786,7 +5786,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastShortMaxVectorTests(IntFunction fa) { + static void BroadcastShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5800,7 +5800,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZeroShortMaxVectorTests(IntFunction fa) { + static void ZeroShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5825,7 +5825,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void sliceUnaryShortMaxVectorTests(IntFunction fa) { + static void sliceUnaryShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5836,7 +5836,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, ShortMaxVectorTests::sliceUnary); + assertArraysEquals(r, a, origin, ShortVectorMaxTests::sliceUnary); } static short[] sliceBinary(short[] a, short[] b, int origin, int idx) { @@ -5853,7 +5853,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void sliceBinaryShortMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void sliceBinaryShortVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5866,7 +5866,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, ShortMaxVectorTests::sliceBinary); + assertArraysEquals(r, a, b, origin, ShortVectorMaxTests::sliceBinary); } static short[] slice(short[] a, short[] b, int origin, boolean[] mask, int idx) { @@ -5883,7 +5883,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void sliceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void sliceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -5900,7 +5900,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, mask, ShortMaxVectorTests::slice); + assertArraysEquals(r, a, b, origin, mask, ShortVectorMaxTests::slice); } static short[] unsliceUnary(short[] a, int origin, int idx) { @@ -5917,7 +5917,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void unsliceUnaryShortMaxVectorTests(IntFunction fa) { + static void unsliceUnaryShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; int origin = RAND.nextInt(SPECIES.length()); @@ -5928,7 +5928,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, origin, ShortMaxVectorTests::unsliceUnary); + assertArraysEquals(r, a, origin, ShortVectorMaxTests::unsliceUnary); } static short[] unsliceBinary(short[] a, short[] b, int origin, int part, int idx) { @@ -5954,7 +5954,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpProvider") - static void unsliceBinaryShortMaxVectorTestsBinary(IntFunction fa, IntFunction fb) { + static void unsliceBinaryShortVectorMaxTestsBinary(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -5968,7 +5968,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, ShortMaxVectorTests::unsliceBinary); + assertArraysEquals(r, a, b, origin, part, ShortVectorMaxTests::unsliceBinary); } static short[] unslice(short[] a, short[] b, int origin, int part, boolean[] mask, int idx) { @@ -6008,7 +6008,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void unsliceShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void unsliceShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6025,7 +6025,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, origin, part, mask, ShortMaxVectorTests::unslice); + assertArraysEquals(r, a, b, origin, part, mask, ShortVectorMaxTests::unslice); } static short BITWISE_BLEND(short a, short b, short c) { @@ -6037,7 +6037,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShortMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6052,11 +6052,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, ShortVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShortMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6069,11 +6069,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.bitwiseBlend(bv, cv).intoArray(r, i); } - assertArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend); + assertArraysEquals(r, a, b, c, ShortVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShortMaxVectorTestsMasked(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVectorMaxTestsMasked(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6091,11 +6091,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND); + assertArraysEquals(r, a, b, c, mask, ShortVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6106,11 +6106,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, ShortVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShortMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6121,11 +6121,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6136,11 +6136,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { ShortVector bv = ShortVector.fromArray(SPECIES, b, i); av.bitwiseBlend(bv, c[i]).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend); + assertBroadcastArraysEquals(r, a, b, c, ShortVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShortMaxVectorTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVectorMaxTestsAltBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6151,11 +6151,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { ShortVector cv = ShortVector.fromArray(SPECIES, c, i); av.bitwiseBlend(b[i], cv).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend); + assertAltBroadcastArraysEquals(r, a, b, c, ShortVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6170,11 +6170,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i); } - assertBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND); + assertBroadcastArraysEquals(r, a, b, c, mask, ShortVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShortMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVectorMaxTestsAltBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6189,11 +6189,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i); } - assertAltBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND); + assertAltBroadcastArraysEquals(r, a, b, c, mask, ShortVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void BITWISE_BLENDShortMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void BITWISE_BLENDShortVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6204,11 +6204,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVectorMaxTests::BITWISE_BLEND); } @Test(dataProvider = "shortTernaryOpProvider") - static void bitwiseBlendShortMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { + static void bitwiseBlendShortVectorMaxTestsDoubleBroadcastSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] c = fc.apply(SPECIES.length()); @@ -6219,11 +6219,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.bitwiseBlend(b[i], c[i]).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend); + assertDoubleBroadcastArraysEquals(r, a, b, c, ShortVectorMaxTests::bitwiseBlend); } @Test(dataProvider = "shortTernaryOpMaskProvider") - static void BITWISE_BLENDShortMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, + static void BITWISE_BLENDShortVectorMaxTestsDoubleBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb, IntFunction fc, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6237,7 +6237,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i); } - assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND); + assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ShortVectorMaxTests::BITWISE_BLEND); } static short NEG(short a) { @@ -6249,7 +6249,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NEGShortMaxVectorTests(IntFunction fa) { + static void NEGShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6260,11 +6260,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::NEG); + assertArraysEquals(r, a, ShortVectorMaxTests::NEG); } @Test(dataProvider = "shortUnaryOpProvider") - static void negShortMaxVectorTests(IntFunction fa) { + static void negShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6275,11 +6275,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::neg); + assertArraysEquals(r, a, ShortVectorMaxTests::neg); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NEGMaskedShortMaxVectorTests(IntFunction fa, + static void NEGMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6293,7 +6293,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::NEG); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::NEG); } static short ABS(short a) { @@ -6305,7 +6305,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ABSShortMaxVectorTests(IntFunction fa) { + static void ABSShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6316,11 +6316,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::ABS); + assertArraysEquals(r, a, ShortVectorMaxTests::ABS); } @Test(dataProvider = "shortUnaryOpProvider") - static void absShortMaxVectorTests(IntFunction fa) { + static void absShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6331,11 +6331,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::abs); + assertArraysEquals(r, a, ShortVectorMaxTests::abs); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ABSMaskedShortMaxVectorTests(IntFunction fa, + static void ABSMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6349,7 +6349,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::ABS); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::ABS); } static short NOT(short a) { @@ -6361,7 +6361,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void NOTShortMaxVectorTests(IntFunction fa) { + static void NOTShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6372,11 +6372,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::NOT); + assertArraysEquals(r, a, ShortVectorMaxTests::NOT); } @Test(dataProvider = "shortUnaryOpProvider") - static void notShortMaxVectorTests(IntFunction fa) { + static void notShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6387,11 +6387,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::not); + assertArraysEquals(r, a, ShortVectorMaxTests::not); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void NOTMaskedShortMaxVectorTests(IntFunction fa, + static void NOTMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6405,7 +6405,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::NOT); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::NOT); } static short ZOMO(short a) { @@ -6413,7 +6413,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ZOMOShortMaxVectorTests(IntFunction fa) { + static void ZOMOShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6424,11 +6424,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::ZOMO); + assertArraysEquals(r, a, ShortVectorMaxTests::ZOMO); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ZOMOMaskedShortMaxVectorTests(IntFunction fa, + static void ZOMOMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6442,7 +6442,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::ZOMO); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::ZOMO); } static short BIT_COUNT(short a) { @@ -6450,7 +6450,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void BIT_COUNTShortMaxVectorTests(IntFunction fa) { + static void BIT_COUNTShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6461,11 +6461,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::BIT_COUNT); + assertArraysEquals(r, a, ShortVectorMaxTests::BIT_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void BIT_COUNTMaskedShortMaxVectorTests(IntFunction fa, + static void BIT_COUNTMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6479,7 +6479,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::BIT_COUNT); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::BIT_COUNT); } static short TRAILING_ZEROS_COUNT(short a) { @@ -6487,7 +6487,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void TRAILING_ZEROS_COUNTShortMaxVectorTests(IntFunction fa) { + static void TRAILING_ZEROS_COUNTShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6498,11 +6498,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVectorMaxTests::TRAILING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void TRAILING_ZEROS_COUNTMaskedShortMaxVectorTests(IntFunction fa, + static void TRAILING_ZEROS_COUNTMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6516,7 +6516,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::TRAILING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::TRAILING_ZEROS_COUNT); } static short LEADING_ZEROS_COUNT(short a) { @@ -6524,7 +6524,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void LEADING_ZEROS_COUNTShortMaxVectorTests(IntFunction fa) { + static void LEADING_ZEROS_COUNTShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6535,11 +6535,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, ShortVectorMaxTests::LEADING_ZEROS_COUNT); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void LEADING_ZEROS_COUNTMaskedShortMaxVectorTests(IntFunction fa, + static void LEADING_ZEROS_COUNTMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6553,7 +6553,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::LEADING_ZEROS_COUNT); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::LEADING_ZEROS_COUNT); } static short REVERSE(short a) { @@ -6561,7 +6561,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSEShortMaxVectorTests(IntFunction fa) { + static void REVERSEShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6572,11 +6572,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::REVERSE); + assertArraysEquals(r, a, ShortVectorMaxTests::REVERSE); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSEMaskedShortMaxVectorTests(IntFunction fa, + static void REVERSEMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6590,7 +6590,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::REVERSE); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::REVERSE); } static short REVERSE_BYTES(short a) { @@ -6598,7 +6598,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void REVERSE_BYTESShortMaxVectorTests(IntFunction fa) { + static void REVERSE_BYTESShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6609,11 +6609,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, ShortVectorMaxTests::REVERSE_BYTES); } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void REVERSE_BYTESMaskedShortMaxVectorTests(IntFunction fa, + static void REVERSE_BYTESMaskedShortVectorMaxTests(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] r = fr.apply(SPECIES.length()); @@ -6627,7 +6627,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, mask, ShortMaxVectorTests::REVERSE_BYTES); + assertArraysEquals(r, a, mask, ShortVectorMaxTests::REVERSE_BYTES); } static boolean band(boolean a, boolean b) { @@ -6635,7 +6635,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandShortVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6648,7 +6648,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::band); + assertArraysEquals(r, a, b, ShortVectorMaxTests::band); } static boolean bor(boolean a, boolean b) { @@ -6656,7 +6656,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskorShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskorShortVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6669,7 +6669,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::bor); + assertArraysEquals(r, a, b, ShortVectorMaxTests::bor); } static boolean bxor(boolean a, boolean b) { @@ -6677,7 +6677,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskxorShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskxorShortVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6690,7 +6690,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::bxor); + assertArraysEquals(r, a, b, ShortVectorMaxTests::bxor); } static boolean bandNot(boolean a, boolean b) { @@ -6698,7 +6698,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskandNotShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskandNotShortVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6711,7 +6711,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::bandNot); + assertArraysEquals(r, a, b, ShortVectorMaxTests::bandNot); } static boolean beq(boolean a, boolean b) { @@ -6719,7 +6719,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskeqShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskeqShortVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6732,7 +6732,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, b, ShortMaxVectorTests::beq); + assertArraysEquals(r, a, b, ShortVectorMaxTests::beq); } static boolean unot(boolean a) { @@ -6740,7 +6740,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskUnaryOpProvider") - static void masknotShortMaxVectorTests(IntFunction fa) { + static void masknotShortVectorMaxTests(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); boolean[] r = new boolean[a.length]; @@ -6751,7 +6751,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertArraysEquals(r, a, ShortMaxVectorTests::unot); + assertArraysEquals(r, a, ShortVectorMaxTests::unot); } private static final long LONG_MASK_BITS = 0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()); @@ -6768,7 +6768,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "longMaskProvider") - static void maskFromToLongShortMaxVectorTests(IntFunction fa) { + static void maskFromToLongShortVectorMaxTests(IntFunction fa) { long[] a = fa.apply(SPECIES.length()); long[] r = new long[a.length]; @@ -6782,7 +6782,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void ltShortMaxVectorTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { + static void ltShortVectorMaxTestsBroadcastSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6798,7 +6798,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortCompareOpProvider") - static void eqShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { + static void eqShortVectorMaxTestsBroadcastMaskedSmokeTest(IntFunction fa, IntFunction fb) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6814,7 +6814,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toIntArrayShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void toIntArrayShortVectorMaxTestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6825,7 +6825,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toLongArrayShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void toLongArrayShortVectorMaxTestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6836,7 +6836,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toDoubleArrayShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void toDoubleArrayShortVectorMaxTestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6847,7 +6847,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void toStringShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void toStringShortVectorMaxTestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6860,7 +6860,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void hashCodeShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void hashCodeShortVectorMaxTestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -6893,7 +6893,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpProvider") - static void ADDReduceLongShortMaxVectorTests(IntFunction fa) { + static void ADDReduceLongShortVectorMaxTests(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); long ra = 0; @@ -6909,7 +6909,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionLongArraysEquals(r, ra, a, - ShortMaxVectorTests::ADDReduceLong, ShortMaxVectorTests::ADDReduceAllLong); + ShortVectorMaxTests::ADDReduceLong, ShortVectorMaxTests::ADDReduceAllLong); } static long ADDReduceLongMasked(short[] a, int idx, boolean[] mask) { @@ -6932,7 +6932,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpMaskProvider") - static void ADDReduceLongShortMaxVectorTestsMasked(IntFunction fa, IntFunction fm) { + static void ADDReduceLongShortVectorMaxTestsMasked(IntFunction fa, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); long[] r = lfr.apply(SPECIES.length()); boolean[] mask = fm.apply(SPECIES.length()); @@ -6950,11 +6950,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } assertReductionLongArraysEqualsMasked(r, ra, a, mask, - ShortMaxVectorTests::ADDReduceLongMasked, ShortMaxVectorTests::ADDReduceAllLongMasked); + ShortVectorMaxTests::ADDReduceLongMasked, ShortVectorMaxTests::ADDReduceAllLongMasked); } @Test(dataProvider = "shortUnaryOpProvider") - static void BroadcastLongShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void BroadcastLongShortVectorMaxTestsSmokeTest(IntFunction fa) { short[] a = fa.apply(SPECIES.length()); short[] r = new short[a.length]; @@ -6965,7 +6965,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortBinaryOpMaskProvider") - static void blendShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, + static void blendShortVectorMaxTestsBroadcastLongSmokeTest(IntFunction fa, IntFunction fb, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); @@ -6979,12 +6979,12 @@ public class ShortMaxVectorTests extends AbstractVectorTest { av.blend((long)b[i], vmask).intoArray(r, i); } } - assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::blend); + assertBroadcastLongArraysEquals(r, a, b, mask, ShortVectorMaxTests::blend); } @Test(dataProvider = "shortUnaryOpSelectFromProvider") - static void SelectFromShortMaxVectorTests(IntFunction fa, + static void SelectFromShortVectorMaxTests(IntFunction fa, BiFunction fs) { short[] a = fa.apply(SPECIES.length()); short[] order = fs.apply(a.length, SPECIES.length()); @@ -7000,7 +7000,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortSelectFromTwoVectorOpProvider") - static void SelectFromTwoVectorShortMaxVectorTests(IntFunction fa, IntFunction fb, IntFunction fc) { + static void SelectFromTwoVectorShortVectorMaxTests(IntFunction fa, IntFunction fb, IntFunction fc) { short[] a = fa.apply(SPECIES.length()); short[] b = fb.apply(SPECIES.length()); short[] idx = fc.apply(SPECIES.length()); @@ -7018,7 +7018,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shortUnaryOpSelectFromMaskProvider") - static void SelectFromShortMaxVectorTestsMaskedSmokeTest(IntFunction fa, + static void SelectFromShortVectorMaxTestsMaskedSmokeTest(IntFunction fa, BiFunction fs, IntFunction fm) { short[] a = fa.apply(SPECIES.length()); @@ -7037,7 +7037,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleMiscellaneousShortMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleMiscellaneousShortVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7053,7 +7053,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleProvider") - static void shuffleToStringShortMaxVectorTestsSmokeTest(BiFunction fs) { + static void shuffleToStringShortVectorMaxTestsSmokeTest(BiFunction fs) { int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7067,7 +7067,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "shuffleCompareOpProvider") - static void shuffleEqualsShortMaxVectorTestsSmokeTest(BiFunction fa, BiFunction fb) { + static void shuffleEqualsShortVectorMaxTestsSmokeTest(BiFunction fa, BiFunction fb) { int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length()); @@ -7081,7 +7081,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "boolMaskBinaryOpProvider") - static void maskEqualsShortMaxVectorTests(IntFunction fa, IntFunction fb) { + static void maskEqualsShortVectorMaxTests(IntFunction fa, IntFunction fb) { boolean[] a = fa.apply(SPECIES.length()); boolean[] b = fb.apply(SPECIES.length()); @@ -7097,7 +7097,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskHashCodeShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskHashCodeShortVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); for (int i = 0; i < a.length; i += SPECIES.length()) { @@ -7119,7 +7119,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskTrueCountShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskTrueCountShortVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7130,7 +7130,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskTrueCount); + assertMaskReductionArraysEquals(r, a, ShortVectorMaxTests::maskTrueCount); } static int maskLastTrue(boolean[] a, int idx) { @@ -7144,7 +7144,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskLastTrueShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskLastTrueShortVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7155,7 +7155,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskLastTrue); + assertMaskReductionArraysEquals(r, a, ShortVectorMaxTests::maskLastTrue); } static int maskFirstTrue(boolean[] a, int idx) { @@ -7169,7 +7169,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "maskProvider") - static void maskFirstTrueShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskFirstTrueShortVectorMaxTestsSmokeTest(IntFunction fa) { boolean[] a = fa.apply(SPECIES.length()); int[] r = new int[a.length]; @@ -7180,11 +7180,11 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } } - assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskFirstTrue); + assertMaskReductionArraysEquals(r, a, ShortVectorMaxTests::maskFirstTrue); } @Test(dataProvider = "maskProvider") - static void maskCompressShortMaxVectorTestsSmokeTest(IntFunction fa) { + static void maskCompressShortVectorMaxTestsSmokeTest(IntFunction fa) { int trueCount = 0; boolean[] a = fa.apply(SPECIES.length()); @@ -7212,7 +7212,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeShortMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeShortVectorMaxTestsSmokeTest(int offset) { int limit = SPECIES.length() * BUFFER_REPS; for (int i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7226,7 +7226,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "offsetProvider") - static void indexInRangeLongShortMaxVectorTestsSmokeTest(int offset) { + static void indexInRangeLongShortVectorMaxTestsSmokeTest(int offset) { long limit = SPECIES.length() * BUFFER_REPS; for (long i = 0; i < limit; i += SPECIES.length()) { var actualMask = SPECIES.indexInRange(i + offset, limit); @@ -7253,14 +7253,14 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test(dataProvider = "lengthProvider") - static void loopBoundShortMaxVectorTestsSmokeTest(int length) { + static void loopBoundShortVectorMaxTestsSmokeTest(int length) { int actualLoopBound = SPECIES.loopBound(length); int expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); assertEquals(actualLoopBound, expectedLoopBound); } @Test(dataProvider = "lengthProvider") - static void loopBoundLongShortMaxVectorTestsSmokeTest(int _length) { + static void loopBoundLongShortVectorMaxTestsSmokeTest(int _length) { long length = _length; long actualLoopBound = SPECIES.loopBound(length); long expectedLoopBound = length - Math.floorMod(length, SPECIES.length()); @@ -7268,21 +7268,21 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test - static void ElementSizeShortMaxVectorTestsSmokeTest() { + static void ElementSizeShortVectorMaxTestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); int elsize = av.elementSize(); assertEquals(elsize, Short.SIZE); } @Test - static void VectorShapeShortMaxVectorTestsSmokeTest() { + static void VectorShapeShortVectorMaxTestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); assert(vsh.equals(VectorShape.S_Max_BIT)); } @Test - static void ShapeWithLanesShortMaxVectorTestsSmokeTest() { + static void ShapeWithLanesShortVectorMaxTestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = vsh.withLanes(short.class); @@ -7290,32 +7290,32 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test - static void ElementTypeShortMaxVectorTestsSmokeTest() { + static void ElementTypeShortVectorMaxTestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementType() == short.class); } @Test - static void SpeciesElementSizeShortMaxVectorTestsSmokeTest() { + static void SpeciesElementSizeShortVectorMaxTestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().elementSize() == Short.SIZE); } @Test - static void VectorTypeShortMaxVectorTestsSmokeTest() { + static void VectorTypeShortVectorMaxTestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); assert(av.species().vectorType() == av.getClass()); } @Test - static void WithLanesShortMaxVectorTestsSmokeTest() { + static void WithLanesShortVectorMaxTestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorSpecies species = av.species().withLanes(short.class); assert(species.equals(SPECIES)); } @Test - static void WithShapeShortMaxVectorTestsSmokeTest() { + static void WithShapeShortVectorMaxTestsSmokeTest() { ShortVector av = ShortVector.zero(SPECIES); VectorShape vsh = av.shape(); VectorSpecies species = av.species().withShape(vsh); @@ -7323,7 +7323,7 @@ public class ShortMaxVectorTests extends AbstractVectorTest { } @Test - static void MaskAllTrueShortMaxVectorTestsSmokeTest() { + static void MaskAllTrueShortVectorMaxTestsSmokeTest() { for (int ic = 0; ic < INVOC_COUNT; ic++) { assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length())); } diff --git a/test/jdk/jdk/incubator/vector/gen-tests.sh b/test/jdk/jdk/incubator/vector/gen-tests.sh index 239e53367c0..8b5c4cac616 100644 --- a/test/jdk/jdk/incubator/vector/gen-tests.sh +++ b/test/jdk/jdk/incubator/vector/gen-tests.sh @@ -1,6 +1,6 @@ #!/bin/bash # -# Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2018, 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 @@ -126,7 +126,6 @@ do abstractvectortype=${typeprefix}${Type}Vector abstractvectorteststype=${typeprefix}${Type}VectorTests - abstractbitsvectortype=${typeprefix}${Bitstype}Vector abstractfpvectortype=${typeprefix}${Fptype}Vector args="$args -Dabstractvectortype=$abstractvectortype -Dabstractvectorteststype=$abstractvectorteststype -Dabstractbitsvectortype=$abstractbitsvectortype -Dabstractfpvectortype=$abstractfpvectortype" @@ -136,12 +135,12 @@ do for bits in 64 128 256 512 Max do - vectortype=${typeprefix}${Type}${bits}Vector - vectorteststype=${typeprefix}${Type}${bits}VectorTests - vectorbenchtype=${typeprefix}${Type}${bits}Vector - masktype=${typeprefix}${Type}${bits}Mask - bitsvectortype=${typeprefix}${Bitstype}${bits}Vector - fpvectortype=${typeprefix}${Fptype}${bits}Vector + vectortype=${typeprefix}${Type}$Vector{bits} + vectorteststype=${typeprefix}${Type}Vector${bits}Tests + vectorbenchtype=${typeprefix}${Type}Vector${bits} + masktype=${typeprefix}${Type}$Mask{bits} + bitsvectortype=${typeprefix}${Bitstype}Vector${bits} + fpvectortype=${typeprefix}${Fptype}Vector${bits} shape=S${bits}Bit Shape=S_${bits}_BIT if [[ "${vectortype}" == "ByteMaxVector" ]]; then @@ -211,12 +210,12 @@ do # For each size for bits in 64 128 256 512 Max do - vectortype=${typeprefix}${Type}${bits}Vector - vectorteststype=${typeprefix}${Type}${bits}VectorLoadStoreTests - vectorbenchtype=${typeprefix}${Type}${bits}VectorLoadStore - masktype=${typeprefix}${Type}${bits}Mask - bitsvectortype=${typeprefix}${Bitstype}${bits}Vector - fpvectortype=${typeprefix}${Fptype}${bits}Vector + vectortype=${typeprefix}${Type}Vector${bits} + vectorteststype=${typeprefix}${Type}Vector${bits}LoadStoreTests + vectorbenchtype=${typeprefix}${Type}Vector${bits}LoadStore + masktype=${typeprefix}${Type}Mask${bits} + bitsvectortype=${typeprefix}${Bitstype}Vector${bits} + fpvectortype=${typeprefix}${Fptype}Vector${bits} shape=S${bits}Bit Shape=S_${bits}_BIT if [[ "${vectortype}" == "ByteMaxVector" ]]; then From bea48b54e2f423693e1e472129a86b030baf9eee Mon Sep 17 00:00:00 2001 From: Volkan Yazici Date: Thu, 19 Feb 2026 09:44:00 +0000 Subject: [PATCH 02/63] 8272758: Improve HttpServer to avoid partial file name matches while mapping request path to context path Reviewed-by: dfuchs --- .../com/sun/net/httpserver/HttpServer.java | 44 +++- .../share/classes/module-info.java | 32 ++- .../sun/net/httpserver/ContextList.java | 197 +++++++++++++++++- .../ContextPathMatcherPathPrefixTest.java | 154 ++++++++++++++ .../ContextPathMatcherStringPrefixTest.java | 64 ++++++ .../httpclient/PlainProxyConnectionTest.java | 6 +- 6 files changed, 471 insertions(+), 26 deletions(-) create mode 100644 test/jdk/com/sun/net/httpserver/ContextPathMatcherPathPrefixTest.java create mode 100644 test/jdk/com/sun/net/httpserver/ContextPathMatcherStringPrefixTest.java diff --git a/src/jdk.httpserver/share/classes/com/sun/net/httpserver/HttpServer.java b/src/jdk.httpserver/share/classes/com/sun/net/httpserver/HttpServer.java index a0271fed146..fb10ecb0755 100644 --- a/src/jdk.httpserver/share/classes/com/sun/net/httpserver/HttpServer.java +++ b/src/jdk.httpserver/share/classes/com/sun/net/httpserver/HttpServer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 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 @@ -75,7 +75,7 @@ import java.util.concurrent.Executor; * *

The following table shows some request URIs and which, if any context they would * match with: - * + *
description
* * * @@ -278,10 +278,20 @@ public abstract class HttpServer { *

The class overview describes how incoming request URIs are * mapped to HttpContext instances. * - * @apiNote The path should generally, but is not required to, end with '/'. - * If the path does not end with '/', eg such as with {@code "/foo"} then - * this would match requests with a path of {@code "/foobar"} or - * {@code "/foo/bar"}. + * @apiNote + * The path should generally, but is not required to, end with {@code /}. + * If the path does not end with {@code /}, e.g., such as with {@code /foo}, + * then some implementations may use string prefix matching where + * this context path matches request paths {@code /foo}, + * {@code /foo/bar}, or {@code /foobar}. Others may use path prefix + * matching where {@code /foo} matches request paths {@code /foo} and + * {@code /foo/bar}, but not {@code /foobar}. + * + * @implNote + * By default, the JDK built-in implementation uses path prefix matching. + * String prefix matching can be enabled using the + * {@link jdk.httpserver/##sun.net.httpserver.pathMatcher sun.net.httpserver.pathMatcher} + * system property. * * @param path the root URI path to associate the context with * @param handler the handler to invoke for incoming requests @@ -289,6 +299,8 @@ public abstract class HttpServer { * already exists for this path * @throws NullPointerException if either path, or handler are {@code null} * @return an instance of {@code HttpContext} + * + * @see jdk.httpserver/##sun.net.httpserver.pathMatcher sun.net.httpserver.pathMatcher */ public abstract HttpContext createContext(String path, HttpHandler handler); @@ -308,16 +320,28 @@ public abstract class HttpServer { *

The class overview describes how incoming request URIs are * mapped to {@code HttpContext} instances. * - * @apiNote The path should generally, but is not required to, end with '/'. - * If the path does not end with '/', eg such as with {@code "/foo"} then - * this would match requests with a path of {@code "/foobar"} or - * {@code "/foo/bar"}. + * @apiNote + * The path should generally, but is not required to, end with {@code /}. + * If the path does not end with {@code /}, e.g., such as with {@code /foo}, + * then some implementations may use string prefix matching where + * this context path matches request paths {@code /foo}, + * {@code /foo/bar}, or {@code /foobar}. Others may use path prefix + * matching where {@code /foo} matches request paths + * {@code /foo} and {@code /foo/bar}, but not {@code /foobar}. + * + * @implNote + * By default, the JDK built-in implementation uses path prefix matching. + * String prefix matching can be enabled using the + * {@link jdk.httpserver/##sun.net.httpserver.pathMatcher sun.net.httpserver.pathMatcher} + * system property. * * @param path the root URI path to associate the context with * @throws IllegalArgumentException if path is invalid, or if a context * already exists for this path * @throws NullPointerException if path is {@code null} * @return an instance of {@code HttpContext} + * + * @see jdk.httpserver/##sun.net.httpserver.pathMatcher sun.net.httpserver.pathMatcher */ public abstract HttpContext createContext(String path); diff --git a/src/jdk.httpserver/share/classes/module-info.java b/src/jdk.httpserver/share/classes/module-info.java index ac147582b14..0a0e77c628f 100644 --- a/src/jdk.httpserver/share/classes/module-info.java +++ b/src/jdk.httpserver/share/classes/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 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 @@ -101,7 +101,35 @@ import com.sun.net.httpserver.*; *

  • {@systemProperty sun.net.httpserver.nodelay} (default: false)
    * Boolean value, which if true, sets the {@link java.net.StandardSocketOptions#TCP_NODELAY TCP_NODELAY} * socket option on all incoming connections. - *

    • + * + *
  • + *

    {@systemProperty sun.net.httpserver.pathMatcher} (default: + * {@code pathPrefix})
    + * + * The path matching scheme used to route requests to context handlers. + * The property can be configured with one of the following values:

    + * + *
    + *
    + *
    {@code pathPrefix} (default)
    + *
    The request path must begin with the context path and all matching path + * segments must be identical. For instance, the context path {@code /foo} + * would match request paths {@code /foo}, {@code /foo/}, and {@code /foo/bar}, + * but not {@code /foobar}.
    + *
    {@code stringPrefix}
    + *
    The request path string must begin with the context path string. For + * instance, the context path {@code /foo} would match request paths + * {@code /foo}, {@code /foo/}, {@code /foo/bar}, and {@code /foobar}. + *
    + *
    + *
    + * + *

    In case of a blank or invalid value, the default will be used.

    + * + *

    This property and the ability to restore the string prefix matching + * behavior may be removed in a future release.

    + *
    • + * * * @apiNote The API and SPI in this module are designed and implemented to support a minimal * HTTP server and simple HTTP semantics primarily. diff --git a/src/jdk.httpserver/share/classes/sun/net/httpserver/ContextList.java b/src/jdk.httpserver/share/classes/sun/net/httpserver/ContextList.java index 96b55575928..6393ca34798 100644 --- a/src/jdk.httpserver/share/classes/sun/net/httpserver/ContextList.java +++ b/src/jdk.httpserver/share/classes/sun/net/httpserver/ContextList.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 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 @@ -26,13 +26,22 @@ package sun.net.httpserver; import java.util.*; +import java.util.function.BiPredicate; class ContextList { + private static final System.Logger LOGGER = System.getLogger(ContextList.class.getName()); + private final LinkedList list = new LinkedList<>(); public synchronized void add(HttpContextImpl ctx) { + assert ctx != null; + // `findContext(String protocol, String path, ContextPathMatcher matcher)` + // expects the protocol to be lower-cased using ROOT locale, hence: + assert ctx.getProtocol().equals(ctx.getProtocol().toLowerCase(Locale.ROOT)); assert ctx.getPath() != null; + // `ContextPathMatcher` expects context paths to be non-empty: + assert !ctx.getPath().isEmpty(); if (contains(ctx)) { throw new IllegalArgumentException("cannot add context to list"); } @@ -40,21 +49,25 @@ class ContextList { } boolean contains(HttpContextImpl ctx) { - return findContext(ctx.getProtocol(), ctx.getPath(), true) != null; + return findContext(ctx.getProtocol(), ctx.getPath(), ContextPathMatcher.EXACT) != null; } public synchronized int size() { return list.size(); } - /* initially contexts are located only by protocol:path. - * Context with longest prefix matches (currently case-sensitive) + /** + * {@return the context with the longest case-sensitive prefix match} + * + * @param protocol the request protocol + * @param path the request path */ - synchronized HttpContextImpl findContext(String protocol, String path) { - return findContext(protocol, path, false); + HttpContextImpl findContext(String protocol, String path) { + var matcher = ContextPathMatcher.ofConfiguredPrefixPathMatcher(); + return findContext(protocol, path, matcher); } - synchronized HttpContextImpl findContext(String protocol, String path, boolean exact) { + private synchronized HttpContextImpl findContext(String protocol, String path, ContextPathMatcher matcher) { protocol = protocol.toLowerCase(Locale.ROOT); String longest = ""; HttpContextImpl lc = null; @@ -63,9 +76,7 @@ class ContextList { continue; } String cpath = ctx.getPath(); - if (exact && !cpath.equals(path)) { - continue; - } else if (!exact && !path.startsWith(cpath)) { + if (!matcher.test(cpath, path)) { continue; } if (cpath.length() > longest.length()) { @@ -76,10 +87,174 @@ class ContextList { return lc; } + private enum ContextPathMatcher implements BiPredicate { + + /** + * Tests if both the request path and the context path are identical. + */ + EXACT(String::equals), + + /** + * Tests string prefix matches where the request path string + * starts with the context path string. + * + *

    Examples

    + * + *
    description
    Request URI
    + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
    Context pathRequest path
    /foo/foo//foo/bar/foobar
    /YYYY
    /fooYYYY
    /foo/NYYN
    + */ + STRING_PREFIX((contextPath, requestPath) -> requestPath.startsWith(contextPath)), + + /** + * Tests path prefix matches where path segments must have an + * exact match. + * + *

    Examples

    + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
    Context pathRequest path
    /foo/foo//foo/bar/foobar
    /YYYY
    /fooYYYN
    /foo/NYYN
    + */ + PATH_PREFIX((contextPath, requestPath) -> { + + // Fast-path for `/` + if ("/".equals(contextPath)) { + return true; + } + + // Does the request path prefix match? + if (requestPath.startsWith(contextPath)) { + + // Is it an exact match? + int contextPathLength = contextPath.length(); + if (requestPath.length() == contextPathLength) { + return true; + } + + // Is it a path-prefix match? + assert contextPathLength > 0; + return + // Case 1: The request path starts with the context + // path, but the context path has an extra path + // separator suffix. For instance, the context path is + // `/foo/` and the request path is `/foo/bar`. + contextPath.charAt(contextPathLength - 1) == '/' || + // Case 2: The request path starts with the + // context path, but the request path has an + // extra path separator suffix. For instance, + // context path is `/foo` and the request path + // is `/foo/` or `/foo/bar`. + requestPath.charAt(contextPathLength) == '/'; + + } + + return false; + + }); + + private final BiPredicate predicate; + + ContextPathMatcher(BiPredicate predicate) { + this.predicate = predicate; + } + + @Override + public boolean test(String contextPath, String requestPath) { + return predicate.test(contextPath, requestPath); + } + + private static ContextPathMatcher ofConfiguredPrefixPathMatcher() { + var propertyName = "sun.net.httpserver.pathMatcher"; + var propertyValueDefault = "pathPrefix"; + var propertyValue = System.getProperty(propertyName, propertyValueDefault); + return switch (propertyValue) { + case "pathPrefix" -> ContextPathMatcher.PATH_PREFIX; + case "stringPrefix" -> ContextPathMatcher.STRING_PREFIX; + default -> { + LOGGER.log( + System.Logger.Level.WARNING, + "System property \"{}\" contains an invalid value: \"{}\". Falling back to the default: \"{}\"", + propertyName, propertyValue, propertyValueDefault); + yield ContextPathMatcher.PATH_PREFIX; + } + }; + } + + } + public synchronized void remove(String protocol, String path) throws IllegalArgumentException { - HttpContextImpl ctx = findContext(protocol, path, true); + HttpContextImpl ctx = findContext(protocol, path, ContextPathMatcher.EXACT); if (ctx == null) { throw new IllegalArgumentException("cannot remove element from list"); } diff --git a/test/jdk/com/sun/net/httpserver/ContextPathMatcherPathPrefixTest.java b/test/jdk/com/sun/net/httpserver/ContextPathMatcherPathPrefixTest.java new file mode 100644 index 00000000000..e1cff62a45f --- /dev/null +++ b/test/jdk/com/sun/net/httpserver/ContextPathMatcherPathPrefixTest.java @@ -0,0 +1,154 @@ +/* + * Copyright (c) 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. + */ + +import com.sun.net.httpserver.HttpHandler; +import com.sun.net.httpserver.HttpServer; +import java.io.IOException; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.util.Map; + +import static java.net.http.HttpClient.Builder.NO_PROXY; + +import org.junit.jupiter.api.AfterAll; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +/* + * @test id=default + * @bug 8272758 + * @summary Verifies path prefix matching using defaults + * @build EchoHandler + * @run junit ${test.main.class} + */ + +/* + * @test id=withProperty + * @bug 8272758 + * @summary Verifies path prefix matching by providing a system property + * @build EchoHandler + * @run junit/othervm + * -Dsun.net.httpserver.pathMatcher=pathPrefix + * ${test.main.class} + */ + +/* + * @test id=withInvalidProperty + * @bug 8272758 + * @summary Verifies path prefix matching by providing a system property + * containing an invalid value, and observing it fall back to the + * default + * @build EchoHandler + * @run junit/othervm + * -Dsun.net.httpserver.pathMatcher=noSuchMatcher + * ${test.main.class} + */ + +public class ContextPathMatcherPathPrefixTest { + + protected static final HttpClient CLIENT = + HttpClient.newBuilder().proxy(NO_PROXY).build(); + + @AfterAll + static void stopClient() { + CLIENT.shutdownNow(); + } + + @Test + void testContextPathOfEmptyString() { + var iae = assertThrows(IllegalArgumentException.class, () -> new Infra("")); + assertEquals("Illegal value for path or protocol", iae.getMessage()); + } + + @Test + void testContextPathAtRoot() throws Exception { + try (var infra = new Infra("/")) { + infra.expect(200, "/foo", "/foo/", "/foo/bar", "/foobar"); + } + } + + @Test + void testContextPathAtSubDir() throws Exception { + try (var infra = new Infra("/foo")) { + infra.expect(200, "/foo", "/foo/", "/foo/bar"); + infra.expect(404, "/foobar"); + } + } + + @Test + void testContextPathAtSubDirWithTrailingSlash() throws Exception { + try (var infra = new Infra("/foo/")) { + infra.expect(200, "/foo/", "/foo/bar"); + infra.expect(404, "/foo", "/foobar"); + } + } + + protected static final class Infra implements AutoCloseable { + + private static final InetSocketAddress LO_SA_0 = + new InetSocketAddress(InetAddress.getLoopbackAddress(), 0); + + private static final HttpHandler HANDLER = new EchoHandler(); + + private final HttpServer server; + + private final String contextPath; + + protected Infra(String contextPath) throws IOException { + this.server = HttpServer.create(LO_SA_0, 10); + server.createContext(contextPath, HANDLER); + server.start(); + this.contextPath = contextPath; + } + + protected void expect(int statusCode, String... requestPaths) throws Exception { + for (String requestPath : requestPaths) { + var requestURI = URI.create("http://%s:%s%s".formatted( + server.getAddress().getHostString(), + server.getAddress().getPort(), + requestPath)); + var request = HttpRequest.newBuilder(requestURI).build(); + var response = CLIENT.send(request, HttpResponse.BodyHandlers.discarding()); + assertEquals( + statusCode, response.statusCode(), + "unexpected status code " + Map.of( + "contextPath", contextPath, + "requestPath", requestPath)); + } + } + + @Override + public void close() { + server.stop(0); + } + + } + +} diff --git a/test/jdk/com/sun/net/httpserver/ContextPathMatcherStringPrefixTest.java b/test/jdk/com/sun/net/httpserver/ContextPathMatcherStringPrefixTest.java new file mode 100644 index 00000000000..3f3008a8531 --- /dev/null +++ b/test/jdk/com/sun/net/httpserver/ContextPathMatcherStringPrefixTest.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 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. + */ + +import org.junit.jupiter.api.Test; + +/* + * @test + * @bug 8272758 + * @summary Verifies string prefix matching configured using a system property + * @build ContextPathMatcherPathPrefixTest + * EchoHandler + * @run junit/othervm + * -Dsun.net.httpserver.pathMatcher=stringPrefix + * ${test.main.class} + */ + +class ContextPathMatcherStringPrefixTest extends ContextPathMatcherPathPrefixTest { + + @Test + @Override + void testContextPathAtRoot() throws Exception { + try (var infra = new Infra("/")) { + infra.expect(200, "/foo", "/foo/", "/foo/bar", "/foobar"); + } + } + + @Test + @Override + void testContextPathAtSubDir() throws Exception { + try (var infra = new Infra("/foo")) { + infra.expect(200, "/foo", "/foo/", "/foo/bar", "/foobar"); + } + } + + @Test + @Override + void testContextPathAtSubDirWithTrailingSlash() throws Exception { + try (var infra = new Infra("/foo/")) { + infra.expect(200, "/foo/", "/foo/bar"); + infra.expect(404, "/foo", "/foobar"); + } + } + +} diff --git a/test/jdk/java/net/httpclient/PlainProxyConnectionTest.java b/test/jdk/java/net/httpclient/PlainProxyConnectionTest.java index c2fab85f8ff..cd7049285f1 100644 --- a/test/jdk/java/net/httpclient/PlainProxyConnectionTest.java +++ b/test/jdk/java/net/httpclient/PlainProxyConnectionTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 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 @@ -208,9 +208,9 @@ public class PlainProxyConnectionTest { System.out.println("Server is: " + server.getAddress().toString()); URI uri = new URI("http", null, server.getAddress().getAddress().getHostAddress(), - server.getAddress().getPort(), PATH + "x", + server.getAddress().getPort(), PATH + "/x", null, null); - URI proxiedURI = new URI("http://some.host.that.does.not.exist:4242" + PATH + "x"); + URI proxiedURI = new URI("http://some.host.that.does.not.exist:4242" + PATH + "/x"); performSanityTest(server, uri, proxiedURI); From 79dbc50b4f907af9b5f9d586d6bd6f33c3a3dd21 Mon Sep 17 00:00:00 2001 From: Erik Gahlin Date: Thu, 19 Feb 2026 15:26:56 +0000 Subject: [PATCH 03/63] 8378171: JFR: Copy of a closed recording should not be available Reviewed-by: mgronlun --- .../share/classes/jdk/jfr/EventSettings.java | 7 ++++++- .../share/classes/jdk/jfr/Recording.java | 10 ++++++++-- .../jdk/jfr/internal/PlatformRecorder.java | 20 +++++++++++-------- .../jdk/jfr/internal/PrivateAccess.java | 5 ++++- .../api/recording/misc/TestRecordingCopy.java | 11 ++++++++-- 5 files changed, 39 insertions(+), 14 deletions(-) diff --git a/src/jdk.jfr/share/classes/jdk/jfr/EventSettings.java b/src/jdk.jfr/share/classes/jdk/jfr/EventSettings.java index 6ed20f124d9..c9f24d9f903 100644 --- a/src/jdk.jfr/share/classes/jdk/jfr/EventSettings.java +++ b/src/jdk.jfr/share/classes/jdk/jfr/EventSettings.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 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 @@ -150,6 +150,11 @@ public abstract class EventSettings { return FlightRecorder.getFlightRecorder().getInternal(); } + @Override + public Recording newRecording(RecordingState state) { + return new Recording(state, Map.of()); + } + @Override public EventSettings newEventSettings(EventSettingsModifier esm) { return new EventSettings.DelegatedEventSettings(esm); diff --git a/src/jdk.jfr/share/classes/jdk/jfr/Recording.java b/src/jdk.jfr/share/classes/jdk/jfr/Recording.java index 089a5ed37d8..8a3181307d2 100644 --- a/src/jdk.jfr/share/classes/jdk/jfr/Recording.java +++ b/src/jdk.jfr/share/classes/jdk/jfr/Recording.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 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 @@ -35,6 +35,7 @@ import java.util.HashMap; import java.util.Map; import java.util.Objects; +import jdk.jfr.RecordingState; import jdk.jfr.internal.PlatformRecorder; import jdk.jfr.internal.PlatformRecording; import jdk.jfr.internal.Type; @@ -100,11 +101,16 @@ public final class Recording implements Closeable { * @since 11 */ public Recording(Map settings) { + this(RecordingState.NEW, settings); + } + + // package private + Recording(RecordingState state, Map settings) { Objects.requireNonNull(settings, "settings"); Map sanitized = Utils.sanitizeNullFreeStringMap(settings); PlatformRecorder r = FlightRecorder.getFlightRecorder().getInternal(); synchronized (r) { - this.internal = r.newRecording(sanitized); + this.internal = r.newRecording(state, sanitized); this.internal.setRecording(this); if (internal.getRecording() != this) { throw new InternalError("Internal recording not properly setup"); diff --git a/src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java b/src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java index cf46c05b804..260f2fed54d 100644 --- a/src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java +++ b/src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 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 @@ -82,8 +82,8 @@ public final class PlatformRecorder { Runtime.getRuntime().addShutdownHook(shutdownHook); } - public synchronized PlatformRecording newRecording(Map settings) { - return newRecording(settings, ++recordingCounter); + public synchronized PlatformRecording newRecording(RecordingState state, Map settings) { + return newRecording(state, settings, ++recordingCounter); } // To be used internally when doing dumps. @@ -92,15 +92,17 @@ public final class PlatformRecorder { if(!Thread.holdsLock(this)) { throw new InternalError("Caller must have recorder lock"); } - return newRecording(new HashMap<>(), 0); + return newRecording(RecordingState.NEW, new HashMap<>(), 0); } - private synchronized PlatformRecording newRecording(Map settings, long id) { + private synchronized PlatformRecording newRecording(RecordingState state, Map settings, long id) { PlatformRecording recording = new PlatformRecording(this, id); if (!settings.isEmpty()) { recording.setSettings(settings); } - recordings.add(recording); + if (state != RecordingState.CLOSED) { + recordings.add(recording); + } return recording; } @@ -545,8 +547,10 @@ public final class PlatformRecorder { } synchronized Recording newCopy(PlatformRecording r, boolean stop) { - Recording newRec = new Recording(); - PlatformRecording copy = PrivateAccess.getInstance().getPlatformRecording(newRec); + PrivateAccess pr = PrivateAccess.getInstance(); + boolean closed = r.getState() == RecordingState.CLOSED; + Recording newRec = closed ? pr.newRecording(RecordingState.CLOSED) : new Recording(); + PlatformRecording copy = pr.getPlatformRecording(newRec); copy.setSettings(r.getSettings()); copy.setMaxAge(r.getMaxAge()); copy.setMaxSize(r.getMaxSize()); diff --git a/src/jdk.jfr/share/classes/jdk/jfr/internal/PrivateAccess.java b/src/jdk.jfr/share/classes/jdk/jfr/internal/PrivateAccess.java index fe5d5aea327..2297bf7bdde 100644 --- a/src/jdk.jfr/share/classes/jdk/jfr/internal/PrivateAccess.java +++ b/src/jdk.jfr/share/classes/jdk/jfr/internal/PrivateAccess.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 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 @@ -33,6 +33,7 @@ import jdk.jfr.Configuration; import jdk.jfr.EventSettings; import jdk.jfr.EventType; import jdk.jfr.Recording; +import jdk.jfr.RecordingState; import jdk.jfr.SettingDescriptor; import jdk.jfr.ValueDescriptor; import jdk.jfr.internal.management.EventSettingsModifier; @@ -96,6 +97,8 @@ public abstract class PrivateAccess { public abstract PlatformRecorder getPlatformRecorder(); + public abstract Recording newRecording(RecordingState state); + public abstract EventSettings newEventSettings(EventSettingsModifier esm); public abstract boolean isVisible(EventType t); diff --git a/test/jdk/jdk/jfr/api/recording/misc/TestRecordingCopy.java b/test/jdk/jdk/jfr/api/recording/misc/TestRecordingCopy.java index 1234655f31a..960a4ca73d2 100644 --- a/test/jdk/jdk/jfr/api/recording/misc/TestRecordingCopy.java +++ b/test/jdk/jdk/jfr/api/recording/misc/TestRecordingCopy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 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 @@ -22,6 +22,7 @@ */ package jdk.jfr.api.recording.misc; +import jdk.jfr.FlightRecorder; import jdk.jfr.Recording; import jdk.jfr.RecordingState; import jdk.jfr.consumer.RecordedEvent; @@ -79,8 +80,14 @@ public class TestRecordingCopy { Asserts.assertEquals(stoppedCopy.getState(), RecordingState.STOPPED); assertCopy(stoppedCopy, original); - // Clean-up original.close(); + int beforeCount = FlightRecorder.getFlightRecorder().getRecordings().size(); + Recording closedCopy = original.copy(true); + Asserts.assertEquals(closedCopy.getState(), RecordingState.CLOSED); + int afterCount = FlightRecorder.getFlightRecorder().getRecordings().size(); + Asserts.assertEquals(beforeCount, afterCount); + + // Clean-up runningCopy.stop(); runningCopy.close(); stoppedCopy.close(); From f02d1900958ee705c4e86bc94b92f7c2cde39c0d Mon Sep 17 00:00:00 2001 From: Kirill Shirokov Date: Thu, 19 Feb 2026 16:35:53 +0000 Subject: [PATCH 04/63] 8377729: Running jtreg tests with -agent... option causes some tests to fail due to duplicate -agent options provided to a subprocess Reviewed-by: lmesnik, sspitsyn --- .../jtreg/gc/g1/ihop/TestIHOPStatic.java | 3 +- .../tools/jstack/DeadlockDetectionTest.java | 6 ++-- test/lib/jdk/test/lib/apps/LingeredApp.java | 2 ++ .../test/lib/cli/CommandLineOptionTest.java | 3 +- .../jdk/test/lib/process/ProcessTools.java | 32 +++++++++++++++++-- 5 files changed, 36 insertions(+), 10 deletions(-) diff --git a/test/hotspot/jtreg/gc/g1/ihop/TestIHOPStatic.java b/test/hotspot/jtreg/gc/g1/ihop/TestIHOPStatic.java index 6f2c7c005df..2028e8751d7 100644 --- a/test/hotspot/jtreg/gc/g1/ihop/TestIHOPStatic.java +++ b/test/hotspot/jtreg/gc/g1/ihop/TestIHOPStatic.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 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 @@ -119,7 +119,6 @@ public class TestIHOPStatic { System.out.println(" MaxHeapSize : " + heapSize); System.out.println(" Expect for concurrent cycle initiation message : " + expectInitiationMessage); List options = new ArrayList<>(); - Collections.addAll(options, Utils.getTestJavaOpts()); Collections.addAll(options, "-XX:InitiatingHeapOccupancyPercent=" + ihop, "-Dmemory.fill=" + (heapSize * 1024 * 1024 * pctToFill / 100), diff --git a/test/jdk/sun/tools/jstack/DeadlockDetectionTest.java b/test/jdk/sun/tools/jstack/DeadlockDetectionTest.java index 80eda6fc091..d743485373e 100644 --- a/test/jdk/sun/tools/jstack/DeadlockDetectionTest.java +++ b/test/jdk/sun/tools/jstack/DeadlockDetectionTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 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 @@ -76,10 +76,8 @@ public class DeadlockDetectionTest { } try { - String[] vmArgs = Utils.appendTestJavaOpts("-XX:+UsePerfData"); - theApp = new LingeredAppWithDeadlock(); - LingeredApp.startApp(theApp, vmArgs); + LingeredApp.startApp(theApp, "-XX:+UsePerfData"); OutputAnalyzer output = jstack(Long.toString(theApp.getPid())); System.out.println(output.getOutput()); diff --git a/test/lib/jdk/test/lib/apps/LingeredApp.java b/test/lib/jdk/test/lib/apps/LingeredApp.java index 38ad9ae5b0e..9a8395d7879 100644 --- a/test/lib/jdk/test/lib/apps/LingeredApp.java +++ b/test/lib/jdk/test/lib/apps/LingeredApp.java @@ -46,6 +46,7 @@ import java.util.UUID; import jdk.test.lib.JDKToolFinder; import jdk.test.lib.Utils; import jdk.test.lib.process.OutputBuffer; +import jdk.test.lib.process.ProcessTools; import jdk.test.lib.process.StreamPumper; import jdk.test.lib.util.CoreUtils; @@ -451,6 +452,7 @@ public class LingeredApp { long t1 = System.currentTimeMillis(); theApp.createLock(); try { + ProcessTools.checkDuplicateAgentOpts(jvmOpts); theApp.runAppExactJvmOpts(jvmOpts); theApp.waitAppReadyOrCrashed(); } catch (Exception ex) { diff --git a/test/lib/jdk/test/lib/cli/CommandLineOptionTest.java b/test/lib/jdk/test/lib/cli/CommandLineOptionTest.java index 8e28ea08365..a9ae57bca71 100644 --- a/test/lib/jdk/test/lib/cli/CommandLineOptionTest.java +++ b/test/lib/jdk/test/lib/cli/CommandLineOptionTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 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 @@ -107,7 +107,6 @@ public abstract class CommandLineOptionTest { List finalOptions = new ArrayList<>(); if (addTestVMOptions) { Collections.addAll(finalOptions, InputArguments.getVmInputArgs()); - Collections.addAll(finalOptions, Utils.getTestJavaOpts()); } Collections.addAll(finalOptions, options); finalOptions.add("-version"); diff --git a/test/lib/jdk/test/lib/process/ProcessTools.java b/test/lib/jdk/test/lib/process/ProcessTools.java index 7d03268cac4..fe9c1de9f30 100644 --- a/test/lib/jdk/test/lib/process/ProcessTools.java +++ b/test/lib/jdk/test/lib/process/ProcessTools.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2025, Oracle and/or its affiliates. All rights reserved. + * 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 @@ -43,8 +43,10 @@ import java.time.Duration; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.concurrent.CancellationException; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; @@ -448,7 +450,7 @@ public final class ProcessTools { private static ProcessBuilder createJavaProcessBuilder(String... command) { String javapath = JDKToolFinder.getJDKTool("java"); - ArrayList args = new ArrayList<>(); + List args = new ArrayList<>(); args.add(javapath); String noCPString = System.getProperty("test.noclasspath", "false"); @@ -465,6 +467,8 @@ public final class ProcessTools { Collections.addAll(args, command); } + checkDuplicateAgentOpts(args); + // Reporting StringBuilder cmdLine = new StringBuilder(); for (String cmd : args) @@ -479,6 +483,30 @@ public final class ProcessTools { return pb; } + // 8377729: Check for duplicate VM JVMTI agent options, as it may + // cause test to fail + public static void checkDuplicateAgentOpts(List args) { + if (args == null || args.isEmpty()) { + return; + } + + Set seen = new HashSet<>(); + List dupArgs = args.stream() + .filter(arg -> (arg.startsWith("-agent") + || arg.startsWith("-javaagent:")) + && !seen.add(arg)) + .collect(Collectors.toList()); + + if (!dupArgs.isEmpty()) { + System.err.println("WARNING: Duplicate JVMTI agent options may" + + " cause test to fail:\n" + dupArgs); + } + } + + public static void checkDuplicateAgentOpts(String[] args) { + checkDuplicateAgentOpts(Arrays.asList(args)); + } + private static void printStack(Thread t, StackTraceElement[] stack) { System.out.println("\t" + t + " stack: (length = " + stack.length + ")"); if (t != null) { From 4a6d359a455fd9895ee40ab64909ac6501487d87 Mon Sep 17 00:00:00 2001 From: Ben Taylor Date: Thu, 19 Feb 2026 17:27:01 +0000 Subject: [PATCH 05/63] 8377701: Shenandoah: Convert ShenandoahEvacOOMHandler to use Atomic Reviewed-by: shade, xpeng, wkemper, phh --- .../share/gc/shenandoah/shenandoahEvacOOMHandler.cpp | 12 ++++++------ .../share/gc/shenandoah/shenandoahEvacOOMHandler.hpp | 3 ++- .../shenandoah/shenandoahEvacOOMHandler.inline.hpp | 5 ++--- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.cpp b/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.cpp index dd09bec8a7c..5b24140ac1c 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.cpp @@ -37,22 +37,22 @@ ShenandoahEvacOOMCounter::ShenandoahEvacOOMCounter() : void ShenandoahEvacOOMCounter::decrement() { assert(unmasked_count() > 0, "sanity"); // NOTE: It's ok to simply decrement, even with mask set, because unmasked value is positive. - AtomicAccess::dec(&_bits); + _bits.fetch_then_sub(1); } void ShenandoahEvacOOMCounter::clear() { assert(unmasked_count() == 0, "sanity"); - AtomicAccess::release_store_fence(&_bits, (jint)0); + _bits.release_store_fence((jint)0); } void ShenandoahEvacOOMCounter::set_oom_bit(bool decrement) { - jint threads_in_evac = AtomicAccess::load_acquire(&_bits); + jint threads_in_evac = _bits.load_acquire(); while (true) { jint newval = decrement ? (threads_in_evac - 1) | OOM_MARKER_MASK : threads_in_evac | OOM_MARKER_MASK; - jint other = AtomicAccess::cmpxchg(&_bits, threads_in_evac, newval); + jint other = _bits.compare_exchange(threads_in_evac, newval); if (other == threads_in_evac) { // Success: wait for other threads to get out of the protocol and return. break; @@ -65,7 +65,7 @@ void ShenandoahEvacOOMCounter::set_oom_bit(bool decrement) { bool ShenandoahEvacOOMCounter::try_increment() { - jint threads_in_evac = AtomicAccess::load_acquire(&_bits); + jint threads_in_evac = _bits.load_acquire(); while (true) { // Cannot enter evacuation if OOM_MARKER_MASK is set. @@ -73,7 +73,7 @@ bool ShenandoahEvacOOMCounter::try_increment() return false; } - jint other = AtomicAccess::cmpxchg(&_bits, threads_in_evac, threads_in_evac + 1); + jint other = _bits.compare_exchange(threads_in_evac, threads_in_evac + 1); if (other == threads_in_evac) { // Success: caller may safely enter evacuation return true; diff --git a/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.hpp b/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.hpp index dd77f6216e0..3e28d9ac88e 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.hpp @@ -27,6 +27,7 @@ #include "gc/shenandoah/shenandoahPadding.hpp" #include "memory/allocation.hpp" +#include "runtime/atomic.hpp" #include "runtime/javaThread.hpp" #include "utilities/globalDefinitions.hpp" @@ -36,7 +37,7 @@ class ShenandoahEvacOOMCounter { private: // Combination of a 31-bit counter and 1-bit OOM marker. - volatile jint _bits; + Atomic _bits; // This class must be at least a cache line in size to prevent false sharing. shenandoah_padding_minus_size(0, sizeof(jint)); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.inline.hpp index 11509ec9d2d..4bd4381068a 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahEvacOOMHandler.inline.hpp @@ -29,14 +29,13 @@ #include "gc/shenandoah/shenandoahHeap.inline.hpp" #include "gc/shenandoah/shenandoahThreadLocalData.hpp" -#include "runtime/atomicAccess.hpp" jint ShenandoahEvacOOMCounter::load_acquire() { - return AtomicAccess::load_acquire(&_bits); + return _bits.load_acquire(); } jint ShenandoahEvacOOMCounter::unmasked_count() { - return AtomicAccess::load_acquire(&_bits) & ~OOM_MARKER_MASK; + return _bits.load_acquire() & ~OOM_MARKER_MASK; } void ShenandoahEvacOOMHandler::enter_evacuation(Thread* thr) { From 82fe8b9cd0f2985327a4bd6efcaef539b751f667 Mon Sep 17 00:00:00 2001 From: Coleen Phillimore Date: Thu, 19 Feb 2026 17:39:38 +0000 Subject: [PATCH 06/63] 8377797: Remove SA support for MethodData and the printmdo command Reviewed-by: kevinw, ysuenaga, cjplummer, kvn --- src/hotspot/share/runtime/vmStructs.cpp | 25 +- src/jdk.hotspot.agent/doc/clhsdb.html | 1 - .../sun/jvm/hotspot/CommandProcessor.java | 41 +- .../sun/jvm/hotspot/oops/ArgInfoData.java | 56 --- .../sun/jvm/hotspot/oops/ArrayData.java | 82 ---- .../classes/sun/jvm/hotspot/oops/BitData.java | 74 ---- .../sun/jvm/hotspot/oops/BranchData.java | 76 ---- .../sun/jvm/hotspot/oops/CallTypeData.java | 108 ----- .../hotspot/oops/CallTypeDataInterface.java | 35 -- .../sun/jvm/hotspot/oops/CounterData.java | 71 ---- .../sun/jvm/hotspot/oops/DataLayout.java | 189 --------- .../sun/jvm/hotspot/oops/JumpData.java | 81 ---- .../sun/jvm/hotspot/oops/Metadata.java | 3 +- .../classes/sun/jvm/hotspot/oops/Method.java | 8 +- .../sun/jvm/hotspot/oops/MethodData.java | 376 +----------------- .../jvm/hotspot/oops/MethodDataInterface.java | 39 -- .../sun/jvm/hotspot/oops/MultiBranchData.java | 113 ------ .../jvm/hotspot/oops/ParametersTypeData.java | 74 ---- .../sun/jvm/hotspot/oops/ProfileData.java | 123 ------ .../jvm/hotspot/oops/ReceiverTypeData.java | 132 ------ .../classes/sun/jvm/hotspot/oops/RetData.java | 113 ------ .../sun/jvm/hotspot/oops/ReturnTypeEntry.java | 60 --- .../jvm/hotspot/oops/SpeculativeTrapData.java | 70 ---- .../sun/jvm/hotspot/oops/TypeEntries.java | 97 ----- .../jvm/hotspot/oops/TypeEntriesAtCall.java | 54 --- .../hotspot/oops/TypeStackSlotEntries.java | 91 ----- .../sun/jvm/hotspot/oops/VirtualCallData.java | 64 --- .../jvm/hotspot/oops/VirtualCallTypeData.java | 108 ----- .../serviceability/sa/ClhsdbCDSCore.java | 20 +- .../jtreg/serviceability/sa/TestPrintMdo.java | 73 ---- 30 files changed, 12 insertions(+), 2445 deletions(-) delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ArgInfoData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ArrayData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/BitData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/BranchData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CallTypeData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CallTypeDataInterface.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CounterData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/DataLayout.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/JumpData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MethodDataInterface.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MultiBranchData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ParametersTypeData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ProfileData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ReceiverTypeData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/RetData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ReturnTypeEntry.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/SpeculativeTrapData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeEntries.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeEntriesAtCall.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeStackSlotEntries.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/VirtualCallData.java delete mode 100644 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/VirtualCallTypeData.java delete mode 100644 test/hotspot/jtreg/serviceability/sa/TestPrintMdo.java diff --git a/src/hotspot/share/runtime/vmStructs.cpp b/src/hotspot/share/runtime/vmStructs.cpp index 36c55bd2ecc..92be0217bf3 100644 --- a/src/hotspot/share/runtime/vmStructs.cpp +++ b/src/hotspot/share/runtime/vmStructs.cpp @@ -159,7 +159,7 @@ unchecked_nonstatic_field) \ \ /******************************************************************/ \ - /* OopDesc and Klass hierarchies (NOTE: MethodData* incomplete) */ \ + /* OopDesc and Klass hierarchies */ \ /******************************************************************/ \ \ volatile_nonstatic_field(oopDesc, _mark, markWord) \ @@ -233,27 +233,7 @@ nonstatic_field(Klass, _vtable_len, int) \ nonstatic_field(Klass, _class_loader_data, ClassLoaderData*) \ nonstatic_field(vtableEntry, _method, Method*) \ - nonstatic_field(MethodData, _size, int) \ nonstatic_field(MethodData, _method, Method*) \ - nonstatic_field(MethodData, _data_size, int) \ - nonstatic_field(MethodData, _data[0], intptr_t) \ - nonstatic_field(MethodData, _parameters_type_data_di, int) \ - nonstatic_field(MethodData, _compiler_counters._nof_decompiles, uint) \ - nonstatic_field(MethodData, _compiler_counters._nof_overflow_recompiles, uint) \ - nonstatic_field(MethodData, _compiler_counters._nof_overflow_traps, uint) \ - nonstatic_field(MethodData, _compiler_counters._trap_hist._array[0], u1) \ - nonstatic_field(MethodData, _eflags, intx) \ - nonstatic_field(MethodData, _arg_local, intx) \ - nonstatic_field(MethodData, _arg_stack, intx) \ - nonstatic_field(MethodData, _arg_returned, intx) \ - nonstatic_field(MethodData, _tenure_traps, uint) \ - nonstatic_field(MethodData, _invoke_mask, int) \ - nonstatic_field(MethodData, _backedge_mask, int) \ - nonstatic_field(DataLayout, _header._struct._tag, u1) \ - nonstatic_field(DataLayout, _header._struct._flags, u1) \ - nonstatic_field(DataLayout, _header._struct._bci, u2) \ - nonstatic_field(DataLayout, _header._struct._traps, u4) \ - nonstatic_field(DataLayout, _cells[0], intptr_t) \ nonstatic_field(MethodCounters, _invoke_mask, int) \ nonstatic_field(MethodCounters, _backedge_mask, int) \ COMPILER2_OR_JVMCI_PRESENT(nonstatic_field(MethodCounters, _interpreter_throwout_count, u2)) \ @@ -961,8 +941,6 @@ declare_type(ConstMethod, MetaspaceObj) \ declare_type(Annotations, MetaspaceObj) \ \ - declare_toplevel_type(MethodData::CompilerCounters) \ - \ declare_toplevel_type(narrowKlass) \ \ declare_toplevel_type(vtableEntry) \ @@ -971,7 +949,6 @@ declare_toplevel_type(Symbol*) \ declare_toplevel_type(volatile Metadata*) \ \ - declare_toplevel_type(DataLayout) \ declare_toplevel_type(BSMAttributeEntries) \ \ /********/ \ diff --git a/src/jdk.hotspot.agent/doc/clhsdb.html b/src/jdk.hotspot.agent/doc/clhsdb.html index bd436f1dfef..cfe6453b736 100644 --- a/src/jdk.hotspot.agent/doc/clhsdb.html +++ b/src/jdk.hotspot.agent/doc/clhsdb.html @@ -57,7 +57,6 @@ Available commands: pmap show Solaris pmap-like output print expression print given Klass*, Method* or arbitrary address printas type expression print given address as given HotSpot type. eg. print JavaThread <address> - printmdo -a | expression print method data oop printstatics [ type ] print static fields of given HotSpot type (or all types if none specified) pstack [-v] [-l] show mixed mode stack trace for all Java, non-Java threads. -v is verbose mode. -l includes info on owned java.util.concurrent locks. quit quit CLHSDB tool diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/CommandProcessor.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/CommandProcessor.java index 01b9a4a447e..74335f78888 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/CommandProcessor.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/CommandProcessor.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 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 @@ -60,7 +60,6 @@ import sun.jvm.hotspot.oops.InstanceKlass; import sun.jvm.hotspot.oops.Klass; import sun.jvm.hotspot.oops.Metadata; import sun.jvm.hotspot.oops.Method; -import sun.jvm.hotspot.oops.MethodData; import sun.jvm.hotspot.oops.Oop; import sun.jvm.hotspot.oops.RawHeapVisitor; import sun.jvm.hotspot.oops.Symbol; @@ -860,44 +859,8 @@ public class CommandProcessor { } } }, - new Command("printmdo", "printmdo [ -a | expression ]", false) { - // Print every MDO in the heap or the one referenced by expression. - public void doit(Tokens t) { - if (t.countTokens() != 1) { - usage(); - } else { - String s = t.nextToken(); - if (s.equals("-a")) { - ClassLoaderDataGraph cldg = VM.getVM().getClassLoaderDataGraph(); - cldg.classesDo(new ClassLoaderDataGraph.ClassVisitor() { - public void visit(Klass k) { - if (k instanceof InstanceKlass) { - MethodArray methods = ((InstanceKlass)k).getMethods(); - for (int i = 0; i < methods.length(); i++) { - Method m = methods.at(i); - MethodData mdo = m.getMethodData(); - if (mdo != null) { - out.println("MethodData " + mdo.getAddress() + " for " + - "method " + m.getMethodHolder().getName().asString() + "." + - m.getName().asString() + - m.getSignature().asString() + "@" + m.getAddress()); - mdo.printDataOn(out); - } - } - } - } - } - ); - } else { - Address a = VM.getVM().getDebugger().parseAddress(s); - MethodData mdo = (MethodData) Metadata.instantiateWrapperFor(a); - mdo.printDataOn(out); - } - } - } - }, new Command("printall", "printall", false) { - // Print every MDO in the heap or the one referenced by expression. + // Print every Method for every class loaded. public void doit(Tokens t) { if (t.countTokens() != 0) { usage(); diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ArgInfoData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ArgInfoData.java deleted file mode 100644 index 992d86a02ec..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ArgInfoData.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (c) 2014, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -public class ArgInfoData extends ArrayData { - - public ArgInfoData(DataLayout layout) { - super(layout); - } - - int numberOfArgs() { - return arrayLen(); - } - - int argModified(int arg) { - return arrayUintAt(arg); - } - - public void printDataOn(PrintStream st) { - printShared(st, "ArgInfoData"); - int nargs = numberOfArgs(); - for (int i = 0; i < nargs; i++) { - st.print(" 0x" + Integer.toHexString(argModified(i))); - } - st.println(); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ArrayData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ArrayData.java deleted file mode 100644 index 0eaa3faa74a..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ArrayData.java +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Copyright (c) 2011, 2012, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// ArrayData -// -// A ArrayData is a base class for accessing profiling data which does -// not have a statically known size. It consists of an array length -// and an array start. -abstract class ArrayData extends ProfileData { - - static final int arrayLenOffSet = 0; - static final int arrayStartOffSet = 1; - - int arrayUintAt(int index) { - int aindex = index + arrayStartOffSet; - return uintAt(aindex); - } - int arrayIntAt(int index) { - int aindex = index + arrayStartOffSet; - return intAt(aindex); - } - - // Code generation support for subclasses. - static int arrayElementOffset(int index) { - return cellOffset(arrayStartOffSet + index); - } - - ArrayData(DataLayout layout) { - super(layout); - } - - static int staticCellCount() { - return -1; - } - - int arrayLen() { - return intAt(arrayLenOffSet); - } - - public int cellCount() { - return arrayLen() + 1; - } - - // Code generation support - static int arrayLenOffset() { - return cellOffset(arrayLenOffSet); - } - static int arrayStartOffset() { - return cellOffset(arrayStartOffSet); - } - -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/BitData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/BitData.java deleted file mode 100644 index fa48a7c9b16..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/BitData.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) 2011, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// BitData -// -// A BitData holds a flag or two in its header. -public class BitData extends ProfileData { - - // nullSeen: - // saw a null operand (cast/aastore/instanceof) - static final int nullSeenFlag = DataLayout.firstFlag + 0; - static final int bitCellCount = 0; - - public BitData(DataLayout layout) { - super(layout); - } - - static int staticCellCount() { - return bitCellCount; - } - - public int cellCount() { - return staticCellCount(); - } - - // Accessor - - // The nullSeen flag bit is specially known to the interpreter. - // Consulting it allows the compiler to avoid setting up nullCheck traps. - boolean nullSeen() { return flagAt(nullSeenFlag); } - - // Code generation support - // static int nullSeenByteConstant() { - // return flagNumberToByteConstant(nullSeenFlag); - // } - - static int bitDataSize() { - return cellOffset(bitCellCount); - } - - public void printDataOn(PrintStream st) { - printShared(st, "BitData"); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/BranchData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/BranchData.java deleted file mode 100644 index 5f27437289c..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/BranchData.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (c) 2011, 2012, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// BranchData -// -// A BranchData is used to access profiling data for a two-way branch. -// It consists of taken and notTaken counts as well as a data displacement -// for the taken case. -public class BranchData extends JumpData { - - static final int notTakenOffSet = jumpCellCount; - static final int branchCellCount = notTakenOffSet + 1; - - public BranchData(DataLayout layout) { - super(layout); - //assert(layout.tag() == DataLayout.branchDataTag, "wrong type"); - } - - static int staticCellCount() { - return branchCellCount; - } - - public int cellCount() { - return staticCellCount(); - } - - // Direct accessor - int notTaken() { - return uintAt(notTakenOffSet); - } - - // Code generation support - static int notTakenOffset() { - return cellOffset(notTakenOffSet); - } - static int branchDataSize() { - return cellOffset(branchCellCount); - } - - public void printDataOn(PrintStream st) { - printShared(st, "BranchData"); - st.println("taken(" + taken() + ") displacement(" + displacement() + ")"); - tab(st); - st.println("not taken(" + notTaken() + ")"); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CallTypeData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CallTypeData.java deleted file mode 100644 index a0eb02946b3..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CallTypeData.java +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright (c) 2014, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// CallTypeData -// -// A CallTypeData is used to access profiling information about a non -// virtual call for which we collect type information about arguments -// and return value. -public class CallTypeData extends CounterData implements CallTypeDataInterface { - final TypeStackSlotEntries args; - final ReturnTypeEntry ret; - - int cellCountGlobalOffset() { - return CounterData.staticCellCount() + TypeEntriesAtCall.cellCountLocalOffset(); - } - - int cellCountNoHeader() { - return uintAt(cellCountGlobalOffset()); - } - - public CallTypeData(MethodDataInterface methodData, DataLayout layout) { - super(layout); - args = new TypeStackSlotEntries(methodData, this, CounterData.staticCellCount()+TypeEntriesAtCall.headerCellCount(), numberOfArguments()); - ret = new ReturnTypeEntry(methodData, this, cellCount() - ReturnTypeEntry.staticCellCount()); - } - - static int staticCellCount() { - return -1; - } - - public int cellCount() { - return CounterData.staticCellCount() + - TypeEntriesAtCall.headerCellCount() + - intAt(cellCountGlobalOffset()); - } - - public int numberOfArguments() { - return cellCountNoHeader() / TypeStackSlotEntries.perArgCount(); - } - - public boolean hasArguments() { - return cellCountNoHeader() >= TypeStackSlotEntries.perArgCount(); - } - - public K argumentType(int i) { - return args.type(i); - } - - public boolean hasReturn() { - return (cellCountNoHeader() % TypeStackSlotEntries.perArgCount()) != 0; - } - - public K returnType() { - return ret.type(); - } - - public int argumentTypeIndex(int i) { - return args.typeIndex(i); - } - - public int returnTypeIndex() { - return ret.typeIndex(); - } - - public void printDataOn(PrintStream st) { - super.printDataOn(st); - if (hasArguments()) { - tab(st); - st.print("argument types"); - args.printDataOn(st); - } - if (hasReturn()) { - tab(st); - st.print("return type"); - ret.printDataOn(st); - } - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CallTypeDataInterface.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CallTypeDataInterface.java deleted file mode 100644 index 0a8bf4721e4..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CallTypeDataInterface.java +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (c) 2014, 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. - * - */ - -package sun.jvm.hotspot.oops; - -public interface CallTypeDataInterface { - int numberOfArguments(); - boolean hasArguments(); - K argumentType(int i); - boolean hasReturn(); - K returnType(); - int argumentTypeIndex(int i); - int returnTypeIndex(); -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CounterData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CounterData.java deleted file mode 100644 index f803c71e02b..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CounterData.java +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright (c) 2011, 2012, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// CounterData -// -// A CounterData corresponds to a simple counter. -public class CounterData extends BitData { - - static final int countOff = 0; - static final int counterCellCount = 1; - - public CounterData(DataLayout layout) { - super(layout); - } - - static int staticCellCount() { - return counterCellCount; - } - - public int cellCount() { - return staticCellCount(); - } - - // Direct accessor - int count() { - return uintAt(countOff); - } - - // Code generation support - static int countOffset() { - return cellOffset(countOff); - } - static int counterDataSize() { - return cellOffset(counterCellCount); - } - - public void printDataOn(PrintStream st) { - printShared(st, "CounterData"); - st.println("count(" + count() + ")"); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/DataLayout.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/DataLayout.java deleted file mode 100644 index d627c66839b..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/DataLayout.java +++ /dev/null @@ -1,189 +0,0 @@ -/* - * Copyright (c) 2011, 2021, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -public class DataLayout { - public static final int noTag = 0; - public static final int bitDataTag = 1; - public static final int counterDataTag = 2; - public static final int jumpDataTag= 3; - public static final int receiverTypeDataTag = 4; - public static final int virtualCallDataTag = 5; - public static final int retDataTag = 6; - public static final int branchDataTag = 7; - public static final int multiBranchDataTag = 8; - public static final int argInfoDataTag = 9; - public static final int callTypeDataTag = 10; - public static final int virtualCallTypeDataTag = 11; - public static final int parametersTypeDataTag = 12; - public static final int speculativeTrapDataTag = 13; - - // The trap state breaks down as [recompile:1 | reason:31]. - // This further breakdown is defined in deoptimization.cpp. - // See Deoptimization.trapStateReason for an assert that - // trapBits is big enough to hold reasons < reasonRecordedLimit. - // - // The trapState is collected only if ProfileTraps is true. - public static final int trapBits = 1+31; // 31: enough to distinguish [0..reasonRecordedLimit]. - public static final int trapMask = Bits.rightNBits(trapBits); - public static final int firstFlag = 0; - - private Address data; - - private int offset; - - public DataLayout(MethodData d, int o) { - data = d.getAddress(); - offset = o; - } - - public DataLayout(Address d, int o) { - data = d; - offset = o; - } - - public int dp() { return offset; } - - private int getU11(int at) { - return data.getJByteAt(offset + at) & 0xff; - } - - private int getU22(int at) { - return data.getJShortAt(offset + at) & 0xffff; - } - - long cellAt(int index) { - return data.getCIntegerAt(offset + cellOffset(index), MethodData.cellSize, false); - } - - public Address addressAt(int index) { - return data.getAddressAt(offset + cellOffset(index)); - } - - // Every data layout begins with a header. This header - // contains a tag, which is used to indicate the size/layout - // of the data, 8 bits of flags, which can be used in any way, - // 32 bits of trap history (none/one reason/many reasons), - // and a bci, which is used to tie this piece of data to a - // specific bci in the bytecodes. - // union { - // u8 _bits; - // struct { - // u1 _tag; - // u1 _flags; - // u2 _bci; - // u4 _traps; - // } _struct; - // } _header; - - // Some types of data layouts need a length field. - static boolean needsArrayLen(int tag) { - return (tag == multiBranchDataTag); - } - - public static final int counterIncrement = 1; - - // Size computation - static int headerSizeInBytes() { - return MethodData.cellSize * headerSizeInCells(); - } - static int headerSizeInCells() { - return VM.getVM().isLP64() ? 1 : 2; - } - - public static int computeSizeInBytes(int cellCount) { - return headerSizeInBytes() + cellCount * MethodData.cellSize; - } - - // Initialization - // void initialize(int tag, int bci, int cellCount); - - // Accessors - public int tag() { - return getU11(0); - } - - // Return a few bits of trap state. Range is [0..trapMask]. - // The state tells if traps with zero, one, or many reasons have occurred. - // It also tells whether zero or many recompilations have occurred. - // The associated trap histogram in the MDO itself tells whether - // traps are common or not. If a BCI shows that a trap X has - // occurred, and the MDO shows N occurrences of X, we make the - // simplifying assumption that all N occurrences can be blamed - // on that BCI. - int trapState() { - return data.getJIntAt(offset+4); - } - - int flags() { - return getU11(1); - } - - int bci() { - return getU22(2); - } - - boolean flagAt(int flagNumber) { - // assert(flagNumber < flagLimit, "oob"); - return (flags() & (0x1 << flagNumber)) != 0; - } - - // Low-level support for code generation. - static int headerOffset() { - return 0; - } - static int tagOffset() { - return 0; - } - static int flagsOffset() { - return 1; - } - static int bciOffset() { - return 2; - } - public static int cellOffset(int index) { - return (headerSizeInCells() + index) * MethodData.cellSize; - } - // // Return a value which, when or-ed as a byte into _flags, sets the flag. - // static int flagNumberToByteConstant(int flagNumber) { - // assert(0 <= flagNumber && flagNumber < flagLimit, "oob"); - // DataLayout temp; temp.setHeader(0); - // temp.setFlagAt(flagNumber); - // return temp._header._struct._flags; - // } - // // Return a value which, when or-ed as a word into _header, sets the flag. - // static intptrT flagMaskToHeaderMask(int byteConstant) { - // DataLayout temp; temp.setHeader(0); - // temp._header._struct._flags = byteConstant; - // return temp._header._bits; - // } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/JumpData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/JumpData.java deleted file mode 100644 index 008a6ee7164..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/JumpData.java +++ /dev/null @@ -1,81 +0,0 @@ -/* - * Copyright (c) 2011, 2012, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// JumpData -// -// A JumpData is used to access profiling information for a direct -// branch. It is a counter, used for counting the number of branches, -// plus a data displacement, used for realigning the data pointer to -// the corresponding target bci. -public class JumpData extends ProfileData { - static final int takenOffSet = 0; - static final int displacementOffSet = 1; - static final int jumpCellCount = 2; - - public JumpData(DataLayout layout) { - super(layout); - //assert(layout.tag() == DataLayout.jumpDataTag || - // layout.tag() == DataLayout.branchDataTag, "wrong type"); - } - - static int staticCellCount() { - return jumpCellCount; - } - - public int cellCount() { - return staticCellCount(); - } - - // Direct accessor - int taken() { - return uintAt(takenOffSet); - } - - int displacement() { - return intAt(displacementOffSet); - } - - // Code generation support - static int takenOffset() { - return cellOffset(takenOffSet); - } - - static int displacementOffset() { - return cellOffset(displacementOffSet); - } - - public void printDataOn(PrintStream st) { - printShared(st, "JumpData"); - st.println("taken(" + taken() + ") displacement(" + displacement() + ")"); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Metadata.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Metadata.java index dfbd67ae805..1ba1f817c5c 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Metadata.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Metadata.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 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 @@ -67,7 +67,6 @@ public abstract class Metadata extends VMObject { metadataConstructor.addMapping("TypeArrayKlass", TypeArrayKlass.class); metadataConstructor.addMapping("ObjArrayKlass", ObjArrayKlass.class); metadataConstructor.addMapping("Method", Method.class); - metadataConstructor.addMapping("MethodData", MethodData.class); metadataConstructor.addMapping("ConstMethod", ConstMethod.class); metadataConstructor.addMapping("ConstantPool", ConstantPool.class); metadataConstructor.addMapping("ConstantPoolCache", ConstantPoolCache.class); diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Method.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Method.java index 75dec8edbd1..d16fa61a6b4 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Method.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Method.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 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 @@ -56,7 +56,6 @@ public class Method extends Metadata { private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { type = db.lookupType("Method"); constMethod = type.getAddressField("_constMethod"); - methodData = type.getAddressField("_method_data"); methodCounters = type.getAddressField("_method_counters"); accessFlags = new CIntField(type.getCIntegerField("_access_flags"), 0); code = type.getAddressField("_code"); @@ -82,7 +81,6 @@ public class Method extends Metadata { // Fields private static AddressField constMethod; - private static AddressField methodData; private static AddressField methodCounters; private static CIntField accessFlags; private static CIntField vtableIndex; @@ -126,10 +124,6 @@ public class Method extends Metadata { public U1Array getStackMapData() { return getConstMethod().getStackMapData(); } - public MethodData getMethodData() { - Address addr = methodData.getValue(getAddress()); - return VMObjectFactory.newObject(MethodData.class, addr); - } public MethodCounters getMethodCounters() { Address addr = methodCounters.getValue(getAddress()); return VMObjectFactory.newObject(MethodCounters.class, addr); diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MethodData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MethodData.java index a7c2e2bccb7..fd804085c7b 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MethodData.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MethodData.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 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 @@ -35,92 +35,7 @@ import sun.jvm.hotspot.utilities.Observer; // A MethodData provides interpreter profiling information -public class MethodData extends Metadata implements MethodDataInterface { - static int TypeProfileWidth = 2; - static int BciProfileWidth = 2; - static int CompileThreshold; - - static int Reason_many; // indicates presence of several reasons - static int Reason_none; // indicates absence of a relevant deopt. - static int Reason_LIMIT; - static int Reason_RECORDED_LIMIT; // some are not recorded per bc - - private static String[] trapReasonName; - - static String trapReasonName(int reason) { - if (reason == Reason_many) return "many"; - if (reason < Reason_LIMIT) - return trapReasonName[reason]; - return "reason" + reason; - } - - - static int trapStateReason(int trapState) { - // This assert provides the link between the width of DataLayout.trapBits - // and the encoding of "recorded" reasons. It ensures there are enough - // bits to store all needed reasons in the per-BCI MDO profile. - // assert(dsReasonMask >= reasonRecordedLimit, "enough bits"); - int recompileBit = (trapState & dsRecompileBit); - trapState -= recompileBit; - if (trapState == dsReasonMask) { - return Reason_many; - } else { - // assert((int)reasonNone == 0, "state=0 => Reason_none"); - return trapState; - } - } - - - static final int dsReasonMask = DataLayout.trapMask >> 1; - static final int dsRecompileBit = DataLayout.trapMask - dsReasonMask; - - static boolean trapStateIsRecompiled(int trapState) { - return (trapState & dsRecompileBit) != 0; - } - - static boolean reasonIsRecordedPerBytecode(int reason) { - return reason > Reason_none && reason < Reason_RECORDED_LIMIT; - } - static int trapStateAddReason(int trapState, int reason) { - // assert(reasonIsRecordedPerBytecode((DeoptReason)reason) || reason == reasonMany, "valid reason"); - int recompileBit = (trapState & dsRecompileBit); - trapState -= recompileBit; - if (trapState == dsReasonMask) { - return trapState + recompileBit; // already at state lattice bottom - } else if (trapState == reason) { - return trapState + recompileBit; // the condition is already true - } else if (trapState == 0) { - return reason + recompileBit; // no condition has yet been true - } else { - return dsReasonMask + recompileBit; // fall to state lattice bottom - } - } - static int trapStateSetRecompiled(int trapState, boolean z) { - if (z) return trapState | dsRecompileBit; - else return trapState & ~dsRecompileBit; - } - - static String formatTrapState(int trapState) { - int reason = trapStateReason(trapState); - boolean recompFlag = trapStateIsRecompiled(trapState); - // Re-encode the state from its decoded components. - int decodedState = 0; - if (reasonIsRecordedPerBytecode(reason) || reason == Reason_many) - decodedState = trapStateAddReason(decodedState, reason); - if (recompFlag) - decodedState = trapStateSetRecompiled(decodedState, recompFlag); - // If the state re-encodes properly, format it symbolically. - // Because this routine is used for debugging and diagnostics, - // be robust even if the state is a strange value. - if (decodedState != trapState) { - // Random buggy state that doesn't decode?? - return "#" + trapState; - } else { - return trapReasonName(reason) + (recompFlag ? " recompiled" : ""); - } - } - - +public class MethodData extends Metadata { static { VM.registerVMInitializedObserver(new Observer() { @@ -132,96 +47,17 @@ public class MethodData extends Metadata implements MethodDataInterface parametersTypeData() { - int di = (int)parametersTypeDataDi.getValue(getAddress()); - if (di == -1 || di == -2) { - return null; - } - DataLayout dataLayout = new DataLayout(this, di + (int)data.getOffset()); - return new ParametersTypeData(this, dataLayout); - } - - boolean outOfBounds(int dataIndex) { - return dataIndex >= dataSize(); - } - - ProfileData dataAt(int dataIndex) { - if (outOfBounds(dataIndex)) { - return null; - } - DataLayout dataLayout = new DataLayout(this, dataIndex + (int)data.getOffset()); - - switch (dataLayout.tag()) { - case DataLayout.noTag: - default: - throw new InternalError(dataIndex + " " + dataSize() + " " + dataLayout.tag()); - case DataLayout.bitDataTag: - return new BitData(dataLayout); - case DataLayout.counterDataTag: - return new CounterData(dataLayout); - case DataLayout.jumpDataTag: - return new JumpData(dataLayout); - case DataLayout.receiverTypeDataTag: - return new ReceiverTypeData(this, dataLayout); - case DataLayout.virtualCallDataTag: - return new VirtualCallData(this, dataLayout); - case DataLayout.retDataTag: - return new RetData(dataLayout); - case DataLayout.branchDataTag: - return new BranchData(dataLayout); - case DataLayout.multiBranchDataTag: - return new MultiBranchData(dataLayout); - case DataLayout.callTypeDataTag: - return new CallTypeData(this, dataLayout); - case DataLayout.virtualCallTypeDataTag: - return new VirtualCallTypeData(this, dataLayout); - case DataLayout.parametersTypeDataTag: - return new ParametersTypeData(this, dataLayout); - } - } - - int dpToDi(int dp) { - // this in an offset from the base of the MDO, so convert to offset into _data - return dp - (int)data.getOffset(); - } - - int firstDi() { return 0; } - public ProfileData firstData() { return dataAt(firstDi()); } - public ProfileData nextData(ProfileData current) { - int currentIndex = dpToDi(current.dp()); - int nextIndex = currentIndex + current.sizeInBytes(); - return dataAt(nextIndex); - } - boolean isValid(ProfileData current) { return current != null; } - - DataLayout limitDataPosition() { - return new DataLayout(this, dataSize() + (int)data.getOffset()); - } - - DataLayout extraDataBase() { - return limitDataPosition(); - } - - DataLayout extraDataLimit() { - return new DataLayout(this, sizeInBytes()); - } - - public static int extraNbCells(DataLayout dataLayout) { - int nbCells = 0; - switch(dataLayout.tag()) { - case DataLayout.bitDataTag: - case DataLayout.noTag: - nbCells = BitData.staticCellCount(); - break; - case DataLayout.speculativeTrapDataTag: - nbCells = SpeculativeTrapData.staticCellCount(); - break; - default: - throw new InternalError("unexpected tag " + dataLayout.tag()); - } - return nbCells; - } - - DataLayout nextExtra(DataLayout dataLayout) { - return new DataLayout(this, dataLayout.dp() + DataLayout.computeSizeInBytes(extraNbCells(dataLayout))); - } - - public void printDataOn(PrintStream st) { - if (parametersTypeData() != null) { - parametersTypeData().printDataOn(st); - } - ProfileData data = firstData(); - for ( ; isValid(data); data = nextData(data)) { - st.print(dpToDi(data.dp())); - st.print(" "); - // st->fillTo(6); - data.printDataOn(st); - } - st.println("--- Extra data:"); - DataLayout dp = extraDataBase(); - DataLayout end = extraDataLimit(); - for (;; dp = nextExtra(dp)) { - switch(dp.tag()) { - case DataLayout.noTag: - continue; - case DataLayout.bitDataTag: - data = new BitData(dp); - break; - case DataLayout.speculativeTrapDataTag: - data = new SpeculativeTrapData(this, dp); - break; - case DataLayout.argInfoDataTag: - data = new ArgInfoData(dp); - dp = end; // ArgInfoData is at the end of extra data section. - break; - default: - throw new InternalError("unexpected tag " + dp.tag()); - } - st.print(dpToDi(data.dp())); - st.print(" "); - data.printDataOn(st); - if (dp == end) return; - } - } - - private byte[] fetchDataAt(Address base, long offset, long size) { - byte[] result = new byte[(int)size]; - for (int i = 0; i < size; i++) { - result[i] = base.getJByteAt(offset + i); - } - return result; - } - - public byte[] orig() { - // fetch the orig MethodData data between header and dataSize - return fetchDataAt(getAddress(), 0, sizeofMethodDataOopDesc); - } - - public long[] data() { - // Read the data as an array of intptr_t elements - Address base = getAddress(); - long offset = data.getOffset(); - int elements = dataSize() / cellSize; - long[] result = new long[elements]; - for (int i = 0; i < elements; i++) { - Address value = base.getAddressAt(offset + i * MethodData.cellSize); - if (value != null) { - result[i] = value.minus(null); - } - } - return result; - } - - // Get a measure of how much mileage the method has on it. - int mileageOf(Method method) { - long mileage = 0; - long iic = method.interpreterInvocationCount(); - if (mileage < iic) mileage = iic; - - long ic = method.getInvocationCount(); - long bc = method.getBackedgeCount(); - - long icval = ic >> 3; - if ((ic & 4) != 0) icval += CompileThreshold; - if (mileage < icval) mileage = icval; - long bcval = bc >> 3; - if ((bc & 4) != 0) bcval += CompileThreshold; - if (mileage < bcval) mileage = bcval; - return (int)mileage; - } - - public int currentMileage() { - return 20000; - } - } diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MethodDataInterface.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MethodDataInterface.java deleted file mode 100644 index 8e6b131ee9d..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MethodDataInterface.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2014, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -public interface MethodDataInterface { - K getKlassAtAddress(Address addr); - M getMethodAtAddress(Address addr); - void printKlassValueOn(K klass, PrintStream st); - void printMethodValueOn(M klass, PrintStream st); -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MultiBranchData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MultiBranchData.java deleted file mode 100644 index 089de318adf..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/MultiBranchData.java +++ /dev/null @@ -1,113 +0,0 @@ -/* - * Copyright (c) 2011, 2022, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// MultiBranchData -// -// A MultiBranchData is used to access profiling information for -// a multi-way branch (*switch bytecodes). It consists of a series -// of (count, displacement) pairs, which count the number of times each -// case was taken and specify the data displacement for each branch target. -public class MultiBranchData extends ArrayData { - static final int defaultCountOffSet = 0; - static final int defaultDisaplacementOffSet = 1; - static final int caseArrayStart = 2; - static final int relativeCountOffSet = 0; - static final int relativeDisplacementOffSet = 1; - static final int perCaseCellCount = 2; - - public MultiBranchData(DataLayout layout) { - super(layout); - //assert(layout.tag() == DataLayout.multiBranchDataTag, "wrong type"); - } - - // static int computeCellCount(BytecodeStream stream); - - int numberOfCases() { - int alen = arrayLen() - 2; // get rid of default case here. - //assert(alen % perCaseCellCount == 0, "must be even"); - return (alen / perCaseCellCount); - } - - int defaultCount() { - return arrayUintAt(defaultCountOffSet); - } - int defaultDisplacement() { - return arrayIntAt(defaultDisaplacementOffSet); - } - - int countAt(int index) { - return arrayUintAt(caseArrayStart + - index * perCaseCellCount + - relativeCountOffSet); - } - int displacementAt(int index) { - return arrayIntAt(caseArrayStart + - index * perCaseCellCount + - relativeDisplacementOffSet); - } - - // Code generation support - static int defaultCountOffset() { - return arrayElementOffset(defaultCountOffSet); - } - static int defaultDisplacementOffset() { - return arrayElementOffset(defaultDisaplacementOffSet); - } - static int caseCountOffset(int index) { - return caseArrayOffset() + - (perCaseSize() * index) + - relativeCountOffset(); - } - static int caseArrayOffset() { - return arrayElementOffset(caseArrayStart); - } - static int perCaseSize() { - return (perCaseCellCount) * MethodData.cellSize; - } - static int relativeCountOffset() { - return (relativeCountOffSet) * MethodData.cellSize; - } - static int relativeDisplacementOffset() { - return (relativeDisplacementOffSet) * MethodData.cellSize; - } - - public void printDataOn(PrintStream st) { - printShared(st, "MultiBranchData"); - st.println("default_count(" + defaultCount() + ") displacement(" + defaultDisplacement() + ")"); - int cases = numberOfCases(); - for (int i = 0; i < cases; i++) { - tab(st); - st.println("count(" + countAt(i) + ") displacement(" + displacementAt(i) + ")"); - } - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ParametersTypeData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ParametersTypeData.java deleted file mode 100644 index d6ea749576a..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ParametersTypeData.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) 2014, 2021, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// ParametersTypeData -// -// A ParametersTypeData is used to access profiling information about -// types of parameters to a method -public class ParametersTypeData extends ArrayData { - final TypeStackSlotEntries parameters; - - static int stackSlotLocalOffset(int i) { - return arrayStartOffSet + TypeStackSlotEntries.stackSlotLocalOffset(i); - } - - static int typeLocalOffset(int i) { - return arrayStartOffSet + TypeStackSlotEntries.typeLocalOffset(i); - } - - public ParametersTypeData(MethodDataInterface methodData, DataLayout layout) { - super(layout); - parameters = new TypeStackSlotEntries(methodData, this, 1, numberOfParameters()); - } - - public int numberOfParameters() { - return arrayLen() / TypeStackSlotEntries.perArgCount(); - } - - int stackSlot(int i) { - return parameters.stackSlot(i); - } - - public K type(int i) { - return parameters.type(i); - } - - public static int typeIndex(int i) { - return typeLocalOffset(i); - } - - public void printDataOn(PrintStream st) { - st.print("parameter types"); - parameters.printDataOn(st); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ProfileData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ProfileData.java deleted file mode 100644 index 29a127b6a49..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ProfileData.java +++ /dev/null @@ -1,123 +0,0 @@ -/* - * Copyright (c) 2011, 2021, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -public abstract class ProfileData { - // This is a pointer to a section of profiling data. - private DataLayout _data; - - public DataLayout data() { return _data; } - - // How many cells are in this? - public abstract int cellCount(); - - - // Return the size of this data. - public int sizeInBytes() { - return DataLayout.computeSizeInBytes(cellCount()); - } - - public int dp() { - return data().dp(); - } - - // Low-level accessors for underlying data - long intptrAt(int index) { - //assert(0 <= index && index < cellCount(), "oob"); - return data().cellAt(index); - } - int intAt(int index) { - return (int)intptrAt(index); - } - int uintAt(int index) { - return (int)intptrAt(index); - } - public Address addressAt(int index) { - return data().addressAt(index); - } - - boolean flagAt(int flagNumber) { - return data().flagAt(flagNumber); - } - - // two convenient imports for use by subclasses: - public static int cellOffset(int index) { - return DataLayout.cellOffset(index); - } - - public ProfileData(DataLayout data) { - _data = data; - } - - // Constructor for invalid ProfileData. - ProfileData() { - _data = null; - } - - int bci() { - return data().bci(); - } - - int trapState() { - return data().trapState(); - } - public abstract void printDataOn(PrintStream st); - - void tab(PrintStream st) { - st.print("\t"); - } - - void printShared(PrintStream st, String name) { - st.print("bci: " + bci()); - // st.fillTo(tabWidthOne); - st.print(" " + name + " "); - tab(st); - int trap = trapState(); - if (trap != 0) { - st.print("trap(" + MethodData.formatTrapState(trap) + ") "); - } - int flags = data().flags(); - if (flags != 0) - st.print("flags(" + flags + ") "); - } - - public String toString() { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - PrintStream ps = new PrintStream(baos); - try { - printDataOn(ps); - } finally { - ps.close(); - } - return baos.toString(); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ReceiverTypeData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ReceiverTypeData.java deleted file mode 100644 index 758566c5611..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ReceiverTypeData.java +++ /dev/null @@ -1,132 +0,0 @@ -/* - * Copyright (c) 2011, 2016, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// ReceiverTypeData -// -// A ReceiverTypeData is used to access profiling information about a -// dynamic type check. It consists of a counter which counts the total times -// that the check is reached, and a series of (Klass, count) pairs -// which are used to store a type profile for the receiver of the check. -public class ReceiverTypeData extends CounterData { - static final int nonProfiledCountOffset = counterCellCount; - static final int receiver0Offset; - static final int count0Offset; - static final int receiverTypeRowCellCount; - static { - receiver0Offset = counterCellCount; - count0Offset = receiver0Offset + 1; - receiverTypeRowCellCount = (count0Offset + 1) - receiver0Offset; - } - final MethodDataInterface methodData; - - public ReceiverTypeData(MethodDataInterface methodData, DataLayout layout) { - super(layout); - this.methodData = methodData; - //assert(layout.tag() == DataLayout.receiverTypeDataTag || - // layout.tag() == DataLayout.virtualCallDataTag, "wrong type"); - } - - boolean isReceivertypedata() { return true; } - - static int staticCellCount() { - int cellCount = counterCellCount + MethodData.TypeProfileWidth * receiverTypeRowCellCount; - return cellCount; - } - - public int cellCount() { - return staticCellCount(); - } - - // Direct accessors - public static int rowLimit() { - return MethodData.TypeProfileWidth; - } - public static int receiverCellIndex(int row) { - return receiver0Offset + row * receiverTypeRowCellCount; - } - public static int receiverCountCellIndex(int row) { - return count0Offset + row * receiverTypeRowCellCount; - } - - // Get the receiver at row. The 'unchecked' version is needed by parallel old - // gc; it does not assert the receiver is a klass. During compaction of the - // perm gen, the klass may already have moved, so the isKlass() predicate - // would fail. The 'normal' version should be used whenever possible. - K receiverUnchecked(int row) { - //assert(row < rowLimit(), "oob"); - Address recv = addressAt(receiverCellIndex(row)); - return methodData.getKlassAtAddress(recv); - } - - public K receiver(int row) { - K recv = receiverUnchecked(row); - //assert(recv == NULL || ((oop)recv).isKlass(), "wrong type"); - return recv; - } - - public int receiverCount(int row) { - //assert(row < rowLimit(), "oob"); - return uintAt(receiverCountCellIndex(row)); - } - - // Code generation support - static int receiverOffset(int row) { - return cellOffset(receiverCellIndex(row)); - } - static int receiverCountOffset(int row) { - return cellOffset(receiverCountCellIndex(row)); - } - static int receiverTypeDataSize() { - return cellOffset(staticCellCount()); - } - - void printReceiverDataOn(PrintStream st) { - int row; - int entries = 0; - for (row = 0; row < rowLimit(); row++) { - if (receiver(row) != null) entries++; - } - st.println("count(" + count() + ") entries(" + entries + ")"); - for (row = 0; row < rowLimit(); row++) { - if (receiver(row) != null) { - tab(st); - methodData.printKlassValueOn(receiver(row), st); - st.println("(" + receiverCount(row) + ")"); - } - } - } - public void printDataOn(PrintStream st) { - printShared(st, "ReceiverTypeData"); - printReceiverDataOn(st); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/RetData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/RetData.java deleted file mode 100644 index 5ecd60bcb8e..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/RetData.java +++ /dev/null @@ -1,113 +0,0 @@ -/* - * Copyright (c) 2011, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// RetData -// -// A RetData is used to access profiling information for a ret bytecode. -// It is composed of a count of the number of times that the ret has -// been executed, followed by a series of triples of the form -// (bci, count, di) which count the number of times that some bci was the -// target of the ret and cache a corresponding data displacement. -public class RetData extends CounterData { - - static final int bci0Offset = counterCellCount; - static final int count0Offset = bci0Offset + 1; - static final int displacement0Offset = count0Offset + 1; - static final int retRowCellCount = (displacement0Offset + 1) - bci0Offset; - - public RetData(DataLayout layout) { - super(layout); - //assert(layout.tag() == DataLayout.retDataTag, "wrong type"); - } - - static final int noBci = -1; // value of bci when bci1/2 are not in use. - - static int staticCellCount() { - return counterCellCount + MethodData.BciProfileWidth * retRowCellCount; - } - - public int cellCount() { - return staticCellCount(); - } - - static int rowLimit() { - return MethodData.BciProfileWidth; - } - static int bciCellIndex(int row) { - return bci0Offset + row * retRowCellCount; - } - static int bciCountCellIndex(int row) { - return count0Offset + row * retRowCellCount; - } - static int bciDisplacementCellIndex(int row) { - return displacement0Offset + row * retRowCellCount; - } - - // Direct accessors - int bci(int row) { - return intAt(bciCellIndex(row)); - } - int bciCount(int row) { - return uintAt(bciCountCellIndex(row)); - } - int bciDisplacement(int row) { - return intAt(bciDisplacementCellIndex(row)); - } - - // Code generation support - static int bciOffset(int row) { - return cellOffset(bciCellIndex(row)); - } - static int bciCountOffset(int row) { - return cellOffset(bciCountCellIndex(row)); - } - static int bciDisplacementOffset(int row) { - return cellOffset(bciDisplacementCellIndex(row)); - } - - public void printDataOn(PrintStream st) { - printShared(st, "RetData"); - int row; - int entries = 0; - for (row = 0; row < rowLimit(); row++) { - if (bci(row) != noBci) entries++; - } - st.println("count(" + count() + ") entries(" + entries + ")"); - for (row = 0; row < rowLimit(); row++) { - if (bci(row) != noBci) { - tab(st); - st.println(" bci(" + bci(row) + ": count(" + bciCount(row) + ") displacement(" + bciDisplacement(row) + "))"); - } - } - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ReturnTypeEntry.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ReturnTypeEntry.java deleted file mode 100644 index 667e4cd4a94..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ReturnTypeEntry.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (c) 2014, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// Type entry used for return from a call. A single cell to record the -// type. -public class ReturnTypeEntry extends TypeEntries { - static final int cellCount = 1; - - ReturnTypeEntry(MethodDataInterface methodData, ProfileData pd, int baseOff) { - super(methodData, pd, baseOff); - } - - K type() { - return validKlass(baseOff); - } - - static int staticCellCount() { - return cellCount; - } - - int typeIndex() { - return baseOff; - } - - void printDataOn(PrintStream st) { - pd.tab(st); - printKlass(st, baseOff); - st.println(); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/SpeculativeTrapData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/SpeculativeTrapData.java deleted file mode 100644 index 76e531d1dea..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/SpeculativeTrapData.java +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2014, 2021, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// SpeculativeTrapData -// -// A SpeculativeTrapData is used to record traps due to type -// speculation. It records the root of the compilation. -public class SpeculativeTrapData extends ProfileData { - static final int speculativeTrapMethod = 0; - static final int speculativeTrapCellCount = 1; - final MethodDataInterface methodData; - - public SpeculativeTrapData(MethodDataInterface methodData, DataLayout layout) { - super(layout); - this.methodData = methodData; - } - - static int staticCellCount() { - return speculativeTrapCellCount; - } - - public int cellCount() { - return staticCellCount(); - } - - public M method() { - return methodData.getMethodAtAddress(addressAt(speculativeTrapMethod)); - } - - public static int methodIndex() { - return speculativeTrapMethod; - } - - public void printDataOn(PrintStream st) { - printShared(st, "SpeculativeTrapData"); - tab(st); - methodData.printMethodValueOn(method(), st); - st.println(); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeEntries.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeEntries.java deleted file mode 100644 index 16ba553a838..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeEntries.java +++ /dev/null @@ -1,97 +0,0 @@ -/* - * Copyright (c) 2014, 2021, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// Entries in a ProfileData object to record types: it can either be -// none (no profile), unknown (conflicting profile data) or a klass if -// a single one is seen. Whether a null reference was seen is also -// recorded. No counter is associated with the type and a single type -// is tracked (unlike VirtualCallData). -public abstract class TypeEntries { - static final int nullSeen = 1; - static final int typeMask = ~nullSeen; - static final int typeUnknown = 2; - static final int statusBits = nullSeen | typeUnknown; - static final int typeKlassMask = ~statusBits; - - final ProfileData pd; - final int baseOff; - final MethodDataInterface methodData; - - boolean wasNullSeen(int index) { - long v = pd.intptrAt(index); - return (v & nullSeen) != 0; - } - - boolean isTypeUnknown(int index) { - long v = pd.intptrAt(index); - return (v & typeUnknown) != 0; - } - - boolean isTypeNone(int index) { - long v = pd.intptrAt(index); - return (v & typeMask) == 0; - } - - K validKlass(int index) { - if (!isTypeNone(index) && - !isTypeUnknown(index)) { - return methodData.getKlassAtAddress(pd.addressAt(index).andWithMask(typeKlassMask)); - } else { - return null; - } - } - - void printKlass(PrintStream st, int index) { - if (isTypeNone(index)) { - st.print("none"); - } else if (isTypeUnknown(index)) { - st.print("unknown"); - } else { - methodData.printKlassValueOn(validKlass(index), st); - } - if (wasNullSeen(index)) { - st.print(" (null seen)"); - } - } - - TypeEntries(MethodDataInterface methodData, ProfileData pd, int baseOff) { - this.pd = pd; - this.baseOff = baseOff; - this.methodData = methodData; - } - - long intptrAt(int index) { - return pd.intptrAt(index); - } - -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeEntriesAtCall.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeEntriesAtCall.java deleted file mode 100644 index 2891f91c69e..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeEntriesAtCall.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) 2014, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// Entries to collect type information at a call: contains arguments -// (TypeStackSlotEntries), a return type (ReturnTypeEntry) and a -// number of cells. -public abstract class TypeEntriesAtCall { - - static int stackSlotLocalOffset(int i) { - return headerCellCount() + TypeStackSlotEntries.stackSlotLocalOffset(i); - } - - static int argumentTypeLocalOffset(int i) { - return headerCellCount() + TypeStackSlotEntries.typeLocalOffset(i); - } - - static int headerCellCount() { - return 1; - } - - static int cellCountLocalOffset() { - return 0; - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeStackSlotEntries.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeStackSlotEntries.java deleted file mode 100644 index 9efff34a4c3..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/TypeStackSlotEntries.java +++ /dev/null @@ -1,91 +0,0 @@ -/* - * Copyright (c) 2014, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// Type entries used for arguments passed at a call and parameters on -// method entry. 2 cells per entry: one for the type encoded as in -// TypeEntries and one initialized with the stack slot where the -// profiled object is to be found so that the interpreter can locate -// it quickly. -public class TypeStackSlotEntries extends TypeEntries { - static final int stackSlotEntry = 0; - static final int typeEntry = 1; - static final int perArgCellCount = 2; - - int stackSlotOffset(int i) { - return baseOff + stackSlotLocalOffset(i); - } - - final int numberOfEntries; - - int typeOffsetInCells(int i) { - return baseOff + typeLocalOffset(i); - } - - TypeStackSlotEntries(MethodDataInterface methodData, ProfileData pd, int baseOff, int nbEntries) { - super(methodData, pd, baseOff); - numberOfEntries = nbEntries; - } - - static int stackSlotLocalOffset(int i) { - return i * perArgCellCount + stackSlotEntry; - } - - static int typeLocalOffset(int i) { - return i * perArgCellCount + typeEntry; - } - - int stackSlot(int i) { - return pd.uintAt(stackSlotOffset(i)); - } - - K type(int i) { - return validKlass(typeOffsetInCells(i)); - } - - static int perArgCount() { - return perArgCellCount; - } - - int typeIndex(int i) { - return typeOffsetInCells(i); - } - - void printDataOn(PrintStream st) { - for (int i = 0; i < numberOfEntries; i++) { - pd.tab(st); - st.print(i + ": stack(" + stackSlot(i)+ ") "); - printKlass(st, typeOffsetInCells(i)); - st.println(); - } - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/VirtualCallData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/VirtualCallData.java deleted file mode 100644 index 2d303d8606d..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/VirtualCallData.java +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2011, 2016, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// VirtualCallData -// -// A VirtualCallData is used to access profiling information about a -// call. For now, it has nothing more than a ReceiverTypeData. -public class VirtualCallData extends ReceiverTypeData { - public VirtualCallData(MethodDataInterface methodData, DataLayout layout) { - super(methodData, layout); - //assert(layout.tag() == DataLayout.virtualCallDataTag, "wrong type"); - } - - static int staticCellCount() { - // At this point we could add more profile state, e.g., for arguments. - // But for now it's the same size as the base record type. - int cellCount = ReceiverTypeData.staticCellCount(); - return cellCount; - } - - public int cellCount() { - return staticCellCount(); - } - - // Direct accessors - static int virtualCallDataSize() { - return cellOffset(staticCellCount()); - } - - public void printDataOn(PrintStream st) { - printShared(st, "VirtualCallData"); - printReceiverDataOn(st); - } -} diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/VirtualCallTypeData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/VirtualCallTypeData.java deleted file mode 100644 index 483d0d54ee2..00000000000 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/VirtualCallTypeData.java +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright (c) 2014, 2020, 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. - * - */ - -package sun.jvm.hotspot.oops; - -import java.io.*; -import java.util.*; -import sun.jvm.hotspot.debugger.*; -import sun.jvm.hotspot.runtime.*; -import sun.jvm.hotspot.types.*; -import sun.jvm.hotspot.utilities.*; - -// VirtualCallTypeData -// -// A VirtualCallTypeData is used to access profiling information about -// a virtual call for which we collect type information about -// arguments and return value. -public class VirtualCallTypeData extends VirtualCallData implements CallTypeDataInterface { - final TypeStackSlotEntries args; - final ReturnTypeEntry ret; - - int cellCountGlobalOffset() { - return VirtualCallData.staticCellCount() + TypeEntriesAtCall.cellCountLocalOffset(); - } - - int cellCountNoHeader() { - return uintAt(cellCountGlobalOffset()); - } - - public VirtualCallTypeData(MethodDataInterface methodData, DataLayout layout) { - super(methodData, layout); - args = new TypeStackSlotEntries(methodData, this, VirtualCallData.staticCellCount()+TypeEntriesAtCall.headerCellCount(), numberOfArguments()); - ret = new ReturnTypeEntry(methodData, this, cellCount() - ReturnTypeEntry.staticCellCount()); - } - - static int staticCellCount() { - return -1; - } - - public int cellCount() { - return VirtualCallData.staticCellCount() + - TypeEntriesAtCall.headerCellCount() + - intAt(cellCountGlobalOffset()); - } - - public int numberOfArguments() { - return cellCountNoHeader() / TypeStackSlotEntries.perArgCount(); - } - - public boolean hasArguments() { - return cellCountNoHeader() >= TypeStackSlotEntries.perArgCount(); - } - - public K argumentType(int i) { - return args.type(i); - } - - public boolean hasReturn() { - return (cellCountNoHeader() % TypeStackSlotEntries.perArgCount()) != 0; - } - - public K returnType() { - return ret.type(); - } - - public int argumentTypeIndex(int i) { - return args.typeIndex(i); - } - - public int returnTypeIndex() { - return ret.typeIndex(); - } - - public void printDataOn(PrintStream st) { - super.printDataOn(st); - if (hasArguments()) { - tab(st); - st.print("argument types"); - args.printDataOn(st); - } - if (hasReturn()) { - tab(st); - st.print("return type"); - ret.printDataOn(st); - } - } -}; diff --git a/test/hotspot/jtreg/serviceability/sa/ClhsdbCDSCore.java b/test/hotspot/jtreg/serviceability/sa/ClhsdbCDSCore.java index 53370fc09d6..aa3b19c4fcf 100644 --- a/test/hotspot/jtreg/serviceability/sa/ClhsdbCDSCore.java +++ b/test/hotspot/jtreg/serviceability/sa/ClhsdbCDSCore.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 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 @@ -24,7 +24,7 @@ /** * @test * @bug 8174994 8200613 - * @summary Test the clhsdb commands 'printmdo', 'printall', 'jstack' on a CDS enabled corefile. + * @summary Test the clhsdb commands 'printall', 'jstack' on a CDS enabled corefile. * @requires vm.cds * @requires vm.hasSA * @requires vm.flavor == "server" @@ -124,24 +124,10 @@ public class ClhsdbCDSCore { throw new SkippedException("The CDS archive is not mapped"); } - List testJavaOpts = Arrays.asList(Utils.getTestJavaOpts()); - - if (testJavaOpts.contains("-XX:TieredStopAtLevel=1")) { - // No MDOs are allocated in -XX:TieredStopAtLevel=1 - // The reason is methods being compiled aren't hot enough - // Let's not call printmdo in such scenario - cmds = List.of("printall", "jstack -v"); - } else { - cmds = List.of("printmdo -a", "printall", "jstack -v"); - } + cmds = List.of("printall", "jstack -v"); Map> expStrMap = new HashMap<>(); Map> unExpStrMap = new HashMap<>(); - expStrMap.put("printmdo -a", List.of( - "CounterData", - "BranchData")); - unExpStrMap.put("printmdo -a", List.of( - "No suitable match for type of address")); expStrMap.put("printall", List.of( "aload_0", "_nofast_aload_0", diff --git a/test/hotspot/jtreg/serviceability/sa/TestPrintMdo.java b/test/hotspot/jtreg/serviceability/sa/TestPrintMdo.java deleted file mode 100644 index 7292d797740..00000000000 --- a/test/hotspot/jtreg/serviceability/sa/TestPrintMdo.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (c) 2017, 2025, 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 java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.HashMap; -import jdk.test.lib.apps.LingeredApp; -import jdk.test.lib.Utils; -import jtreg.SkippedException; - -/** - * @test - * @library /test/lib - * @requires vm.hasSA - * @requires (os.arch != "riscv64" | !(vm.cpu.features ~= ".*qemu.*")) - * @requires vm.flavor == "server" & !vm.emulatedClient & !(vm.opt.TieredStopAtLevel == 1) - * @run main/othervm TestPrintMdo - */ - -public class TestPrintMdo { - - public static void main (String... args) throws Exception { - System.out.println("Starting TestPrintMdo test"); - LingeredApp app = null; - try { - ClhsdbLauncher test = new ClhsdbLauncher(); - app = LingeredApp.startApp("-XX:+ProfileInterpreter", "-XX:CompileThreshold=100"); - System.out.println ("Started LingeredApp with pid " + app.getPid()); - List cmds = List.of("printmdo -a"); - - Map> expStrMap = new HashMap<>(); - Map> unExpStrMap = new HashMap<>(); - expStrMap.put("printmdo -a", List.of( - "VirtualCallData", - "CounterData", - "bci", - "MethodData", - "java/lang/Object")); - unExpStrMap.put("printmdo -a", List.of( - "missing reason for ")); - test.run(app.getPid(), cmds, expStrMap, unExpStrMap); - } catch (SkippedException se) { - throw se; - } catch (Exception ex) { - throw new RuntimeException("Test ERROR " + ex, ex); - } finally { - LingeredApp.stopApp(app); - } - - System.out.println("Test PASSED"); - } -} From 9b44ea39bf07b1d76e5bf9ebddbcae6bfc93e357 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Thu, 19 Feb 2026 17:58:36 +0000 Subject: [PATCH 07/63] 8378204: Remove AppContext from two Swing UI classes Reviewed-by: serb, kizune --- .../java/swing/plaf/motif/MotifRadioButtonUI.java | 13 ++----------- .../javax/swing/plaf/metal/MetalLabelUI.java | 3 +-- .../classes/sun/awt/im/InputMethodManager.java | 1 - 3 files changed, 3 insertions(+), 14 deletions(-) diff --git a/src/java.desktop/share/classes/com/sun/java/swing/plaf/motif/MotifRadioButtonUI.java b/src/java.desktop/share/classes/com/sun/java/swing/plaf/motif/MotifRadioButtonUI.java index f9a1dd7bb50..d78bcb13577 100644 --- a/src/java.desktop/share/classes/com/sun/java/swing/plaf/motif/MotifRadioButtonUI.java +++ b/src/java.desktop/share/classes/com/sun/java/swing/plaf/motif/MotifRadioButtonUI.java @@ -36,8 +36,6 @@ import javax.swing.UIManager; import javax.swing.plaf.ComponentUI; import javax.swing.plaf.basic.BasicRadioButtonUI; -import sun.awt.AppContext; - /** * RadioButtonUI implementation for MotifRadioButtonUI * @@ -45,7 +43,7 @@ import sun.awt.AppContext; */ public class MotifRadioButtonUI extends BasicRadioButtonUI { - private static final Object MOTIF_RADIO_BUTTON_UI_KEY = new Object(); + private static final ComponentUI UI = new MotifRadioButtonUI(); protected Color focusColor; @@ -55,14 +53,7 @@ public class MotifRadioButtonUI extends BasicRadioButtonUI { // Create PLAF // ******************************** public static ComponentUI createUI(JComponent c) { - AppContext appContext = AppContext.getAppContext(); - MotifRadioButtonUI motifRadioButtonUI = - (MotifRadioButtonUI) appContext.get(MOTIF_RADIO_BUTTON_UI_KEY); - if (motifRadioButtonUI == null) { - motifRadioButtonUI = new MotifRadioButtonUI(); - appContext.put(MOTIF_RADIO_BUTTON_UI_KEY, motifRadioButtonUI); - } - return motifRadioButtonUI; + return UI; } // ******************************** diff --git a/src/java.desktop/share/classes/javax/swing/plaf/metal/MetalLabelUI.java b/src/java.desktop/share/classes/javax/swing/plaf/metal/MetalLabelUI.java index 35fc07de056..1d131c9d294 100644 --- a/src/java.desktop/share/classes/javax/swing/plaf/metal/MetalLabelUI.java +++ b/src/java.desktop/share/classes/javax/swing/plaf/metal/MetalLabelUI.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 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 @@ -26,7 +26,6 @@ package javax.swing.plaf.metal; import sun.swing.SwingUtilities2; -import sun.awt.AppContext; import javax.swing.*; import javax.swing.plaf.*; diff --git a/src/java.desktop/share/classes/sun/awt/im/InputMethodManager.java b/src/java.desktop/share/classes/sun/awt/im/InputMethodManager.java index 0da7dbed6ea..c3968f19b60 100644 --- a/src/java.desktop/share/classes/sun/awt/im/InputMethodManager.java +++ b/src/java.desktop/share/classes/sun/awt/im/InputMethodManager.java @@ -35,7 +35,6 @@ import java.awt.PopupMenu; import java.awt.Menu; import java.awt.MenuItem; import java.awt.Toolkit; -import sun.awt.AppContext; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.InvocationEvent; From 2a71f89bc8d72be8095113695e541f4f38acdeca Mon Sep 17 00:00:00 2001 From: Phil Race Date: Thu, 19 Feb 2026 18:04:06 +0000 Subject: [PATCH 08/63] 8378192: Remove AppContext from SwingUtilities2 Reviewed-by: psadhukhan, kizune --- .../share/classes/sun/swing/SwingUtilities2.java | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/src/java.desktop/share/classes/sun/swing/SwingUtilities2.java b/src/java.desktop/share/classes/sun/swing/SwingUtilities2.java index 58a0f28bb02..d552bc5c9f2 100644 --- a/src/java.desktop/share/classes/sun/swing/SwingUtilities2.java +++ b/src/java.desktop/share/classes/sun/swing/SwingUtilities2.java @@ -92,7 +92,6 @@ import javax.swing.tree.TreeModel; import javax.swing.tree.TreePath; import sun.awt.AWTAccessor; -import sun.awt.AppContext; import sun.awt.SunToolkit; import sun.font.FontDesignMetrics; import sun.font.FontUtilities; @@ -1241,7 +1240,7 @@ public class SwingUtilities2 { return null; } - private static final Object APP_CONTEXT_FRC_CACHE_KEY = new Object(); + private static final Map cache = new HashMap<>(); private static FontRenderContext getFRCFromCache(AffineTransform tx, Object aaHint) { @@ -1249,15 +1248,6 @@ public class SwingUtilities2 { return null; } - @SuppressWarnings("unchecked") - Map cache = (Map) - AppContext.getAppContext().get(APP_CONTEXT_FRC_CACHE_KEY); - - if (cache == null) { - cache = new HashMap<>(); - AppContext.getAppContext().put(APP_CONTEXT_FRC_CACHE_KEY, cache); - } - Object key = (tx == null) ? aaHint : (aaHint == null ? tx : new KeyPair(tx, aaHint)); From ff1c42f111c57837ed1da37bb30a50a5b4df03ff Mon Sep 17 00:00:00 2001 From: Coleen Phillimore Date: Thu, 19 Feb 2026 22:17:41 +0000 Subject: [PATCH 09/63] 8378112: Test runtime/ErrorHandling/MachCodeFramesInErrorFile.java fails with RuntimeException: 1 < 2 Reviewed-by: phubner, matsaave --- .../runtime/ErrorHandling/MachCodeFramesInErrorFile.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/hotspot/jtreg/runtime/ErrorHandling/MachCodeFramesInErrorFile.java b/test/hotspot/jtreg/runtime/ErrorHandling/MachCodeFramesInErrorFile.java index ba36d5810d8..7608c5f5619 100644 --- a/test/hotspot/jtreg/runtime/ErrorHandling/MachCodeFramesInErrorFile.java +++ b/test/hotspot/jtreg/runtime/ErrorHandling/MachCodeFramesInErrorFile.java @@ -169,6 +169,10 @@ public class MachCodeFramesInErrorFile { Matcher matcher = Pattern.compile("\\[MachCode\\]\\s*\\[Verified Entry Point\\]\\s* # \\{method\\} \\{[^}]*\\} '([^']+)' '([^']+)' in '([^']+)'", Pattern.DOTALL).matcher(hsErr); List machCodeHeaders = matcher.results().map(mr -> String.format("'%s' '%s' in '%s'", mr.group(1), mr.group(2), mr.group(3))).collect(Collectors.toList()); int minExpectedMachCodeSections = Math.max(1, compiledJavaFrames); + if ((hsErr.contains("stop reattempt (retry printing native stack (no source info))") || hsErr.contains("reason: Step time limit reached"))) { + // In this case, the vm only prints the crashing frame. + minExpectedMachCodeSections = 1; + } if (machCodeHeaders.size() < minExpectedMachCodeSections) { Asserts.fail(machCodeHeaders.size() + " < " + minExpectedMachCodeSections); } From e42508fc1c6a2cfddcee5dc7dea70a8e95ae9be4 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Thu, 19 Feb 2026 23:44:14 +0000 Subject: [PATCH 10/63] 8378203: Remove AppContext from jdk.unsupported.desktop Reviewed-by: kizune, serb --- .../classes/jdk/swing/interop/SwingInterOpUtils.java | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/jdk.unsupported.desktop/share/classes/jdk/swing/interop/SwingInterOpUtils.java b/src/jdk.unsupported.desktop/share/classes/jdk/swing/interop/SwingInterOpUtils.java index 589744641e4..aaed4d3e048 100644 --- a/src/jdk.unsupported.desktop/share/classes/jdk/swing/interop/SwingInterOpUtils.java +++ b/src/jdk.unsupported.desktop/share/classes/jdk/swing/interop/SwingInterOpUtils.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 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 @@ -29,7 +29,6 @@ import java.awt.Toolkit; import java.awt.Window; import java.awt.AWTEvent; import sun.awt.SunToolkit; -import sun.awt.AppContext; import sun.awt.UngrabEvent; /** @@ -47,10 +46,7 @@ public class SwingInterOpUtils { public SwingInterOpUtils() {} public static void postEvent(Object target, java.awt.AWTEvent e) { - AppContext context = SunToolkit.targetToAppContext(target); - if (context != null) { - SunToolkit.postEvent(context, e); - } + SunToolkit.postEvent(e); } public static void grab(Toolkit toolkit, Window window) { From 1a967a0bca116513be07129885b93a41c40a22a6 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Thu, 19 Feb 2026 23:46:05 +0000 Subject: [PATCH 11/63] 8378193: Remove AppContext from JinternalFrame Reviewed-by: kizune, serb --- .../classes/javax/swing/JInternalFrame.java | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/src/java.desktop/share/classes/javax/swing/JInternalFrame.java b/src/java.desktop/share/classes/javax/swing/JInternalFrame.java index 9611f991025..f3295cd6ad8 100644 --- a/src/java.desktop/share/classes/javax/swing/JInternalFrame.java +++ b/src/java.desktop/share/classes/javax/swing/JInternalFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 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 @@ -54,7 +54,6 @@ import javax.swing.event.InternalFrameListener; import javax.swing.plaf.DesktopIconUI; import javax.swing.plaf.InternalFrameUI; -import sun.awt.AppContext; import sun.swing.SwingUtilities2; /** @@ -237,17 +236,13 @@ public class JInternalFrame extends JComponent implements /** Constrained property name indicating that the internal frame is iconified. */ public static final String IS_ICON_PROPERTY = "icon"; - private static final Object PROPERTY_CHANGE_LISTENER_KEY = - new StringBuilder("InternalFramePropertyChangeListener"); + private static PropertyChangeListener focusListener; private static void addPropertyChangeListenerIfNecessary() { - if (AppContext.getAppContext().get(PROPERTY_CHANGE_LISTENER_KEY) == - null) { - PropertyChangeListener focusListener = - new FocusPropertyChangeListener(); - - AppContext.getAppContext().put(PROPERTY_CHANGE_LISTENER_KEY, - focusListener); + synchronized (JInternalFrame.class) { + if (focusListener == null) { + focusListener = new FocusPropertyChangeListener(); + } KeyboardFocusManager.getCurrentKeyboardFocusManager(). addPropertyChangeListener(focusListener); From 866cbcbecb02bf9d7bbc37941a503cc968f34428 Mon Sep 17 00:00:00 2001 From: Sergey Bylokhov Date: Fri, 20 Feb 2026 00:58:51 +0000 Subject: [PATCH 12/63] 8378050: Add missing @Override annotations in "java.awt.color" package Reviewed-by: kizune, prr --- .../share/classes/java/awt/color/ICC_ColorSpace.java | 8 +++++++- .../share/classes/java/awt/color/ICC_ProfileGray.java | 3 ++- .../share/classes/java/awt/color/ICC_ProfileRGB.java | 5 ++++- 3 files changed, 13 insertions(+), 3 deletions(-) diff --git a/src/java.desktop/share/classes/java/awt/color/ICC_ColorSpace.java b/src/java.desktop/share/classes/java/awt/color/ICC_ColorSpace.java index f4a39c43e04..89cde4b0ef0 100644 --- a/src/java.desktop/share/classes/java/awt/color/ICC_ColorSpace.java +++ b/src/java.desktop/share/classes/java/awt/color/ICC_ColorSpace.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 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 @@ -200,6 +200,7 @@ public class ICC_ColorSpace extends ColorSpace { * the number of components in this {@code ColorSpace} * @throws NullPointerException if {@code colorvalue} is {@code null} */ + @Override public float[] toRGB(float[] colorvalue) { if (this2srgb == null) { synchronized (this) { @@ -249,6 +250,7 @@ public class ICC_ColorSpace extends ColorSpace { * @throws ArrayIndexOutOfBoundsException if array length is not at least 3 * @throws NullPointerException if {@code rgbvalue} is {@code null} */ + @Override public float[] fromRGB(float[] rgbvalue) { if (srgb2this == null) { synchronized (this) { @@ -378,6 +380,7 @@ public class ICC_ColorSpace extends ColorSpace { * the number of components in this {@code ColorSpace} * @throws NullPointerException if {@code colorvalue} is {@code null} */ + @Override public float[] toCIEXYZ(float[] colorvalue) { if (this2xyz == null) { synchronized (this) { @@ -510,6 +513,7 @@ public class ICC_ColorSpace extends ColorSpace { * @throws ArrayIndexOutOfBoundsException if array length is not at least 3 * @throws NullPointerException if {@code colorvalue} is {@code null} */ + @Override public float[] fromCIEXYZ(float[] colorvalue) { if (xyz2this == null) { synchronized (this) { @@ -560,6 +564,7 @@ public class ICC_ColorSpace extends ColorSpace { * than {@code numComponents - 1} * @since 1.4 */ + @Override public float getMinValue(int component) { rangeCheck(component); return minVal[component]; @@ -583,6 +588,7 @@ public class ICC_ColorSpace extends ColorSpace { * than {@code numComponents - 1} * @since 1.4 */ + @Override public float getMaxValue(int component) { rangeCheck(component); return maxVal[component]; diff --git a/src/java.desktop/share/classes/java/awt/color/ICC_ProfileGray.java b/src/java.desktop/share/classes/java/awt/color/ICC_ProfileGray.java index f8de7d1581d..85b4b28b487 100644 --- a/src/java.desktop/share/classes/java/awt/color/ICC_ProfileGray.java +++ b/src/java.desktop/share/classes/java/awt/color/ICC_ProfileGray.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 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 @@ -100,6 +100,7 @@ public final class ICC_ProfileGray extends ICC_Profile { * @return an array containing the components of the mediaWhitePointTag in * the ICC profile */ + @Override public float[] getMediaWhitePoint() { return super.getMediaWhitePoint(); } diff --git a/src/java.desktop/share/classes/java/awt/color/ICC_ProfileRGB.java b/src/java.desktop/share/classes/java/awt/color/ICC_ProfileRGB.java index 1c7fab265ac..9069c898261 100644 --- a/src/java.desktop/share/classes/java/awt/color/ICC_ProfileRGB.java +++ b/src/java.desktop/share/classes/java/awt/color/ICC_ProfileRGB.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 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 @@ -135,6 +135,7 @@ public final class ICC_ProfileRGB extends ICC_Profile { * @return a 3-element {@code float} array containing the x, y, and z * components of the profile's {@code mediaWhitePointTag} */ + @Override public float[] getMediaWhitePoint() { return super.getMediaWhitePoint(); } @@ -186,6 +187,7 @@ public final class ICC_ProfileRGB extends ICC_Profile { * @throws ProfileDataException if the profile does not specify the * corresponding TRC as a single gamma value */ + @Override public float getGamma(int component) { return super.getGamma(toTag(component)); } @@ -218,6 +220,7 @@ public final class ICC_ProfileRGB extends ICC_Profile { * @throws ProfileDataException if the profile does not specify the * corresponding TRC as a table */ + @Override public short[] getTRC(int component) { return super.getTRC(toTag(component)); } From 1df05943885fd83989b62bd460ed1aaeb4f284fc Mon Sep 17 00:00:00 2001 From: Roger Calnan Date: Fri, 20 Feb 2026 03:52:56 +0000 Subject: [PATCH 13/63] 8377502: Add anchors to the options in the Serviceability tool man pages Reviewed-by: dholmes, cjplummer --- src/jdk.hotspot.agent/share/man/jhsdb.md | 30 ++++++++++++------------ src/jdk.jcmd/share/man/jmap.md | 8 +++---- src/jdk.jcmd/share/man/jstat.md | 28 +++++++++++----------- src/jdk.jdi/share/man/jdb.md | 24 +++++++++---------- 4 files changed, 45 insertions(+), 45 deletions(-) diff --git a/src/jdk.hotspot.agent/share/man/jhsdb.md b/src/jdk.hotspot.agent/share/man/jhsdb.md index 4c6be775ece..f329a2fea6f 100644 --- a/src/jdk.hotspot.agent/share/man/jhsdb.md +++ b/src/jdk.hotspot.agent/share/man/jhsdb.md @@ -119,20 +119,20 @@ The `jhsdb` tool can be launched in any one of the following modes: ## Options for the debugd Mode -`--serverid` *server-id* +[`--serverid`]{#debugd-option--serverid} *server-id* : An optional unique ID for this debug server. This is required if multiple debug servers are run on the same machine. -`--rmiport` *port* +[`--rmiport`]{#debugd-option--rmiport} *port* : Sets the port number to which the RMI connector is bound. If not specified a random available port is used. -`--registryport` *port* +[`--registryport`]{#debugd-option--registryport} *port* : Sets the RMI registry port. This option overrides the system property 'sun.jvm.hotspot.rmi.port'. If not specified, the system property is used. If the system property is not set, the default port 1099 is used. -`--hostname` *hostname* +[`--hostname`]{#debugd-option--hostname} *hostname* : Sets the hostname the RMI connector is bound. The value could be a hostname or an IPv4/IPv6 address. This option overrides the system property 'java.rmi.server.hostname'. If not specified, the system property is used. @@ -140,10 +140,10 @@ The `jhsdb` tool can be launched in any one of the following modes: ## Options for the jinfo Mode -`--flags` +[`--flags`]{#jinfo-option--flags} : Prints the VM flags. -`--sysprops` +[`--sysprops`]{#jinfo-option--sysprops} : Prints the Java system properties. no option @@ -154,33 +154,33 @@ no option no option : Prints the same information as Solaris `pmap`. -`--heap` +[`--heap`]{#jmap-option--heap} : Prints the `java` heap summary. -`--binaryheap` +[`--binaryheap`]{#jmap-option--binaryheap} : Dumps the `java` heap in `hprof` binary format. -`--dumpfile` *name* +[`--dumpfile`]{#jmap-option--dumpfile} *name* : The name of the dumpfile. -`--histo` +[`--histo`]{#jmap-option--histo} : Prints the histogram of `java` object heap. -`--clstats` +[`--clstats`]{#jmap-option--clstats} : Prints the class loader statistics. -`--finalizerinfo` +[`--finalizerinfo`]{#jmap-option--finalizerinfo} : Prints the information on objects awaiting finalization. ## Options for the jstack Mode -`--locks` +[`--locks`]{#jstack-option--locks} : Prints the `java.util.concurrent` locks information. -`--mixed` +[`--mixed`]{#jstack-option--mixed} : Attempts to print both `java` and native frames if the platform allows it. ## Options for the jsnap Mode -`--all` +[`--all`]{#jsnap-option--all} : Prints all performance counters. diff --git a/src/jdk.jcmd/share/man/jmap.md b/src/jdk.jcmd/share/man/jmap.md index b0352ad9194..dd0be1b24ef 100644 --- a/src/jdk.jcmd/share/man/jmap.md +++ b/src/jdk.jcmd/share/man/jmap.md @@ -62,20 +62,20 @@ was produced. ## Options for the jmap Command -`-clstats` *pid* +[`-clstats`]{#option-clstats} *pid* : Connects to a running process and prints class loader statistics of Java heap. -`-finalizerinfo` *pid* +[`-finalizerinfo`]{#option-finalizerinfo} *pid* : Connects to a running process and prints information on objects awaiting finalization. -`-histo`\[`:live`\] *pid* +[`-histo`]{#option-histo}\[`:live`\] *pid* : Connects to a running process and prints a histogram of the Java object heap. If the `live` suboption is specified, it then counts only live objects. -`-dump:`*dump\_options* *pid* +[`-dump:`]{#option-dump_}*dump\_options* *pid* : Connects to a running process and dumps the Java heap. The *dump\_options* include: diff --git a/src/jdk.jcmd/share/man/jstat.md b/src/jdk.jcmd/share/man/jstat.md index 324d0a48cb2..624b675de76 100644 --- a/src/jdk.jcmd/share/man/jstat.md +++ b/src/jdk.jcmd/share/man/jstat.md @@ -125,7 +125,7 @@ Don't write scripts to parse the `jstat` command's output because the format might change in future releases. If you write scripts that parse the `jstat` command output, then expect to modify them for future releases of this tool. -`-statOption` +[`-statOption`]{#option-statOption} : Determines the statistics information that the `jstat` command displays. The following lists the available options. Use the `-options` general option to display the list of options for a particular platform @@ -161,7 +161,7 @@ command output, then expect to modify them for future releases of this tool. `printcompilation`: Displays Java HotSpot VM compilation method statistics. -`-J`*javaOption* +[`-J`]{#option-J}*javaOption* : Passes *javaOption* to the Java application launcher. For example, `-J-Xms48m` sets the startup memory to 48 MB. For a complete list of options, see [java](java.html). @@ -171,7 +171,7 @@ command output, then expect to modify them for future releases of this tool. The following information summarizes the columns that the `jstat` command outputs for each *statOption*. -`-class` *option* +[`-class`]{#option-class} *option* : Class loader statistics. `Loaded`: Number of classes loaded. @@ -184,7 +184,7 @@ outputs for each *statOption*. `Time`: Time spent performing class loading and unloading operations. -`-compiler` *option* +[`-compiler`]{#option-compiler} *option* : Java HotSpot VM Just-in-Time compiler statistics. `Compiled`: Number of compilation tasks performed. @@ -199,7 +199,7 @@ outputs for each *statOption*. `FailedMethod`: Class name and method of the last failed compilation. -`-gc` *option* +[`-gc`]{#option-gc} *option* : Garbage collected heap statistics. `S0C`: Current survivor space 0 capacity (KB). @@ -236,7 +236,7 @@ outputs for each *statOption*. `GCT`: Total garbage collection time. -`-gccapacity` *option* +[`-gccapacity`]{#option-gccapacity} *option* : Memory pool generation and space capacities. `NGCMN`: Minimum new generation capacity (KB). @@ -275,7 +275,7 @@ outputs for each *statOption*. `FGC`: Number of full GC events. -`-gccause` *option* +[`-gccause`]{#option-gccause} *option* : This option displays the same summary of garbage collection statistics as the `-gcutil` option, but includes the causes of the last garbage collection event and (when applicable), the current garbage collection @@ -286,7 +286,7 @@ outputs for each *statOption*. `GCC`: Cause of current garbage collection -`-gcnew` *option* +[`-gcnew`]{#option-gcnew} *option* : New generation statistics. `S0C`: Current survivor space 0 capacity (KB). @@ -311,7 +311,7 @@ outputs for each *statOption*. `YGCT`: Young generation garbage collection time. -`-gcnewcapacity` *option* +[`-gcnewcapacity`]{#option-gcnewcapacity} *option* : New generation space size statistics. `NGCMN`: Minimum new generation capacity (KB). @@ -336,7 +336,7 @@ outputs for each *statOption*. `FGC`: Number of full GC events. -`-gcold` *option* +[`-gcold`]{#option-gcold} *option* : Old generation size statistics. `MC`: Metaspace Committed Size (KB). @@ -359,7 +359,7 @@ outputs for each *statOption*. `GCT`: Total garbage collection time. -`-gcoldcapacity` *option* +[`-gcoldcapacity`]{#option-gcoldcapacity} *option* : Old generation statistics. `OGCMN`: Minimum old generation capacity (KB). @@ -378,7 +378,7 @@ outputs for each *statOption*. `GCT`: Total garbage collection time. -`-gcmetacapacity` *option* +[`-gcmetacapacity`]{#option-gcmetacapacity} *option* : Metaspace size statistics. `MCMN`: Minimum metaspace capacity (KB). @@ -399,7 +399,7 @@ outputs for each *statOption*. `GCT`: Total garbage collection time. -`-gcutil` *option* +[`-gcutil`]{#option-gcutil} *option* : Summary of garbage collection statistics. `S0`: Survivor space 0 utilization as a percentage of the space's current @@ -427,7 +427,7 @@ outputs for each *statOption*. `GCT`: Total garbage collection time. -`-printcompilation` *option* +[`-printcompilation`]{#option-printcompilation} *option* : Java HotSpot VM compiler method statistics. `Compiled`: Number of compilation tasks performed by the most recently diff --git a/src/jdk.jdi/share/man/jdb.md b/src/jdk.jdi/share/man/jdb.md index 75d2d9a150c..8aabb202c80 100644 --- a/src/jdk.jdi/share/man/jdb.md +++ b/src/jdk.jdi/share/man/jdb.md @@ -145,50 +145,50 @@ The following options are accepted by the `jdb` command: `-help` : Displays a help message. -`-sourcepath` *dir1*`:`*dir2*`:`... +[`-sourcepath`]{#option-sourcepath} *dir1*`:`*dir2*`:`... : Uses the specified path to search for source files in the specified path. If this option is not specified, then use the default path of dot (`.`). -`-attach` *address* +[`-attach`]{#option-attach} *address* : Attaches the debugger to a running JVM with the default connection mechanism. -`-listen` *address* +[`-listen`]{#option-listen} *address* : Waits for a running JVM to connect to the specified address with a standard connector. -`-listenany` +[`-listenany`]{#option-listenany} : Waits for a running JVM to connect at any available address using a standard connector. -`-launch` +[`-launch`]{#option-launch} : Starts the debugged application immediately upon startup of the `jdb` command. The `-launch` option removes the need for the `run` command. The debugged application is launched and then stopped just before the initial application class is loaded. At that point, you can set any necessary breakpoints and use the `cont` command to continue execution. -`-listconnectors` +[`-listconnectors`]{#option-listconnectors} : Lists the connectors available in this JVM. -`-connect` *connector-name*`:`*name1*`=`*value1*.... +[`-connect`]{#option-connect} *connector-name*`:`*name1*`=`*value1*.... : Connects to the target JVM with the named connector and listed argument values. -`-dbgtrace` \[*flags*\] +[`-dbgtrace`]{#option-dbgtrace} \[*flags*\] : Prints information for debugging the `jdb` command. -`-tclient` +[`-tclient`]{#option-tclient} : Runs the application in the Java HotSpot VM client. -`-trackallthreads` +[`-trackallthreads`]{#option-trackallthreads} : Track all threads as they are created, including virtual threads. See [Working With Virtual Threads](#working-with-virtual-threads) below. -`-tserver` +[`-tserver`]{#option-tserver} : Runs the application in the Java HotSpot VM server. -`-J`*option* +[`-J`]{#option-J}*option* : Passes *option* to the JDB JVM, where option is one of the options described on the reference page for the Java application launcher. For example, `-J-Xms48m` sets the startup memory to 48 MB. See *Overview of Java From f0529a854215f325ac67082a44c0aaacc1505c87 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Fri, 20 Feb 2026 06:48:58 +0000 Subject: [PATCH 14/63] 8378080: Zero: JNIEnv argument is corrupted in native calls Reviewed-by: mdoerr, serb, phh --- src/hotspot/cpu/zero/zeroInterpreter_zero.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/hotspot/cpu/zero/zeroInterpreter_zero.cpp b/src/hotspot/cpu/zero/zeroInterpreter_zero.cpp index 28c2364315e..1b20761f6e4 100644 --- a/src/hotspot/cpu/zero/zeroInterpreter_zero.cpp +++ b/src/hotspot/cpu/zero/zeroInterpreter_zero.cpp @@ -368,12 +368,15 @@ int ZeroInterpreter::native_entry(Method* method, intptr_t UNUSED, TRAPS) { goto unlock_unwind_and_return; void **arguments; - void *mirror; { + // These locals must remain on stack until call completes + void *mirror; + void *env; + { arguments = (void **) stack->alloc(handler->argument_count() * sizeof(void **)); void **dst = arguments; - void *env = thread->jni_environment(); + env = thread->jni_environment(); *(dst++) = &env; if (method->is_static()) { From f49c6d8777c8083d122a61ba3bd359cf9826cb0b Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Fri, 20 Feb 2026 06:49:15 +0000 Subject: [PATCH 15/63] 8377990: Zero: Replace Java math ops with UB-safe implementations Reviewed-by: aph, serb, phh --- .../zero/bytecodeInterpreter_zero.inline.hpp | 33 ++++++++++--------- src/hotspot/share/sanitizers/ub.hpp | 5 +-- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/src/hotspot/cpu/zero/bytecodeInterpreter_zero.inline.hpp b/src/hotspot/cpu/zero/bytecodeInterpreter_zero.inline.hpp index 4d813cd53c6..4c73368b673 100644 --- a/src/hotspot/cpu/zero/bytecodeInterpreter_zero.inline.hpp +++ b/src/hotspot/cpu/zero/bytecodeInterpreter_zero.inline.hpp @@ -26,6 +26,8 @@ #ifndef CPU_ZERO_BYTECODEINTERPRETER_ZERO_INLINE_HPP #define CPU_ZERO_BYTECODEINTERPRETER_ZERO_INLINE_HPP +#include "sanitizers/ub.hpp" + // Inline interpreter functions for zero inline jfloat BytecodeInterpreter::VMfloatAdd(jfloat op1, jfloat op2) { @@ -40,6 +42,7 @@ inline jfloat BytecodeInterpreter::VMfloatMul(jfloat op1, jfloat op2) { return op1 * op2; } +ATTRIBUTE_NO_UBSAN // IEEE-754 division by zero is well-defined inline jfloat BytecodeInterpreter::VMfloatDiv(jfloat op1, jfloat op2) { return op1 / op2; } @@ -68,7 +71,7 @@ inline void BytecodeInterpreter::VMmemCopy64(uint32_t to[2], } inline jlong BytecodeInterpreter::VMlongAdd(jlong op1, jlong op2) { - return op1 + op2; + return java_add(op1, op2); } inline jlong BytecodeInterpreter::VMlongAnd(jlong op1, jlong op2) { @@ -82,7 +85,7 @@ inline jlong BytecodeInterpreter::VMlongDiv(jlong op1, jlong op2) { } inline jlong BytecodeInterpreter::VMlongMul(jlong op1, jlong op2) { - return op1 * op2; + return java_multiply(op1, op2); } inline jlong BytecodeInterpreter::VMlongOr(jlong op1, jlong op2) { @@ -90,7 +93,7 @@ inline jlong BytecodeInterpreter::VMlongOr(jlong op1, jlong op2) { } inline jlong BytecodeInterpreter::VMlongSub(jlong op1, jlong op2) { - return op1 - op2; + return java_subtract(op1, op2); } inline jlong BytecodeInterpreter::VMlongXor(jlong op1, jlong op2) { @@ -104,19 +107,19 @@ inline jlong BytecodeInterpreter::VMlongRem(jlong op1, jlong op2) { } inline jlong BytecodeInterpreter::VMlongUshr(jlong op1, jint op2) { - return ((unsigned long long) op1) >> (op2 & 0x3F); + return java_shift_right_unsigned(op1, op2); } inline jlong BytecodeInterpreter::VMlongShr(jlong op1, jint op2) { - return op1 >> (op2 & 0x3F); + return java_shift_right(op1, op2); } inline jlong BytecodeInterpreter::VMlongShl(jlong op1, jint op2) { - return op1 << (op2 & 0x3F); + return java_shift_left(op1, op2); } inline jlong BytecodeInterpreter::VMlongNeg(jlong op) { - return -op; + return java_negate(op); } inline jlong BytecodeInterpreter::VMlongNot(jlong op) { @@ -183,8 +186,8 @@ inline jdouble BytecodeInterpreter::VMdoubleAdd(jdouble op1, jdouble op2) { return op1 + op2; } +ATTRIBUTE_NO_UBSAN // IEEE-754 division by zero is well-defined inline jdouble BytecodeInterpreter::VMdoubleDiv(jdouble op1, jdouble op2) { - // Divide by zero... QQQ return op1 / op2; } @@ -228,7 +231,7 @@ inline jdouble BytecodeInterpreter::VMfloat2Double(jfloat op) { // Integer Arithmetic inline jint BytecodeInterpreter::VMintAdd(jint op1, jint op2) { - return op1 + op2; + return java_add(op1, op2); } inline jint BytecodeInterpreter::VMintAnd(jint op1, jint op2) { @@ -242,11 +245,11 @@ inline jint BytecodeInterpreter::VMintDiv(jint op1, jint op2) { } inline jint BytecodeInterpreter::VMintMul(jint op1, jint op2) { - return op1 * op2; + return java_multiply(op1, op2); } inline jint BytecodeInterpreter::VMintNeg(jint op) { - return -op; + return java_negate(op); } inline jint BytecodeInterpreter::VMintOr(jint op1, jint op2) { @@ -260,19 +263,19 @@ inline jint BytecodeInterpreter::VMintRem(jint op1, jint op2) { } inline jint BytecodeInterpreter::VMintShl(jint op1, jint op2) { - return op1 << (op2 & 0x1F); + return java_shift_left(op1, op2); } inline jint BytecodeInterpreter::VMintShr(jint op1, jint op2) { - return op1 >> (op2 & 0x1F); + return java_shift_right(op1, op2); } inline jint BytecodeInterpreter::VMintSub(jint op1, jint op2) { - return op1 - op2; + return java_subtract(op1, op2); } inline juint BytecodeInterpreter::VMintUshr(jint op1, jint op2) { - return ((juint) op1) >> (op2 & 0x1F); + return java_shift_right_unsigned(op1, op2); } inline jint BytecodeInterpreter::VMintXor(jint op1, jint op2) { diff --git a/src/hotspot/share/sanitizers/ub.hpp b/src/hotspot/share/sanitizers/ub.hpp index d5901f6821c..8a6bfa50f51 100644 --- a/src/hotspot/share/sanitizers/ub.hpp +++ b/src/hotspot/share/sanitizers/ub.hpp @@ -33,12 +33,9 @@ // Useful if the function or method is known to do something special or even 'dangerous', for // example causing desired signals/crashes. #ifdef UNDEFINED_BEHAVIOR_SANITIZER -#if defined(__clang__) +#if defined(__clang__) || defined(__GNUC__) #define ATTRIBUTE_NO_UBSAN __attribute__((no_sanitize("undefined","float-divide-by-zero"))) #endif -#if defined(__GNUC__) && !defined(__clang__) -#define ATTRIBUTE_NO_UBSAN __attribute__((no_sanitize("undefined"))) -#endif #endif #ifndef ATTRIBUTE_NO_UBSAN From cb70654943695049e75743ee957c7c51ac33ffdc Mon Sep 17 00:00:00 2001 From: SendaoYan Date: Fri, 20 Feb 2026 08:25:42 +0000 Subject: [PATCH 16/63] 8377949: TestZRelocationSetEvent.java intermittent fails OOME Reviewed-by: stefank, mgronlun --- .../jdk/jfr/event/gc/detailed/TestZRelocationSetEvent.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/test/jdk/jdk/jfr/event/gc/detailed/TestZRelocationSetEvent.java b/test/jdk/jdk/jfr/event/gc/detailed/TestZRelocationSetEvent.java index e64d6f83ab8..6217de6e235 100644 --- a/test/jdk/jdk/jfr/event/gc/detailed/TestZRelocationSetEvent.java +++ b/test/jdk/jdk/jfr/event/gc/detailed/TestZRelocationSetEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 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 @@ -25,7 +25,6 @@ package jdk.jfr.event.gc.detailed; import java.util.List; -import static gc.testlibrary.Allocation.blackHole; import jdk.jfr.Recording; import jdk.jfr.consumer.RecordedEvent; import jdk.test.lib.jfr.EventNames; @@ -36,7 +35,7 @@ import jdk.test.lib.jfr.Events; * @requires vm.hasJFR & vm.gc.Z * @requires vm.flagless * @library /test/lib /test/jdk /test/hotspot/jtreg - * @run main/othervm -XX:+UseZGC -Xmx32M jdk.jfr.event.gc.detailed.TestZRelocationSetEvent + * @run main/othervm -XX:+UseZGC -Xmx64M jdk.jfr.event.gc.detailed.TestZRelocationSetEvent */ public class TestZRelocationSetEvent { From fa2f4d82f5337afab2291e4757387e4bc328265d Mon Sep 17 00:00:00 2001 From: Anton Artemov Date: Fri, 20 Feb 2026 08:31:18 +0000 Subject: [PATCH 17/63] 8377223: Port fdlibm atanh to Java Reviewed-by: darcy, rgiulietti --- .../share/classes/java/lang/FdLibm.java | 48 +++ .../share/classes/java/lang/Math.java | 34 +- .../share/classes/java/lang/StrictMath.java | 36 +- test/jdk/java/lang/Math/HyperbolicTests.java | 386 +++++++++++++++++- .../java/lang/StrictMath/ExhaustingTests.java | 1 + .../java/lang/StrictMath/FdlibmTranslit.java | 50 +++ .../java/lang/StrictMath/HyperbolicTests.java | 102 ++++- 7 files changed, 651 insertions(+), 6 deletions(-) diff --git a/src/java.base/share/classes/java/lang/FdLibm.java b/src/java.base/share/classes/java/lang/FdLibm.java index 8e75f8f6994..5a6bdc9b94e 100644 --- a/src/java.base/share/classes/java/lang/FdLibm.java +++ b/src/java.base/share/classes/java/lang/FdLibm.java @@ -3607,4 +3607,52 @@ final class FdLibm { } } } + + /** + * Return the Inverse Hyperbolic Tangent of x + * Method : + * + * + * atanh(x) is defined so that atanh(tanh(alpha)) = alpha, -∞ < alpha < ∞ + * and tanh(atanh(x)) = x, -1 < x < 1; + * It can be written as atanh(x) = 0.5 * log1p(2 * x/(1-x)), -1 < x < 1; + * 1. + * atanh(x) := 0.5 * log1p(2 * x/(1 - x)), if |x| >= 0.5, + * := 0.5 * log1p(2x + 2x * x/(1 - x)), if |x| < 0.5. + * + * + * + * Special cases: + * only atanh(±0)=±0 is exact for finite x. + * atanh(NaN) is NaN + * atanh(±1) is ±∞ + */ + static final class Atanh { + + static double compute(double x) { + double t; + int hx,ix; + int lx; // unsigned + hx = __HI(x); // high word + lx = __LO(x); // low word + ix = hx & 0x7fff_ffff; + if ((ix | ((lx | (-lx)) >>> 31)) > 0x3ff0_0000) { // |x| > 1 + return (x - x) / (x - x); + } + if (ix == 0x3ff0_0000) { + return x / 0.0; + } + if (ix < 0x3e30_0000 && (HUGE + x) > 0.0) { + return x; // x<2**-28 + } + x = __HI(x, ix); // x <- |x| + if (ix < 0x3fe0_0000) { // x < 0.5 + t = x + x; + t = 0.5 * Log1p.compute(t + t * x / (1.0 - x)); + } else { + t = 0.5 * Log1p.compute((x + x) / (1.0 - x)); + } + return hx >= 0 ? t : -t; + } + } } diff --git a/src/java.base/share/classes/java/lang/Math.java b/src/java.base/share/classes/java/lang/Math.java index 4f729fe82cb..38a5328fa0b 100644 --- a/src/java.base/share/classes/java/lang/Math.java +++ b/src/java.base/share/classes/java/lang/Math.java @@ -109,7 +109,7 @@ import static java.lang.Double.*; * acos acos}, {@link atan atan}, {@link exp exp}, {@link expm1 * expm1}, {@link log log}, {@link log10 log10}, {@link log1p log1p}, * {@link sinh sinh}, {@link cosh cosh}, {@link tanh tanh}, {@link asinh asinh}, - * {@link acosh acosh}, {@link hypot hypot}, and {@link pow pow}. + * {@link acosh acosh}, {@link atanh atanh}, {@link hypot hypot}, and {@link pow pow}. * (The {@link sqrt sqrt} operation is a required part of IEEE 754 * from a different section of the standard.) The special case behavior * of the recommended operations generally follows the guidance of the IEEE 754 @@ -2814,6 +2814,38 @@ public final class Math { return StrictMath.acosh(x); } + /** + * Returns the inverse hyperbolic tangent of a {@code double} value. + * The inverse hyperbolic tangent of x is defined to be the function such that + * atanh({@linkplain Math#tanh tanh(x)}) = x for any x. + * Note that the domain of the exact atanh is (-1; 1), the range is unrestricted. + * + *

    Special cases: + *

      + * + *
    • If the argument is NaN, then the result is NaN. + * + *
    • If the argument is zero, then the result is a zero with the + * same sign as the argument. + * + *
    • If the argument is {@code +1.0}, then the result is + * positive infinity. + * + *
    • If the argument is {@code -1.0}, then the result is + * negative infinity. + * + *
    • If the argument is greater than {@code 1.0} in magnitude, then the result is NaN. + * + *
    + *

    The computed result must be within 2.5 ulps of the exact result. + * @param x The number whose inverse hyperbolic tangent is to be returned. + * @return The inverse hyperbolic tangent of {@code x}. + * @since 27 + */ + public static double atanh(double x) { + return StrictMath.atanh(x); + } + /** * Returns sqrt(x2 +y2) * without intermediate overflow or underflow. diff --git a/src/java.base/share/classes/java/lang/StrictMath.java b/src/java.base/share/classes/java/lang/StrictMath.java index 9421b41620b..a8f67ef58ba 100644 --- a/src/java.base/share/classes/java/lang/StrictMath.java +++ b/src/java.base/share/classes/java/lang/StrictMath.java @@ -76,8 +76,8 @@ import jdk.internal.vm.annotation.IntrinsicCandidate; * {@code exp}, {@code log}, {@code log10}, * {@code cbrt}, {@code atan2}, {@code pow}, * {@code sinh}, {@code cosh}, {@code tanh}, - * {@code asinh}, {@code acosh}, {@code hypot}, - * {@code expm1}, and {@code log1p}. + * {@code asinh}, {@code acosh},{@code atanh}, + * {@code hypot}, {@code expm1}, and {@code log1p}. * *

    * The platform uses signed two's complement integer arithmetic with @@ -2222,6 +2222,38 @@ public final class StrictMath { return FdLibm.Acosh.compute(x); } + /** + * Returns the inverse hyperbolic tangent of a {@code double} value. + * The inverse hyperbolic tangent of x is defined to be the function such that + * atanh({@linkplain Math#tanh tanh(x)}) = x for any x. + * Note that the domain of the exact atanh is (-1; 1), the range is unrestricted. + * + *

    Special cases: + *

      + * + *
    • If the argument is NaN, then the result is NaN. + * + *
    • If the argument is zero, then the result is a zero with the + * same sign as the argument. + * + *
    • If the argument is {@code +1.0}, then the result is + * positive infinity. + * + *
    • If the argument is {@code -1.0}, then the result is + * negative infinity. + * + *
    • If the argument is greater than {@code 1.0} in magnitude, then the result is NaN. + * + *
    + * + * @param x The number whose inverse hyperbolic tangent is to be returned. + * @return The inverse hyperbolic tangent of {@code x}. + * @since 27 + */ + public static double atanh(double x) { + return FdLibm.Atanh.compute(x); + } + /** * Returns sqrt(x2 +y2) * without intermediate overflow or underflow. diff --git a/test/jdk/java/lang/Math/HyperbolicTests.java b/test/jdk/java/lang/Math/HyperbolicTests.java index ef37a102847..ac5526c1953 100644 --- a/test/jdk/java/lang/Math/HyperbolicTests.java +++ b/test/jdk/java/lang/Math/HyperbolicTests.java @@ -27,7 +27,7 @@ * @build Tests * @build HyperbolicTests * @run main HyperbolicTests - * @summary Tests for {Math, StrictMath}.{sinh, cosh, tanh, asinh, acosh} + * @summary Tests for {Math, StrictMath}.{sinh, cosh, tanh, asinh, acosh, atanh} */ import static java.lang.Double.longBitsToDouble; @@ -45,6 +45,7 @@ public class HyperbolicTests { failures += testTanh(); failures += testAsinh(); failures += testAcosh(); + failures += testAtanh(); if (failures > 0) { System.err.println("Testing the hyperbolic functions incurred " @@ -2101,4 +2102,387 @@ public class HyperbolicTests { failures += Tests.testUlpDiffWithAbsBound("StrictMath.acosh", input, StrictMath::acosh, expected, ulps, Double.POSITIVE_INFINITY); return failures; } + + /** + * Test accuracy of {Math, StrictMath}.atanh. The specified + * accuracy is 2.5 ulps. + * + * The defintion of atanh(x) is + * + * atanh(tanh(x)) = x + * + * Can be also written as + * + * 0.5 * log1p(2 * x / (1-x0)) + * + * Taylor expansion: + * + * x + x^3 / 3 + x^5 / 5 + ... + * + * Therefore, + * + * 1. For small values of x, tanh(x) ~= x. + * + * Additionally, atanh is an odd function; atanh(-x) = -atanh(x). + * + */ + static int testAtanh() { + int failures = 0; + /* + * Array elements below generated using a quad atanh + * implementation. Rounded to a double, the quad result + * *should* be correctly rounded, unless we are quite unlucky. + * Assuming the quad value is a correctly rounded double, the + * allowed error is 3.0 ulps instead of 2.5 since the quad + * value rounded to double can have its own 1/2 ulp error. + */ + double [][] testCases = { + // x atanh(x) + {+0.00000000000000000000000000000000000e+00 , +0.00000000000000000000000000000000000e+00 }, + {+2.00000000000000004163336342344337027e-02 , +2.00026673068495811335374182828113576e-02 }, + {+4.00000000000000008326672684688674053e-02 , +4.00213538367682137458906520059156020e-02 }, + {+5.99999999999999977795539507496869192e-02 , +6.00721559210316214332906986486015264e-02 }, + {+8.00000000000000016653345369377348106e-02 , +8.01713250375896933655527689248809233e-02 }, + {+1.00000000000000005551115123125782702e-01 , +1.00335347731075586242913545116385118e-01 }, + {+1.20000000000000009436895709313830594e-01 , +1.20581028408444044805093075807633198e-01 }, + {+1.40000000000000013322676295501878485e-01 , +1.40925576070493877554736186975308236e-01 }, + {+1.60000000000000003330669073875469621e-01 , +1.61386696131525518759511362898215609e-01 }, + {+1.79999999999999993338661852249060757e-01 , +1.81982688600705816490251036770517457e-01 }, + {+1.99999999999999983346654630622651894e-01 , +2.02732554054082173641771797964103718e-01 }, + {+2.19999999999999973354647408996243030e-01 , +2.23656109021832382650747515743625830e-01 }, + {+2.39999999999999963362640187369834166e-01 , +2.44774112659352854083413297101694196e-01 }, + {+2.59999999999999953370632965743425302e-01 , +2.66108406873654071753827618842061943e-01 }, + {+2.79999999999999971134201359745929949e-01 , +2.87682072451780896117822911968144088e-01 }, + {+2.99999999999999988897769753748434596e-01 , +3.09519604203111703273814331202206426e-01 }, + {+3.20000000000000006661338147750939243e-01 , +3.31647108705132085025104001081840030e-01 }, + {+3.40000000000000024424906541753443889e-01 , +3.54092528962242939723929765493171945e-01 }, + {+3.60000000000000042188474935755948536e-01 , +3.76885901188190124469133896689497444e-01 }, + {+3.80000000000000059952043329758453183e-01 , +4.00059650056056638206593741845596981e-01 }, + {+4.00000000000000077715611723760957830e-01 , +4.23648930193601899373639138690042112e-01 }, + {+4.20000000000000095479180117763462476e-01 , +4.47692023527420813002158901561072580e-01 }, + {+4.40000000000000113242748511765967123e-01 , +4.72230804420425833981180600242988051e-01 }, + {+4.60000000000000131006316905768471770e-01 , +4.97311287572031193620508878977899997e-01 }, + {+4.80000000000000148769885299770976417e-01 , +5.22984277591344047465367134186014130e-01 }, + {+5.00000000000000111022302462515654042e-01 , +5.49306144334054993727359235148812474e-01 }, + {+5.20000000000000128785870856518158689e-01 , +5.76339754969192906113997153691857594e-01 }, + {+5.40000000000000146549439250520663336e-01 , +6.04155602962267286054127265014583953e-01 }, + {+5.60000000000000164313007644523167983e-01 , +6.32833186665638181077146946128475799e-01 }, + {+5.80000000000000182076576038525672629e-01 , +6.62462707371799523213172030295196960e-01 }, + {+6.00000000000000199840144432528177276e-01 , +6.93147180559945621667457797283512021e-01 }, + {+6.20000000000000217603712826530681923e-01 , +7.25005087752999506268291290927001216e-01 }, + {+6.40000000000000235367281220533186570e-01 , +7.58173744684044609195455590065769225e-01 }, + {+6.60000000000000253130849614535691217e-01 , +7.92813631870191370108450047457113058e-01 }, + {+6.80000000000000270894418008538195863e-01 , +8.29114038301766692728933700083100051e-01 }, + {+7.00000000000000288657986402540700510e-01 , +8.67300527694053760423196460163172710e-01 }, + {+7.20000000000000306421554796543205157e-01 , +9.07644983319125195441126107009775370e-01 }, + {+7.40000000000000324185123190545709804e-01 , +9.50479380596524207852088721432242171e-01 }, + {+7.60000000000000341948691584548214450e-01 , +9.96215082345103890579587353760865510e-01 }, + {+7.80000000000000359712259978550719097e-01 , +1.04537054846688556569856922586455819e+00 }, + {+8.00000000000000377475828372553223744e-01 , +1.09861228866811073993921293846013796e+00 }, + {+8.20000000000000395239396766555728391e-01 , +1.15681746459031653565363995495937725e+00 }, + {+8.40000000000000413002965160558233038e-01 , +1.22117351768460359355809310163905228e+00 }, + {+8.60000000000000430766533554560737684e-01 , +1.29334467204897297035888921761818841e+00 }, + {+8.80000000000000448530101948563242331e-01 , +1.37576765652097643587819823310934128e+00 }, + {+9.00000000000000466293670342565746978e-01 , +1.47221948958322268418172604524275263e+00 }, + {+9.20000000000000484057238736568251625e-01 , +1.58902691517397596123778549185721945e+00 }, + {+9.40000000000000501820807130570756271e-01 , +1.73804934491764087653605718356588900e+00 }, + {+9.60000000000000519584375524573260918e-01 , +1.94591014905531993245708137324632564e+00 }, + {+9.80000000000000537347943918575765565e-01 , +2.29755992506730853281874022244325249e+00 }, + }; + + for(double [] testCase : testCases) { + failures += testAtanhCaseWithUlpDiff(testCase[0], + testCase[1], + 3.0); + } + + for(double nan : Tests.NaNs) { + failures += testAtanhCaseWithUlpDiff(nan, NaNd, 0); + } + + double [][] specialTestCases = { + {0.0, 0.0}, + {-0.0, -0.0}, + {1.0, Double.POSITIVE_INFINITY}, + {-1.0, Double.NEGATIVE_INFINITY}, + {2.0, NaNd}, + {-2.0, NaNd}, + }; + + for(double [] specialTestCase : specialTestCases) { + failures += testAtanhCaseWithUlpDiff(specialTestCase[0], + specialTestCase[1], + 0.0); + } + + // For powers of 2 less than 2^(-27), the second and + // subsequent terms of the Taylor series expansion will get + // rounded away since |n-n^3| > 53, the binary precision of a + // double significand. + + for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) { + double d = Math.scalb(2.0, i); + + // Result and expected are the same. + failures += testAtanhCaseWithUlpDiff(d, d, 2.5); + } + + failures += testAtanhAdditionalTests(); + + return failures; + } + + /** + * Test accuracy of {Math, StrictMath}.tanh using quad precision + * tanh implementation as the reference. There are additional tests. + * The specified accuracy is 2.5 ulps. + * + */ + static int testAtanhAdditionalTests() { + int failures = 0; + /* + * Array elements below are generated using a quad precision tanh + * implementation (libquadmath). Rounded to a double, the quad result + * *should* be correctly rounded, unless we are quite unlucky. + * Assuming the quad value is a correctly rounded double, the + * allowed error is 3.0 ulps instead of 2.5 since the quad + * value rounded to double can have its own 1/2 ulp error. + */ + double[][] testCases = { + // x atanh(x) + {+9.39017107929201566562937841808889061e-01 , +1.72967155564501022599234830162276798e+00 }, + {+4.56590977869321346105380143853835762e-01 , +4.92995868916526654745557405930485720e-01 }, + {-6.57855028101722583144805867050308734e-01 , -7.89022676186288902931611202476188124e-01 }, + {+4.62405425240985490376033339998684824e-01 , +5.00366606474614321339885208418466006e-01 }, + {-9.83365261789753697385663144814316183e-01 , -2.39052856803141716223262787771779768e+00 }, + {-6.27582201138608741786129030515439808e-01 , -7.37417270574716377975381198846020522e-01 }, + {-9.83196938676588638728048863413278013e-01 , -2.38545217282555498582477166161511345e+00 }, + {+7.36681396907350904967870519612915814e-01 , +9.43183305171108845024940622694003154e-01 }, + {-7.68733978209885648880117514636367559e-01 , -1.01722532284268312448347897782273734e+00 }, + {-8.99650279001481090190850409271661192e-01 , -1.47038189478731874369381319202006168e+00 }, + {+6.23383381659472490810003364458680153e-02 , +6.24192773197774301522605242534216118e-02 }, + {-8.14139384718910008587045012973248959e-01 , -1.13918472673420532816505691112579313e+00 }, + {-4.89518635342238050967011986358556896e-01 , -5.35427075187260852558782518094419668e-01 }, + {-6.08295892536873550326959048106800765e-01 , -7.06211859359034873213744847874549993e-01 }, + {+9.36079053287340978606323460553539917e-01 , +1.70538649403259128938060088254525967e+00 }, + {+8.31593360663532843446432707423809916e-01 , +1.19328001443669418326658153597705593e+00 }, + {+6.56422583223821076714443734090309590e-01 , +7.86501511439435312578862353672697253e-01 }, + {-3.45789522181036979020518629113212228e-01 , -3.60653496973375779632391162421477716e-01 }, + {+5.32079052777165939502879155043046921e-01 , +5.93040792269778100045583612458499490e-01 }, + {-3.36182931512335247958844774984754622e-01 , -3.49782828626977949006925091676664461e-01 }, + {+6.13630231412017335124176042882027104e-01 , +7.14723430606319696079463920489037224e-01 }, + {+7.39217182016670415478643008100334555e-01 , +9.48751224833067617682882507817093541e-01 }, + {-7.64409441646018983362864673836156726e-03 , -7.64424330871250337925427639013540391e-03 }, + {-9.74816033382744917545892349153291434e-01 , -2.18101148933100542106171185218910695e+00 }, + {+5.52687515297161868765840608830330893e-01 , +6.22242584006598996817110126253907160e-01 }, + {+9.93416759200363430615254856093088165e-01 , +2.85653913150680081054657418761203993e+00 }, + {+9.07659865436335255850508474395610392e-01 , +1.51407684709244159021847264731507603e+00 }, + {+6.60272764758356833780794659105595201e-01 , +7.93297068812459385386864151954890303e-01 }, + {+9.63130814953695568725322573300218210e-01 , +1.98745986190671136058731587311090272e+00 }, + {-5.70877067883640121337407435930799693e-01 , -6.48822975697686437517619163352737241e-01 }, + {-8.11543971448019485492864077968988568e-01 , -1.13153503707350652581786706338031953e+00 }, + {+6.25363929368137561048968109389534220e-01 , +7.33765974893577300297563917687072047e-01 }, + {-2.98846490310910706256208868580870330e-01 , -3.08252492314447063039336121789383998e-01 }, + {-5.97049745291272859759601487894542515e-01 , -6.88550090030688204308547683807415861e-01 }, + {+8.32383827085564576009346637874841690e-01 , +1.19584817769769645815260824209818595e+00 }, + {-6.63715390745103883674005373904947191e-01 , -7.99425357382537999237287552090479860e-01 }, + {-3.94238412786191538828006741823628545e-01 , -4.16808558150307726736043589182851417e-01 }, + {-9.76759747274416945117536670295521617e-01 , -2.22166424268955747060822814557733573e+00 }, + {+8.57442746954987455865193624049425125e-01 , +1.28360612935435243492898897724236702e+00 }, + {-4.24565955117479187919116156990639865e-01 , -4.53248918353154620159372526887584647e-01 }, + {+3.42862260746481295470289296645205468e-01 , +3.57332492545316699435359810051341636e-01 }, + {+9.34459049867542246303742103918921202e-01 , +1.69245393271799745831802454769856267e+00 }, + {+7.64520478549035598092586951679550111e-01 , +1.00700514849153029184678063244721996e+00 }, + {-9.63864704576277597780631367641035467e-01 , -1.99769974929677935746994673118167405e+00 }, + {-1.63366842704400605512660149543080479e-01 , -1.64843919557971079920329622870569601e-01 }, + {+9.94878693411232140064726081618573517e-01 , +2.98246446127683966842287869896800818e+00 }, + {+7.97196021651951247655176757689332590e-01 , +1.09087153746565597453258159715989760e+00 }, + {+8.42371664350162419054868223611265421e-01 , +1.22928450632196951329839160548759750e+00 }, + {+6.96520087724423975217291626904625446e-01 , +8.60509501716176099565750762116593117e-01 }, + {+2.01836732473232416396058397367596626e-01 , +2.04646551779576522368238234135183581e-01 }, + {+5.05939365449320055390103334502782673e-01 , +5.57256946951148119219566387597645954e-01 }, + {-6.01430574320412913991162895399611443e-01 , -6.95385458565007214254554832195678104e-01 }, + {-4.47649318961238940062230540206655860e-01 , -4.81756612137591759595253632500957881e-01 }, + {+3.37215361458020113083478008775273338e-01 , +3.50947266793232870614512911957588554e-01 }, + {+5.14125575037364890285118690371746197e-01 , +5.68321583728012649428480801619053327e-01 }, + {-2.15214858343344861424384362180717289e-01 , -2.18633101430445893274568498462426012e-01 }, + {-9.20630621904034773805847180483397096e-01 , -1.59314811621779716899638118653946385e+00 }, + {+9.19047868224296293782060729427030310e-01 , +1.58286321290197920098639225270320808e+00 }, + {-2.90913484009795997309311132994480431e-01 , -2.99563914714840125917110413508169726e-01 }, + {+3.17993101000002553746526245959103107e-03 , +3.17994172851141737533171613593260162e-03 }, + {-7.16021961571153608971940229821484536e-01 , -8.99433586194582637259073931486986768e-01 }, + {+9.92926371376932737078391255636233836e-01 , +2.82049289268529672262432232518141968e+00 }, + {-7.42199723778889541847547661745920777e-01 , -9.55359320438959545982214260560204172e-01 }, + {+4.01228574786033020949105321051320061e-01 , +4.25112376436892578257996500834612471e-01 }, + {-4.41626489426403034954660142830107361e-01 , -4.74249574732580717257665801841627296e-01 }, + {-7.21334187852223251979921769816428423e-01 , -9.10420850885118135075313207007968241e-01 }, + {+2.82138790772897052328005429444601759e-01 , +2.90004322151609047453793285881602424e-01 }, + {+9.42986643599090679224161704041762277e-01 , +1.76434800601646585550841462860153977e+00 }, + {-5.29497382099672897481923428131267428e-01 , -5.89446464446382266025999977702386855e-01 }, + {+8.90579204675862490248050562513526529e-01 , +1.42471878072594370872155352848645131e+00 }, + {+7.91047774827229877026013582508312538e-01 , +1.07422521925289214702426279427778303e+00 }, + {+4.75836513423619322793456376530230045e-01 , +5.17588301409701923326927500834908347e-01 }, + {+9.32576831661000027473562568047782406e-01 , +1.67781041728427657120484424620161805e+00 }, + {+4.49528137196881449888508086587535217e-01 , +4.84108758524071045231641283604748208e-01 }, + {-6.26946229789648867836149292998015881e-01 , -7.36368746336877301544734566556181860e-01 }, + {+9.58777722962137812778848910966189578e-01 , +1.93054856596755898497650787204101231e+00 }, + {-9.52075725696122754371231167169753462e-01 , -1.85351320681716370080636444991087747e+00 }, + {+9.66628065084665144546249848644947633e-01 , +2.03818021917486263862909093415522483e+00 }, + {-9.90577960901121823411585864960215986e-01 , -2.67656438907628996596144534201915287e+00 }, + {-4.29129153811968588883019037893973291e-01 , -4.58828779570547333956754968138122237e-01 }, + {+9.21075240738198020018501210870454088e-01 , +1.59607267263080478465215862819487820e+00 }, + {-3.36155477527195101217216688382904977e-01 , -3.49751876782073295503516199927519371e-01 }, + {-4.48919523178084922676589485490694642e-01 , -4.83346273396370947315596684554195125e-01 }, + {-7.74714213440744980943009068141691387e-01 , -1.03201246185914269057125935805127686e+00 }, + {-9.33695607057150489538344118045642972e-01 , -1.68646605985566878841417421790327581e+00 }, + {-9.70495709947644780157816057908348739e-01 , -2.10075237060881671900628221642575807e+00 }, + {-9.36541591900329706277261720970273018e-01 , -1.70913713792726775520494333833202263e+00 }, + {+7.37812568478896091406227242259774357e-02 , +7.39155762025176670781318988781666040e-02 }, + {-5.04698425671640915624038825626485050e-01 , -5.55590478683141718256493322563558866e-01 }, + {+8.86920594265426132096763467416167259e-01 , +1.40730559326330763357753153399607213e+00 }, + {-5.34965721339583311078058613929897547e-01 , -5.97076103988724933820435448973192479e-01 }, + {-5.04547440425485049786402669269591570e-01 , -5.55387910636784813509136387661093775e-01 }, + {+6.29048733546408000982808061962714419e-01 , +7.39840413838973059800583747029269377e-01 }, + {-9.78682200705922600292296920088119805e-01 , -2.26532198777189725437096465346095003e+00 }, + {+2.38919916302204882185833412222564220e-03 , +2.38920370910435739436106539813089152e-03 }, + {+9.39119411473845255855508185049984604e-01 , +1.73053742845170764254605902984133442e+00 }, + {-6.12092729070447649775132958893664181e-01 , -7.12261063519474464072359286081706738e-01 }, + {-4.28286500855559193468025114270858467e-01 , -4.57796381674494452786278030205231882e-01 }, + {-3.27343597141078301859806742868386209e-01 , -3.39850137417994572135528032299471827e-01 }, + {+8.67784128381645536443045330088352785e-01 , +1.32403603565363914121499259355873480e+00 }, + {+7.52660015475228982850808279181364924e-01 , +9.79063037984556159433073554464697266e-01 }, + {+7.94013223397652012636172003112733364e-01 , +1.08219921900739052536746217766952318e+00 }, + {+7.09905313419819106179886603058548644e-01 , +8.86992950278189161084285873777251874e-01 }, + {-1.98448575704946783559989853529259562e-01 , -2.01117007840272246446085014680650093e-01 }, + {-5.42433878231522781376838793221395463e-01 , -6.07597742754044712584754611484481699e-01 }, + {-7.54416871023775081894768845813814551e-01 , -9.83128156322049799142775913826928208e-01 }, + {+3.79392548957375952412007791281212121e-01 , +3.99349870596906125894068556877626311e-01 }, + {-7.19279634651493138264299886941444129e-01 , -9.06150816136239309657351447814954486e-01 }, + {-7.23976590297829680764607473975047469e-01 , -9.15951596268038628402616624621418121e-01 }, + {+9.31431733675747830503155455517116934e-01 , +1.66909350005993386837360519102696526e+00 }, + {+5.37270796945802042721140878711594269e-01 , +6.00310952521635654514167563653463826e-01 }, + {+5.05516649275373541883027428411878645e-01 , +5.56688962620397076749424137775916558e-01 }, + {+6.47849417517198489235852321144193411e-01 , +7.71583729081504579676124881689567952e-01 }, + {-5.41124640015404612114480187301523983e-01 , -6.05744544146300297202878069447139070e-01 }, + {+8.08308086737189235293499223189428449e-01 , +1.12212873178291911884370700806026369e+00 }, + {-3.98280706273062445887944704736582935e-01 , -4.21603823445725768059979840445297322e-01 }, + {+8.21296094676341903451088910514954478e-01 , +1.16078669527372101102128788451037300e+00 }, + {+8.31294185704192667429879293194971979e-01 , +1.19231087346512905437819601187290515e+00 }, + {+7.75279686135698531401772015669848770e-01 , +1.03342833983253459558199442655538342e+00 }, + {+8.63016425798844855066249692754354328e-01 , +1.30504558255929258800082186193362940e+00 }, + {-4.01121200686206158536606380948796868e-01 , -4.24984406726507784951210586374028211e-01 }, + {-7.26296876814658931564849808637518436e-01 , -9.20844916340064967501644052845522852e-01 }, + {-6.51251452570346556214531119621824473e-01 , -7.77468783732375082858572957021836038e-01 }, + {-3.38884333978433982537126212264411151e-01 , -3.52831574304372263524860719607206882e-01 }, + {+1.72392299987310537723317338532069698e-01 , +1.74131195612490806064041759672764899e-01 }, + {-5.51462898378643817665079041034914553e-01 , -6.20481084171861782978180187043219425e-01 }, + {-9.64904165725041895740332620334811509e-01 , -2.01255815534358709601688745544440155e+00 }, + {+4.86038064330916674826710277557140216e-01 , +5.30859816325958819695652448239234798e-01 }, + {-1.71510111227157313606994648580439389e-01 , -1.73222128192418256096782313598032358e-01 }, + {-6.40878189659797481425584919634275138e-01 , -7.59662611746376207791374637040653373e-01 }, + {-9.21153045478257270772814990777987987e-01 , -1.59658607015886876829589111732687615e+00 }, + {+9.25949497320595948934851548983715475e-01 , +1.62921352070439068555146795332724838e+00 }, + {+6.67107753751613463677472282142844051e-02 , +6.68100020655284551850585715148980622e-02 }, + {-7.11704678755497255338013928849250078e-01 , -8.90629832677982628857274943637335499e-01 }, + {+2.35257760530820814182106914813630283e-01 , +2.39748052543229836539708777609029562e-01 }, + {-5.99809116170998191108765240642242134e-01 , -6.92848977932719794607448570102282265e-01 }, + {+2.36856137326988402946881251409649849e-02 , +2.36900444994942435090279187572837691e-02 }, + {+4.79753735068501274696473046788014472e-01 , +5.22664335906700767137176554743504717e-01 }, + {-6.67813223642592657114391840877942741e-02 , -6.68808647504004031806529934863158282e-02 }, + {+4.94668485437996574560770568496081978e-01 , +5.42222516993971658066335656775147071e-01 }, + {+9.22379519394591618208778527332469821e-01 , +1.60474385650308389567794994129179836e+00 }, + {+8.66971245297548764874306925776181743e-01 , +1.32075371812223257408713093011711133e+00 }, + {-4.12983669850965462444492004578933120e-01 , -4.39203093212737172928023065922190938e-01 }, + {-5.47462091173417153555647018947638571e-01 , -6.14749985698478964136871989998405650e-01 }, + {+1.94666780724803700763914093840867281e-02 , +1.94691376077079831895420594672983760e-02 }, + {+7.50017550413333511372115935955662280e-01 , +9.72995190965114870405588062706564568e-01 }, + {+4.63499306097077345967250039393547922e-01 , +5.01758888267043269595832923648429311e-01 }, + {-8.37886773978241183868931329925544560e-01 , -1.21403834050977292529923613488719174e+00 }, + {-8.44836969187467534680990866036154330e-01 , -1.23783490656982630833439816713451784e+00 }, + {-6.25239150214307315422956889960914850e-02 , -6.26055803188625957299760516982282628e-02 }, + {+9.22830248275150921699605532921850681e-01 , +1.60777295202485947753242989620181993e+00 }, + {-4.00102773592881266750964641687460244e-01 , -4.23771285697601852943736383483221011e-01 }, + {-2.14797176230649089490043479599989951e-01 , -2.18195175029126913051736730604906575e-01 }, + {+8.02345358196084879054410521348472685e-01 , +1.10516139904369984294917445650114715e+00 }, + {-4.71866662797370439719202295236755162e-01 , -5.12468964220618253719339326228366982e-01 }, + {-5.92911187960187158196845302882138640e-01 , -6.82143591940237868513886526048905163e-01 }, + {-8.76501962797874289989863427763339132e-01 , -1.36046970086086594286889855837180352e+00 }, + {-7.98090332703508265055347692396026105e-01 , -1.09333002432404366596746493295830794e+00 }, + {-9.95891457501823618159164652752224356e-01 , -3.09288886654198972890077598351970075e+00 }, + {+8.90238675794242206862350030860397965e-01 , +1.42307507755399321220435398978827125e+00 }, + {+2.65017376806080395823528306209482253e-01 , +2.71497140326271882216423312414093371e-01 }, + {-8.86140475954999118357591214589774609e-01 , -1.40366125031104099709908824399414822e+00 }, + {-2.77209688130732434530045793508179486e-01 , -2.84656945620440202957754725962273832e-01 }, + {-5.61942305274404585446745841181837022e-01 , -6.35667384226952551579962809234573845e-01 }, + {+5.85899688875965107826004896196536720e-01 , +6.71399455223037749672225055315941521e-01 }, + {+2.89700970360319720597885861934628338e-01 , +2.98239807343473574150289333944139019e-01 }, + {+6.75650398573335864149669305334100500e-01 , +8.21067357862862215855289466859201333e-01 }, + {+8.44595640831392491243434506031917408e-01 , +1.23699243938765398083225288313951255e+00 }, + {+7.51976945151026199276600436860462651e-01 , +9.77489203652249672733902415356008597e-01 }, + {+5.84881385823573185511747851705877110e-01 , +6.69850275691608515819691751205471169e-01 }, + {+1.23322570031297651382828917121514678e-01 , +1.23953519549355101274007946363965461e-01 }, + {-2.47363663564394764549092542438302189e-01 , -2.52602687864803306420298300961589174e-01 }, + {-8.72948142869468535209875881264451891e-01 , -1.34533684420626699711543794108336721e+00 }, + {+8.66853617575293000641067919787019491e-01 , +1.32028029629708106765994282266545478e+00 }, + {+9.65229404828656933901243064610753208e-02 , +9.68243850830075059690451893341587506e-02 }, + {-5.83777226707343555034412929671816528e-01 , -6.68173646565246900863367519530400319e-01 }, + {+9.94603681374665704595372517360374331e-01 , +2.95624183430168683072844226874046298e+00 }, + {+7.54573357889273710341626610897947103e-01 , +9.83491456493016558037612443042858735e-01 }, + {-8.72065566686865079049084670259617269e-01 , -1.34163989421242748094845640631675400e+00 }, + {-1.57050652646726351946426802896894515e-01 , -1.58361317756145752747805962366582739e-01 }, + {+9.07524513496185902816648649604758248e-01 , +1.51330900778040915728163457702896072e+00 }, + {+8.88013640284071148478517443436430767e-01 , +1.41245174788920614220523066982061669e+00 }, + {+5.25920210223992712350593592418590561e-01 , +5.84488641604906625861481645606402185e-01 }, + {-8.55361269493308373768059027497656643e-01 , -1.27579779541753266418749325433063584e+00 }, + {+7.52458416629113502338555008464027196e-01 , +9.78598154541206783526807546834975210e-01 }, + {+2.11594554867804984787937883083941415e-01 , +2.14840051580673426585151516223475322e-01 }, + {-8.77614995063785929829691667691804469e-01 , -1.36529288845779405074788706705067271e+00 }, + {-8.13140811836136734314095519948750734e-01 , -1.13623027343457311746522665305747518e+00 }, + {-9.09625945665704094267312029842287302e-03 , -9.09651034981903612229998860206266111e-03 }, + {+7.11723260837115345722736492461990565e-01 , +8.90667489144918362129731310184000150e-01 }, + {-8.83729688568336113618784111167769879e-01 , -1.39254560811946769303745792066561506e+00 }, + {+2.81119771587539202251093684026272967e-01 , +2.88897516488748428420498810336047168e-01 }, + {+8.67969571335847511761585337808355689e-01 , +1.32478745650884654793737485679177607e+00 }, + {+3.71711284421433640901000217127148062e-01 , +3.90407276521447439801268385319531263e-01 }, + {-5.53264526894389874200896883849054575e-01 , -6.23073752400105167233817313285610373e-01 }, + {-7.50972436681106358946635737083852291e-01 , -9.75181502145488477599896301261990367e-01 }, + {+6.22632428081477007353328190220054239e-01 , +7.29292680370939598849165484001382202e-01 }, + {-5.93039523143406244187758602492976934e-01 , -6.82341523923040079633725976448706286e-01 }, + {-6.21804927349977942796499519317876548e-01 , -7.27942416494347815893737620840227454e-01 }, + {-5.91667199221579398482617762056179345e-01 , -6.80227384371192279205589233595913495e-01 }, + }; + + for (double[] testCase : testCases) { + failures += testAtanhCaseWithUlpDiff(testCase[0], + testCase[1], + 3.0); + } + + return failures; + } + + public static int testAtanhCaseWithTolerance(double input, + double expected, + double tolerance) { + int failures = 0; + failures += Tests.testTolerance("Math.atanh", input, Math::atanh, expected, tolerance); + failures += Tests.testTolerance("Math.atanh", -input, Math::atanh, -expected, tolerance); + + failures += Tests.testTolerance("StrictMath.atanh", input, StrictMath::atanh, expected, tolerance); + failures += Tests.testTolerance("StrictMath.atanh", -input, StrictMath::atanh, -expected, tolerance); + return failures; + } + + public static int testAtanhCaseWithUlpDiff(double input, + double expected, + double ulps) { + int failures = 0; + + failures += Tests.testUlpDiffWithAbsBound("Math.atanh", input, Math::atanh, expected, ulps, Double.POSITIVE_INFINITY); + failures += Tests.testUlpDiffWithAbsBound("Math.atanh", -input, Math::atanh, -expected, ulps, Double.POSITIVE_INFINITY); + + failures += Tests.testUlpDiffWithAbsBound("StrictMath.atanh", input, StrictMath::atanh, expected, ulps, Double.POSITIVE_INFINITY); + failures += Tests.testUlpDiffWithAbsBound("StrictMath.atanh", -input, StrictMath::atanh, -expected, ulps, Double.POSITIVE_INFINITY); + return failures; + } } diff --git a/test/jdk/java/lang/StrictMath/ExhaustingTests.java b/test/jdk/java/lang/StrictMath/ExhaustingTests.java index d028f0541fa..23b55a50bee 100644 --- a/test/jdk/java/lang/StrictMath/ExhaustingTests.java +++ b/test/jdk/java/lang/StrictMath/ExhaustingTests.java @@ -94,6 +94,7 @@ public class ExhaustingTests { new UnaryTestCase("asinh", FdlibmTranslit::asinh, StrictMath::asinh, DEFAULT_SHIFT), new UnaryTestCase("acosh", FdlibmTranslit::acosh, StrictMath::acosh, DEFAULT_SHIFT), + new UnaryTestCase("atanh", FdlibmTranslit::atanh, StrictMath::atanh, DEFAULT_SHIFT), }; for (var testCase : testCases) { diff --git a/test/jdk/java/lang/StrictMath/FdlibmTranslit.java b/test/jdk/java/lang/StrictMath/FdlibmTranslit.java index 6ac90c826d5..ffa18676c90 100644 --- a/test/jdk/java/lang/StrictMath/FdlibmTranslit.java +++ b/test/jdk/java/lang/StrictMath/FdlibmTranslit.java @@ -148,6 +148,10 @@ public class FdlibmTranslit { return Acosh.compute(x); } + public static double atanh(double x) { + return Atanh.compute(x); + } + public static double IEEEremainder(double f1, double f2) { return IEEEremainder.compute(f1, f2); } @@ -2841,4 +2845,50 @@ public class FdlibmTranslit { } } } + + /* + * Return the Inverse Hyperbolic Tangent of x + * + * Method : + * 1.Reduced x to positive by atanh(-x) = -atanh(x) + * 2.For x>=0.5 + * 1 2x x + * atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * --------) + * 2 1 - x 1 - x + * + * For x<0.5 + * atanh(x) = 0.5*log1p(2x+2x*x/(1-x)) + * + * Special cases: + * atanh(x) is NaN if |x| > 1 with signal; + * atanh(NaN) is that NaN with no signal; + * atanh(+-1) is +-INF with signal. + * + */ + private static final class Atanh { + private static final double zero = 0.0; + private static final double one = 1.0; + private static final double huge = 1.0e300; + + static double compute(double x) { + double t; + int hx,ix; + /*unsigned*/ int lx; + hx = __HI(x); /* high word */ + lx = __LO(x); /* low word */ + ix = hx&0x7fffffff; + if ((ix|((lx|(-lx))>>>31))>0x3ff00000) /* |x|>1 */ + return (x-x)/(x-x); + if(ix==0x3ff00000) + return x/zero; + if(ix<0x3e300000&&(huge+x)>zero) return x; /* x<2**-28 */ + x = __HI(x, ix); /* x <- |x| */ + if(ix<0x3fe00000) { /* x < 0.5 */ + t = x+x; + t = 0.5*log1p(t+t*x/(one-x)); + } else + t = 0.5*log1p((x+x)/(one-x)); + if(hx>=0) return t; else return -t; + } + } } diff --git a/test/jdk/java/lang/StrictMath/HyperbolicTests.java b/test/jdk/java/lang/StrictMath/HyperbolicTests.java index b13a16011c1..4be1b350c1d 100644 --- a/test/jdk/java/lang/StrictMath/HyperbolicTests.java +++ b/test/jdk/java/lang/StrictMath/HyperbolicTests.java @@ -34,7 +34,7 @@ import java.util.function.DoubleUnaryOperator; * @build FdlibmTranslit * @build HyperbolicTests * @run main HyperbolicTests - * @summary Tests for StrictMath.{sinh, cosh, tanh, asinh, acosh} + * @summary Tests for StrictMath.{sinh, cosh, tanh, asinh, acosh, atanh} */ /** @@ -60,12 +60,14 @@ public class HyperbolicTests { failures += testAgainstTranslitSinh(); failures += testAgainstTranslitCosh(); failures += testAgainstTranslitTanh(); + failures += testAgainstTranslitAtanh(); failures += testSinh(); failures += testCosh(); failures += testTanh(); failures += testAsinh(); failures += testAcosh(); + failures += testAtanh(); if (failures > 0) { System.err.println("Testing the hyperbolics incurred " @@ -82,7 +84,8 @@ public class HyperbolicTests { COSH(HyperbolicTests::testCoshCase, FdlibmTranslit::cosh), TANH(HyperbolicTests::testTanhCase, FdlibmTranslit::tanh), ASINH(HyperbolicTests::testAsinhCase, FdlibmTranslit::asinh), - ACOSH(HyperbolicTests::testAcoshCase, FdlibmTranslit::acosh); + ACOSH(HyperbolicTests::testAcoshCase, FdlibmTranslit::acosh), + ATANH(HyperbolicTests::testAtanhCase, FdlibmTranslit::atanh); private DoubleDoubleToInt testCase; private DoubleUnaryOperator transliteration; @@ -216,6 +219,31 @@ public class HyperbolicTests { return failures; } + /** + * Test StrictMath.tanh against transliteration port of tanh + */ + private static int testAgainstTranslitAtanh() { + int failures = 0; + double x; + + // Probe near decision points in the FDLIBM algorithm. + double[] decisionPoints = { + 0.0, + + 0x1.0p-28, + -0x1.0p-28, + + 1.0, + -1.0, + }; + + for (double testPoint : decisionPoints) { + failures += testRangeMidpoint(testPoint, Math.ulp(testPoint), 1000, HyperbolicTest.ATANH); + } + + return failures; + } + private interface DoubleDoubleToInt { int apply(double x, double y); } @@ -267,6 +295,11 @@ public class HyperbolicTests { StrictMath::acosh, expected); } + private static int testAtanhCase(double input, double expected) { + return Tests.test("StrictMath.atanh(double)", input, + StrictMath::atanh, expected); + } + private static int testSinh() { int failures = 0; double [][] testCases = { @@ -618,4 +651,69 @@ public class HyperbolicTests { return failures; } + + private static int testAtanh() { + int failures = 0; + double [][] testCases = { + {0x1.5798ee2308c36p-27, 0x1.5798ee2308c37p-27}, + {0x1.ffffffffffffep-26, 0x1p-25}, + {0x1.ffffffffffffep-25, 0x1.0000000000004p-24}, + {0x1.ad7f29abcaf47p-24, 0x1.ad7f29abcaf6p-24}, + {0x1.ad7f29abcaf48p-24, 0x1.ad7f29abcaf61p-24}, + {0x1.ffffffffffffep-24, 0x1.0000000000014p-23}, + {0x1.ffffffffffffep-23, 0x1.0000000000054p-22}, + {0x1.ffffffffffffep-22, 0x1.0000000000154p-21}, + {0x1.ffffffffffffep-21, 0x1.0000000000554p-20}, + {0x1.0c6f7a0b5ed8dp-20, 0x1.0c6f7a0b5f3b3p-20}, + {0x1.ffffffffffffep-20, 0x1.0000000001554p-19}, + {0x1.ffffffffffffep-19, 0x1.0000000005554p-18}, + {0x1.fffffffffffffp-18, 0x1.0000000015555p-17}, + {0x1p-17, 0x1.0000000015555p-17}, + {0x1.4f8b588e368edp-17, 0x1.4f8b588e6698bp-17}, + {0x1.fffffffffffffp-17, 0x1.0000000055555p-16}, + {0x1.fffffffffffffp-16, 0x1.0000000155555p-15}, + {0x1p-15, 0x1.0000000155555p-15}, + {0x1.fffffffffe5ddp-15, 0x1.0000000554844p-14}, + {0x1.fffffffffffffp-15, 0x1.0000000555555p-14}, + {0x1.a36e2eb1c432dp-14, 0x1.a36e2ec938ff8p-14}, + {0x1.ffffffffffffep-14, 0x1.0000001555555p-13}, + {0x1p-13, 0x1.0000001555556p-13}, + {0x1.ffffffffffd51p-13, 0x1.0000005555401p-12}, + {0x1.fffffffffffffp-13, 0x1.0000005555559p-12}, + {0x1.ffffffffffffep-12, 0x1.0000015555587p-11}, + {0x1p-11, 0x1.0000015555588p-11}, + {0x1.fffffffffff1p-11, 0x1.0000055555811p-10}, + {0x1p-10, 0x1.0000055555889p-10}, + {0x1.0624dd2f1a9c6p-10, 0x1.0624e2e91ece1p-10}, + {0x1.0624dd2f1a9f8p-10, 0x1.0624e2e91ed13p-10}, + {0x1.fffffffffffddp-10, 0x1.0000155558877p-9}, + {0x1.fffffffffffffp-10, 0x1.0000155558888p-9}, + {0x1.ffffffffffffcp-9, 0x1.0000555588889p-8}, + {0x1.ffffffffffffep-9, 0x1.000055558888ap-8}, + {0x1.ffffffffffff8p-8, 0x1.0001555888917p-7}, + {0x1.ffffffffffffep-8, 0x1.000155588891ap-7}, + {0x1.47ae147ae1458p-7, 0x1.47b0e059d0574p-7}, + {0x1.47ae147ae1464p-7, 0x1.47b0e059d058p-7}, + {0x1.ffffffffffffep-7, 0x1.000555888ad1bp-6}, + {0x1.fffffffffffffp-7, 0x1.000555888ad1cp-6}, + {0x1.ffffffffffff9p-6, 0x1.001558891aedep-5}, + {0x1.ffffffffffffep-6, 0x1.001558891aee1p-5}, + {0x1.ffffffffffff9p-5, 0x1.005588ad375a9p-4}, + {0x1.fffffffffffffp-5, 0x1.005588ad375acp-4}, + {0x1.9999999999996p-4, 0x1.9af93cd23440ep-4}, + {0x1.9999999999997p-4, 0x1.9af93cd23440fp-4}, + {0x1.fffffffffffffp-4, 0x1.015891c9eaef7p-3}, + {0x1p-3, 0x1.015891c9eaef7p-3}, + {0x1.fffffffffffffp-3, 0x1.058aefa811451p-2}, + {0x1.ffffffffffffcp-2, 0x1.193ea7aad0308p-1}, + {0x1.ffffffffffffep-2, 0x1.193ea7aad0309p-1}, + {0x1.ffffffffffffbp-1, 0x1.1e9067763b478p+4}, + {0x1.ffffffffffffep-1, 0x1.25e4f7b2737fap+4}, + }; + + for (double[] testCase: testCases) + failures += testAtanhCase(testCase[0], testCase[1]); + + return failures; + } } From 7ec561f8b7a72ce3f6adee27dbdd86a191654e50 Mon Sep 17 00:00:00 2001 From: Albert Mingkun Yang Date: Fri, 20 Feb 2026 09:01:08 +0000 Subject: [PATCH 18/63] 8378178: Change Thread::_allocated_bytes from jlong to uint64_t Reviewed-by: coleenp, stefank --- .../share/gc/shared/threadLocalAllocBuffer.cpp | 4 ++-- .../share/gc/shared/threadLocalAllocBuffer.hpp | 2 +- src/hotspot/share/jfr/periodic/jfrPeriodic.cpp | 2 +- src/hotspot/share/jvmci/vmStructs_jvmci.cpp | 2 +- src/hotspot/share/runtime/thread.cpp | 4 ++-- src/hotspot/share/runtime/thread.hpp | 8 ++++---- src/hotspot/share/runtime/thread.inline.hpp | 4 ++-- src/hotspot/share/runtime/vmStructs.cpp | 2 +- src/hotspot/share/services/management.cpp | 12 ++++++------ src/hotspot/share/services/threadService.cpp | 2 +- src/hotspot/share/services/threadService.hpp | 6 +++--- .../classes/sun/jvm/hotspot/runtime/Thread.java | 4 ++-- 12 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/hotspot/share/gc/shared/threadLocalAllocBuffer.cpp b/src/hotspot/share/gc/shared/threadLocalAllocBuffer.cpp index d99544c0573..61cf73fe04a 100644 --- a/src/hotspot/share/gc/shared/threadLocalAllocBuffer.cpp +++ b/src/hotspot/share/gc/shared/threadLocalAllocBuffer.cpp @@ -76,8 +76,8 @@ void ThreadLocalAllocBuffer::accumulate_and_reset_statistics(ThreadLocalAllocSta size_t used = Universe::heap()->tlab_used(); _gc_waste += (unsigned)remaining(); - size_t total_allocated = (size_t)thread()->allocated_bytes(); - size_t allocated_since_last_gc = total_allocated - _allocated_before_last_gc; + uint64_t total_allocated = thread()->allocated_bytes(); + uint64_t allocated_since_last_gc = total_allocated - _allocated_before_last_gc; _allocated_before_last_gc = total_allocated; print_stats("gc"); diff --git a/src/hotspot/share/gc/shared/threadLocalAllocBuffer.hpp b/src/hotspot/share/gc/shared/threadLocalAllocBuffer.hpp index 61caac7ec51..25d9bf00eac 100644 --- a/src/hotspot/share/gc/shared/threadLocalAllocBuffer.hpp +++ b/src/hotspot/share/gc/shared/threadLocalAllocBuffer.hpp @@ -54,7 +54,7 @@ private: size_t _desired_size; // desired size (including alignment_reserve) size_t _refill_waste_limit; // hold onto tlab if free() is larger than this - size_t _allocated_before_last_gc; // total bytes allocated up until the last gc + uint64_t _allocated_before_last_gc; // total bytes allocated up until the last gc static size_t _max_size; // maximum size of any TLAB static int _reserve_for_allocation_prefetch; // Reserve at the end of the TLAB diff --git a/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp b/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp index b30ebd8108c..426ba4e7650 100644 --- a/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp +++ b/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp @@ -493,7 +493,7 @@ TRACE_REQUEST_FUNC(InitialSystemProperty) { TRACE_REQUEST_FUNC(ThreadAllocationStatistics) { ResourceMark rm; int initial_size = Threads::number_of_threads(); - GrowableArray allocated(initial_size); + GrowableArray allocated(initial_size); GrowableArray thread_ids(initial_size); JfrTicks time_stamp = JfrTicks::now(); JfrJavaThreadIterator iter; diff --git a/src/hotspot/share/jvmci/vmStructs_jvmci.cpp b/src/hotspot/share/jvmci/vmStructs_jvmci.cpp index 91482e825cd..74314b0ad61 100644 --- a/src/hotspot/share/jvmci/vmStructs_jvmci.cpp +++ b/src/hotspot/share/jvmci/vmStructs_jvmci.cpp @@ -432,7 +432,7 @@ \ nonstatic_field(Thread, _poll_data, SafepointMechanism::ThreadData) \ nonstatic_field(Thread, _tlab, ThreadLocalAllocBuffer) \ - nonstatic_field(Thread, _allocated_bytes, jlong) \ + nonstatic_field(Thread, _allocated_bytes, uint64_t) \ JFR_ONLY(nonstatic_field(Thread, _jfr_thread_local, JfrThreadLocal)) \ \ static_field(java_lang_Thread, _tid_offset, int) \ diff --git a/src/hotspot/share/runtime/thread.cpp b/src/hotspot/share/runtime/thread.cpp index f27d355f56e..6de56c30d5f 100644 --- a/src/hotspot/share/runtime/thread.cpp +++ b/src/hotspot/share/runtime/thread.cpp @@ -485,8 +485,8 @@ void Thread::print_on(outputStream* st, bool print_extended_info) const { (double)_statistical_info.getElapsedTime() / 1000.0 ); if (is_Java_thread() && (PrintExtendedThreadInfo || print_extended_info)) { - size_t allocated_bytes = checked_cast(cooked_allocated_bytes()); - st->print("allocated=%zu%s ", + uint64_t allocated_bytes = cooked_allocated_bytes(); + st->print("allocated=" UINT64_FORMAT "%s ", byte_size_in_proper_unit(allocated_bytes), proper_unit_for_byte_size(allocated_bytes) ); diff --git a/src/hotspot/share/runtime/thread.hpp b/src/hotspot/share/runtime/thread.hpp index 0225fa808cb..bef31a70170 100644 --- a/src/hotspot/share/runtime/thread.hpp +++ b/src/hotspot/share/runtime/thread.hpp @@ -257,7 +257,7 @@ class Thread: public ThreadShadow { private: ThreadLocalAllocBuffer _tlab; // Thread-local eden - jlong _allocated_bytes; // Cumulative number of bytes allocated on + uint64_t _allocated_bytes; // Cumulative number of bytes allocated on // the Java heap ThreadHeapSampler _heap_sampler; // For use when sampling the memory. @@ -410,9 +410,9 @@ class Thread: public ThreadShadow { void retire_tlab(ThreadLocalAllocStats* stats = nullptr); void fill_tlab(HeapWord* start, size_t pre_reserved, size_t new_size); - jlong allocated_bytes() { return _allocated_bytes; } - void incr_allocated_bytes(jlong size) { _allocated_bytes += size; } - inline jlong cooked_allocated_bytes() const; + uint64_t allocated_bytes() { return _allocated_bytes; } + void incr_allocated_bytes(uint64_t size) { _allocated_bytes += size; } + inline uint64_t cooked_allocated_bytes() const; ThreadHeapSampler& heap_sampler() { return _heap_sampler; } diff --git a/src/hotspot/share/runtime/thread.inline.hpp b/src/hotspot/share/runtime/thread.inline.hpp index d2ac34c3e46..b4cf3ec589a 100644 --- a/src/hotspot/share/runtime/thread.inline.hpp +++ b/src/hotspot/share/runtime/thread.inline.hpp @@ -36,8 +36,8 @@ #include "runtime/os.hpp" #endif -inline jlong Thread::cooked_allocated_bytes() const { - jlong allocated_bytes = AtomicAccess::load_acquire(&_allocated_bytes); +inline uint64_t Thread::cooked_allocated_bytes() const { + uint64_t allocated_bytes = AtomicAccess::load_acquire(&_allocated_bytes); size_t used_bytes = 0; if (UseTLAB) { // cooked_used_bytes() does its best to not return implausible values, but diff --git a/src/hotspot/share/runtime/vmStructs.cpp b/src/hotspot/share/runtime/vmStructs.cpp index 92be0217bf3..4d2ba90e326 100644 --- a/src/hotspot/share/runtime/vmStructs.cpp +++ b/src/hotspot/share/runtime/vmStructs.cpp @@ -576,7 +576,7 @@ nonstatic_field(ThreadShadow, _exception_file, const char*) \ nonstatic_field(ThreadShadow, _exception_line, int) \ nonstatic_field(Thread, _tlab, ThreadLocalAllocBuffer) \ - nonstatic_field(Thread, _allocated_bytes, jlong) \ + nonstatic_field(Thread, _allocated_bytes, uint64_t) \ nonstatic_field(JavaThread, _lock_stack, LockStack) \ nonstatic_field(LockStack, _top, uint32_t) \ nonstatic_field(LockStack, _base[0], oop) \ diff --git a/src/hotspot/share/services/management.cpp b/src/hotspot/share/services/management.cpp index 290e4839c96..09277e16479 100644 --- a/src/hotspot/share/services/management.cpp +++ b/src/hotspot/share/services/management.cpp @@ -2124,12 +2124,12 @@ JVM_ENTRY(jlong, jmm_GetTotalThreadAllocatedMemory(JNIEnv *env)) // We keep a high water mark to ensure monotonicity in case threads counted // on a previous call end up in state (2). - static jlong high_water_result = 0; + static uint64_t high_water_result = 0; JavaThreadIteratorWithHandle jtiwh; - jlong result = ThreadService::exited_allocated_bytes(); + uint64_t result = ThreadService::exited_allocated_bytes(); for (; JavaThread* thread = jtiwh.next();) { - jlong size = thread->cooked_allocated_bytes(); + uint64_t size = thread->cooked_allocated_bytes(); result += size; } @@ -2144,7 +2144,7 @@ JVM_ENTRY(jlong, jmm_GetTotalThreadAllocatedMemory(JNIEnv *env)) high_water_result = result; } } - return result; + return checked_cast(result); JVM_END // Gets the amount of memory allocated on the Java heap for a single thread. @@ -2156,13 +2156,13 @@ JVM_ENTRY(jlong, jmm_GetOneThreadAllocatedMemory(JNIEnv *env, jlong thread_id)) } if (thread_id == 0) { // current thread - return thread->cooked_allocated_bytes(); + return checked_cast(thread->cooked_allocated_bytes()); } ThreadsListHandle tlh; JavaThread* java_thread = tlh.list()->find_JavaThread_from_java_tid(thread_id); if (is_platform_thread(java_thread)) { - return java_thread->cooked_allocated_bytes(); + return checked_cast(java_thread->cooked_allocated_bytes()); } return -1; JVM_END diff --git a/src/hotspot/share/services/threadService.cpp b/src/hotspot/share/services/threadService.cpp index 4dc6abe54b7..4f511075967 100644 --- a/src/hotspot/share/services/threadService.cpp +++ b/src/hotspot/share/services/threadService.cpp @@ -74,7 +74,7 @@ PerfVariable* ThreadService::_daemon_threads_count = nullptr; volatile int ThreadService::_atomic_threads_count = 0; volatile int ThreadService::_atomic_daemon_threads_count = 0; -volatile jlong ThreadService::_exited_allocated_bytes = 0; +volatile uint64_t ThreadService::_exited_allocated_bytes = 0; ThreadDumpResult* ThreadService::_threaddump_list = nullptr; diff --git a/src/hotspot/share/services/threadService.hpp b/src/hotspot/share/services/threadService.hpp index 4b0e76658b6..ddfc78e6315 100644 --- a/src/hotspot/share/services/threadService.hpp +++ b/src/hotspot/share/services/threadService.hpp @@ -63,7 +63,7 @@ private: // As could this... // Number of heap bytes allocated by terminated threads. - static volatile jlong _exited_allocated_bytes; + static volatile uint64_t _exited_allocated_bytes; // These 2 counters are like the above thread counts, but are // atomically decremented in ThreadService::current_thread_exiting instead of @@ -106,8 +106,8 @@ public: static int get_live_thread_count() { return _atomic_threads_count; } static int get_daemon_thread_count() { return _atomic_daemon_threads_count; } - static jlong exited_allocated_bytes() { return AtomicAccess::load(&_exited_allocated_bytes); } - static void incr_exited_allocated_bytes(jlong size) { + static uint64_t exited_allocated_bytes() { return AtomicAccess::load(&_exited_allocated_bytes); } + static void incr_exited_allocated_bytes(uint64_t size) { // No need for an atomic add because called under the Threads_lock, // but because _exited_allocated_bytes is read concurrently, need // atomic store to avoid readers seeing a partial update. diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/Thread.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/Thread.java index 22bc02a06d9..d2e05c6f84d 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/Thread.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/Thread.java @@ -39,7 +39,7 @@ public class Thread extends VMObject { private static AddressField currentWaitingMonitorField; private static AddressField osThreadField; - private static JLongField allocatedBytesField; + private static CIntegerField allocatedBytesField; static { VM.registerVMInitializedObserver(new Observer() { @@ -60,7 +60,7 @@ public class Thread extends VMObject { tlabFieldOffset = typeThread.getField("_tlab").getOffset(); currentPendingMonitorField = typeJavaThread.getAddressField("_current_pending_monitor"); currentWaitingMonitorField = typeJavaThread.getAddressField("_current_waiting_monitor"); - allocatedBytesField = typeThread.getJLongField("_allocated_bytes"); + allocatedBytesField = typeThread.getCIntegerField("_allocated_bytes"); } public Thread(Address addr) { From c3a698f7bef2bf6fae132e762095658273a5a2f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Markus=20Gr=C3=B6nlund?= Date: Fri, 20 Feb 2026 10:55:45 +0000 Subject: [PATCH 19/63] 8377665: JFR: Symbol table not setup for early class unloading Reviewed-by: jsikstro --- .../recorder/checkpoint/types/jfrTypeSet.cpp | 2 +- src/hotspot/share/jfr/recorder/jfrRecorder.cpp | 18 ++++++++++++------ src/hotspot/share/jfr/recorder/jfrRecorder.hpp | 1 + 3 files changed, 14 insertions(+), 7 deletions(-) diff --git a/src/hotspot/share/jfr/recorder/checkpoint/types/jfrTypeSet.cpp b/src/hotspot/share/jfr/recorder/checkpoint/types/jfrTypeSet.cpp index b1c502e17f8..3dd9ea41d3d 100644 --- a/src/hotspot/share/jfr/recorder/checkpoint/types/jfrTypeSet.cpp +++ b/src/hotspot/share/jfr/recorder/checkpoint/types/jfrTypeSet.cpp @@ -1265,7 +1265,7 @@ static size_t teardown() { JfrKlassUnloading::clear(); _artifacts->clear(); _initial_type_set = true; - } else { + } else if (is_initial_typeset_for_chunk()) { _initial_type_set = false; } return total_count; diff --git a/src/hotspot/share/jfr/recorder/jfrRecorder.cpp b/src/hotspot/share/jfr/recorder/jfrRecorder.cpp index 061e3feac6f..5c12d5213ca 100644 --- a/src/hotspot/share/jfr/recorder/jfrRecorder.cpp +++ b/src/hotspot/share/jfr/recorder/jfrRecorder.cpp @@ -102,6 +102,9 @@ bool JfrRecorder::on_create_vm_1() { if (!create_checkpoint_manager()) { return false; } + if (!JfrSymbolTable::create()) { + return false; + } } // fast time initialization @@ -316,10 +319,7 @@ bool JfrRecorder::create_components() { if (!create_thread_group_manager()) { return false; } - if (!create_symbol_table()) { - return false; - } - return true; + return create_symbol_table(); } // subsystems @@ -418,7 +418,13 @@ bool JfrRecorder::create_thread_group_manager() { } bool JfrRecorder::create_symbol_table() { - return JfrSymbolTable::create(); + return !is_started_on_commandline() ? JfrSymbolTable::create() : true; +} + +void JfrRecorder::destroy_symbol_table() { + if (!is_started_on_commandline()) { + JfrSymbolTable::destroy(); + } } void JfrRecorder::destroy_components() { @@ -461,7 +467,7 @@ void JfrRecorder::destroy_components() { } JfrEventThrottler::destroy(); JfrThreadGroupManager::destroy(); - JfrSymbolTable::destroy(); + destroy_symbol_table(); } bool JfrRecorder::create_recorder_thread() { diff --git a/src/hotspot/share/jfr/recorder/jfrRecorder.hpp b/src/hotspot/share/jfr/recorder/jfrRecorder.hpp index 8cc4521669d..fa1b677b31a 100644 --- a/src/hotspot/share/jfr/recorder/jfrRecorder.hpp +++ b/src/hotspot/share/jfr/recorder/jfrRecorder.hpp @@ -59,6 +59,7 @@ class JfrRecorder : public JfrCHeapObj { static bool create_event_throttler(); static bool create_symbol_table(); static bool create_components(); + static void destroy_symbol_table(); static void destroy_components(); static void on_recorder_thread_exit(); From 16f2b8032729c39ed218de11562bc63aa7b35fd9 Mon Sep 17 00:00:00 2001 From: Casper Norrbin Date: Fri, 20 Feb 2026 10:56:15 +0000 Subject: [PATCH 20/63] 8373638: RBTree public interface does not check all input parameters for validity Reviewed-by: ayang, dholmes --- src/hotspot/share/utilities/rbTree.inline.hpp | 23 ++++++++++++++----- 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/src/hotspot/share/utilities/rbTree.inline.hpp b/src/hotspot/share/utilities/rbTree.inline.hpp index ed8884b2d27..70d9aee7fbf 100644 --- a/src/hotspot/share/utilities/rbTree.inline.hpp +++ b/src/hotspot/share/utilities/rbTree.inline.hpp @@ -408,7 +408,9 @@ AbstractRBTree::cursor(const K& key, const NodeType* hi template inline void AbstractRBTree::insert_at_cursor(NodeType* node, const Cursor& node_cursor) { - assert(node_cursor.valid() && !node_cursor.found(), "must be"); + precond(node != nullptr); + precond(node_cursor.valid()); + precond(!node_cursor.found()); _num_nodes++; *node_cursor._insert_location = node; @@ -622,7 +624,8 @@ inline void AbstractRBTree::remove_from_tree(IntrusiveR template inline void AbstractRBTree::remove_at_cursor(const Cursor& node_cursor) { - assert(node_cursor.valid() && node_cursor.found(), "must be"); + precond(node_cursor.valid()); + precond(node_cursor.found()); _num_nodes--; IntrusiveRBNode* node = node_cursor.node(); @@ -718,7 +721,9 @@ AbstractRBTree::prev(const Cursor& node_cursor) const { template inline void AbstractRBTree::replace_at_cursor(NodeType* new_node, const Cursor& node_cursor) { - assert(node_cursor.valid() && node_cursor.found(), "must be"); + precond(new_node != nullptr); + precond(node_cursor.valid()); + precond(node_cursor.found()); NodeType* old_node = node_cursor.node(); if (old_node == new_node) { return; @@ -785,12 +790,14 @@ inline NodeType* AbstractRBTree::find_node(const K& key template inline void AbstractRBTree::insert(const K& key, NodeType* node, const NodeType* hint_node) { + precond(node != nullptr); Cursor node_cursor = cursor(key, hint_node); insert_at_cursor(node, node_cursor); } template inline void AbstractRBTree::remove(NodeType* node) { + precond(node != nullptr); Cursor node_cursor = cursor(node); remove_at_cursor(node_cursor); } @@ -1049,9 +1056,9 @@ inline RBTree::~RBTree() { template bool RBTree::copy_into(RBTree& other) const { - assert(other.size() == 0, "You can only copy into an empty RBTree"); - assert(std::is_copy_constructible::value, "Key type must be copy-constructible when copying a RBTree"); - assert(std::is_copy_constructible::value, "Value type must be copy-constructible when copying a RBTree"); + precond(other.size() == 0); + precond(std::is_copy_constructible::value); + precond(std::is_copy_constructible::value); enum class Dir { Left, Right }; struct node_pair { const IntrusiveRBNode* current; IntrusiveRBNode* other_parent; Dir dir; }; struct stack { @@ -1098,6 +1105,9 @@ bool RBTree::copy_into(RBTree& other) const { template inline void RBTree::replace_at_cursor(RBNode* new_node, const Cursor& node_cursor) { + precond(new_node != nullptr); + precond(node_cursor.valid()); + precond(node_cursor.found()); RBNode* old_node = node_cursor.node(); BaseType::replace_at_cursor(new_node, node_cursor); free_node(old_node); @@ -1123,6 +1133,7 @@ inline RBNode* RBTree::allocate_node(const K& template inline void RBTree::free_node(RBNode* node) { + precond(node != nullptr); node->_value.~V(); _allocator.free(node); } From 2052b443ed2c8c8fb36513822c577f9f80805e91 Mon Sep 17 00:00:00 2001 From: Martin Doerr Date: Fri, 20 Feb 2026 11:25:25 +0000 Subject: [PATCH 21/63] 8378233: depends_only_on_test_impl() assertion hit after JDK-8347365 Reviewed-by: qamai, mbaesken --- src/hotspot/share/opto/intrinsicnode.hpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/hotspot/share/opto/intrinsicnode.hpp b/src/hotspot/share/opto/intrinsicnode.hpp index 02b6ee2d775..d81e7bed7e9 100644 --- a/src/hotspot/share/opto/intrinsicnode.hpp +++ b/src/hotspot/share/opto/intrinsicnode.hpp @@ -221,6 +221,9 @@ public: virtual int Opcode() const; const Type* bottom_type() const { return TypeInt::BOOL; } virtual uint ideal_reg() const { return Op_RegI; } + +private: + virtual bool depends_only_on_test_impl() const { return false; } }; //------------------------------LowerCaseNode------------------------------------ @@ -230,6 +233,9 @@ public: virtual int Opcode() const; const Type* bottom_type() const { return TypeInt::BOOL; } virtual uint ideal_reg() const { return Op_RegI; } + +private: + virtual bool depends_only_on_test_impl() const { return false; } }; //------------------------------UpperCaseNode------------------------------------ @@ -239,6 +245,9 @@ public: virtual int Opcode() const; const Type* bottom_type() const { return TypeInt::BOOL; } virtual uint ideal_reg() const { return Op_RegI; } + +private: + virtual bool depends_only_on_test_impl() const { return false; } }; //------------------------------WhitespaceCode----------------------------------- @@ -248,6 +257,9 @@ public: virtual int Opcode() const; const Type* bottom_type() const { return TypeInt::BOOL; } virtual uint ideal_reg() const { return Op_RegI; } + +private: + virtual bool depends_only_on_test_impl() const { return false; } }; //------------------------------CopySign----------------------------------------- From a296129347ed9448d34ce1c0b6ed778816fd55b1 Mon Sep 17 00:00:00 2001 From: Kerem Kat Date: Fri, 20 Feb 2026 11:33:39 +0000 Subject: [PATCH 22/63] 8375633: C2: Missed Ideal optimization opportunity with ConvD2F/ConvF2HF and -XX:+StressIncrementalInlining Reviewed-by: bmaillard, mchevalier, qamai --- src/hotspot/share/opto/phaseX.cpp | 21 +++++ .../c2/irTests/ConvD2FIdealizationStress.java | 75 +++++++++++++++++ .../irTests/ConvF2HFIdealizationStress.java | 84 +++++++++++++++++++ .../compiler/lib/ir_framework/IRNode.java | 15 ++++ 4 files changed, 195 insertions(+) create mode 100644 test/hotspot/jtreg/compiler/c2/irTests/ConvD2FIdealizationStress.java create mode 100644 test/hotspot/jtreg/compiler/c2/irTests/ConvF2HFIdealizationStress.java diff --git a/src/hotspot/share/opto/phaseX.cpp b/src/hotspot/share/opto/phaseX.cpp index 94f38e86239..9a9a731a022 100644 --- a/src/hotspot/share/opto/phaseX.cpp +++ b/src/hotspot/share/opto/phaseX.cpp @@ -31,6 +31,7 @@ #include "opto/callnode.hpp" #include "opto/castnode.hpp" #include "opto/cfgnode.hpp" +#include "opto/convertnode.hpp" #include "opto/idealGraphPrinter.hpp" #include "opto/loopnode.hpp" #include "opto/machnode.hpp" @@ -2649,6 +2650,26 @@ void PhaseIterGVN::add_users_of_use_to_worklist(Node* n, Node* use, Unique_Node_ } } } + // ConvD2F::Ideal matches ConvD2F(SqrtD(ConvF2D(x))) => SqrtF(x). + // Notify ConvD2F users of SqrtD when any input of the SqrtD changes. + if (use_op == Op_SqrtD) { + for (DUIterator_Fast i2max, i2 = use->fast_outs(i2max); i2 < i2max; i2++) { + Node* u = use->fast_out(i2); + if (u->Opcode() == Op_ConvD2F) { + worklist.push(u); + } + } + } + // ConvF2HF::Ideal matches ConvF2HF(binopF(ConvHF2F(...))) => FP16BinOp(...). + // Notify ConvF2HF users of float binary ops when any input changes. + if (Float16NodeFactory::is_float32_binary_oper(use_op)) { + for (DUIterator_Fast i2max, i2 = use->fast_outs(i2max); i2 < i2max; i2++) { + Node* u = use->fast_out(i2); + if (u->Opcode() == Op_ConvF2HF) { + worklist.push(u); + } + } + } // If changed AddP inputs: // - check Stores for loop invariant, and // - if the changed input is the offset, check constant-offset AddP users for diff --git a/test/hotspot/jtreg/compiler/c2/irTests/ConvD2FIdealizationStress.java b/test/hotspot/jtreg/compiler/c2/irTests/ConvD2FIdealizationStress.java new file mode 100644 index 00000000000..ac0df25ff86 --- /dev/null +++ b/test/hotspot/jtreg/compiler/c2/irTests/ConvD2FIdealizationStress.java @@ -0,0 +1,75 @@ +/* + * Copyright (c) 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. + */ +package compiler.c2.irTests; + +import compiler.lib.ir_framework.*; +import jdk.test.lib.Asserts; +import java.util.Random; +import jdk.test.lib.Utils; + +/* + * @test + * @bug 8375633 + * @key randomness + * @summary Test that ConvD2F::Ideal optimization is not missed with incremental inlining. + * AlwaysIncrementalInline is not required but deterministically defers even + * small methods, making this test reliable. + * @library /test/lib / + * @run driver ${test.main.class} + */ +public class ConvD2FIdealizationStress { + + private static final Random RANDOM = Utils.getRandomInstance(); + + public static void main(String[] args) { + TestFramework.runWithFlags("-XX:-TieredCompilation", + "-XX:+IgnoreUnrecognizedVMOptions", + "-XX:+AlwaysIncrementalInline", + "-XX:VerifyIterativeGVN=1110"); + } + + // Deferred by AlwaysIncrementalInline; ConvF2D appears only after inlining. + static double toDouble(float x) { + return (double) x; + } + + // ConvD2F(SqrtD(ConvF2D(x))) => SqrtF(x) + // Math.sqrt (intrinsic) is expanded at parse time; toDouble is deferred. + @Test + @IR(counts = {IRNode.SQRT_F, ">=1"}, + failOn = {IRNode.CONV_D2F, IRNode.SQRT_D, IRNode.CONV_F2D}) + public static float testSqrtConversion(float x) { + return (float) Math.sqrt(toDouble(x)); + } + + @Run(test = "testSqrtConversion") + public void runSqrtConversion() { + float input = RANDOM.nextFloat(); + checkSqrtConversion(input, testSqrtConversion(input)); + } + + @DontCompile + public void checkSqrtConversion(float input, float result) { + Asserts.assertEQ((float) Math.sqrt(input), result); + } +} diff --git a/test/hotspot/jtreg/compiler/c2/irTests/ConvF2HFIdealizationStress.java b/test/hotspot/jtreg/compiler/c2/irTests/ConvF2HFIdealizationStress.java new file mode 100644 index 00000000000..941077362d5 --- /dev/null +++ b/test/hotspot/jtreg/compiler/c2/irTests/ConvF2HFIdealizationStress.java @@ -0,0 +1,84 @@ +/* + * Copyright (c) 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. + */ +package compiler.c2.irTests; + +import compiler.lib.ir_framework.*; +import jdk.test.lib.Asserts; +import java.util.Random; +import jdk.test.lib.Utils; + +/* + * @test + * @bug 8375633 + * @key randomness + * @summary Test that ConvF2HF::Ideal optimization is not missed with incremental inlining. + * AlwaysIncrementalInline is not required but deterministically defers even + * small methods, making this test reliable. + * @library /test/lib / + * @run driver ${test.main.class} + */ +public class ConvF2HFIdealizationStress { + + private static final Random RANDOM = Utils.getRandomInstance(); + + private short srcBits; + private short twoBits; + private short actualBits; + + public static void main(String[] args) { + TestFramework.runWithFlags("-XX:-TieredCompilation", + "-XX:+IgnoreUnrecognizedVMOptions", + "-XX:+AlwaysIncrementalInline", + "-XX:VerifyIterativeGVN=1110"); + } + + public ConvF2HFIdealizationStress() { + srcBits = Float.floatToFloat16(RANDOM.nextFloat()); + twoBits = Float.floatToFloat16(2.0f); + } + + // Deferred by AlwaysIncrementalInline; ConvHF2F appears only after inlining. + static float toFloat(short hf) { + return Float.float16ToFloat(hf); + } + + // ConvF2HF(MulF(ConvHF2F(a), ConvHF2F(b))) => MulHF(a, b) + // Float.floatToFloat16 (intrinsic) is expanded at parse time; toFloat is deferred. + @Test + @IR(counts = {IRNode.MUL_HF, "1"}, + applyIfCPUFeatureOr = {"avx512_fp16", "true", "zfh", "true"}, + failOn = {IRNode.CONV_F2HF}) + @IR(counts = {IRNode.MUL_HF, "1"}, + applyIfCPUFeatureAnd = {"fphp", "true", "asimdhp", "true"}, + failOn = {IRNode.CONV_F2HF}) + public void testMultiply() { + actualBits = Float.floatToFloat16(toFloat(srcBits) * toFloat(twoBits)); + } + + @Check(test = "testMultiply") + public void checkMultiply() { + float twice = Float.float16ToFloat(srcBits) * Float.float16ToFloat(twoBits); + short expected = Float.floatToFloat16(twice); + Asserts.assertEQ(expected, actualBits); + } +} diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java b/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java index f488e930710..c31ce198644 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java @@ -640,6 +640,11 @@ public class IRNode { beforeMatchingNameRegex(CONV, "Conv"); } + public static final String CONV_D2F = PREFIX + "CONV_D2F" + POSTFIX; + static { + beforeMatchingNameRegex(CONV_D2F, "ConvD2F"); + } + public static final String CONV_D2I = PREFIX + "CONV_D2I" + POSTFIX; static { beforeMatchingNameRegex(CONV_D2I, "ConvD2I"); @@ -650,6 +655,11 @@ public class IRNode { beforeMatchingNameRegex(CONV_D2L, "ConvD2L"); } + public static final String CONV_F2D = PREFIX + "CONV_F2D" + POSTFIX; + static { + beforeMatchingNameRegex(CONV_F2D, "ConvF2D"); + } + public static final String CONV_F2HF = PREFIX + "CONV_F2HF" + POSTFIX; static { beforeMatchingNameRegex(CONV_F2HF, "ConvF2HF"); @@ -1995,6 +2005,11 @@ public class IRNode { beforeMatchingNameRegex(SQRT_HF, "SqrtHF"); } + public static final String SQRT_D = PREFIX + "SQRT_D" + POSTFIX; + static { + beforeMatchingNameRegex(SQRT_D, "SqrtD"); + } + public static final String SQRT_F = PREFIX + "SQRT_F" + POSTFIX; static { beforeMatchingNameRegex(SQRT_F, "SqrtF"); From df8c770944b4a6e9713b1851b45f2b5dd04f6827 Mon Sep 17 00:00:00 2001 From: Matthias Baesken Date: Fri, 20 Feb 2026 11:58:35 +0000 Subject: [PATCH 23/63] 8377300: Use64KPages flag cleanup on AIX Reviewed-by: mdoerr, asteiner --- src/hotspot/os/aix/globals_aix.hpp | 9 ++---- src/hotspot/os/aix/os_aix.cpp | 46 ++++-------------------------- 2 files changed, 8 insertions(+), 47 deletions(-) diff --git a/src/hotspot/os/aix/globals_aix.hpp b/src/hotspot/os/aix/globals_aix.hpp index 14b956235e8..473d7759063 100644 --- a/src/hotspot/os/aix/globals_aix.hpp +++ b/src/hotspot/os/aix/globals_aix.hpp @@ -1,6 +1,6 @@ /* - * Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved. - * Copyright (c) 2012, 2024 SAP SE. All rights reserved. + * Copyright (c) 2005, 2026, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2026 SAP SE. 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 @@ -61,10 +61,6 @@ product(bool, OptimizePollingPageLocation, true, DIAGNOSTIC, \ "Optimize the location of the polling page used for Safepoints") \ \ - /* Use 64K pages for virtual memory (shmat). */ \ - product(bool, Use64KPages, true, DIAGNOSTIC, \ - "Use 64K pages if available.") \ - \ /* Normally AIX commits memory on touch, but sometimes it is helpful to have */ \ /* explicit commit behaviour. This flag, if true, causes the VM to touch */ \ /* memory on os::commit_memory() (which normally is a noop). */ \ @@ -79,7 +75,6 @@ // // UseLargePages means nothing, for now, on AIX. -// Use Use64KPages or Use16MPages instead. define_pd_global(size_t, PreTouchParallelChunkSize, 1 * G); define_pd_global(bool, UseLargePages, false); define_pd_global(bool, UseLargePagesIndividualAllocation, false); diff --git a/src/hotspot/os/aix/os_aix.cpp b/src/hotspot/os/aix/os_aix.cpp index 327508e1118..61d3f36683c 100644 --- a/src/hotspot/os/aix/os_aix.cpp +++ b/src/hotspot/os/aix/os_aix.cpp @@ -2142,46 +2142,12 @@ void os::init(void) { // 64k no --- AIX 5.2 ? --- // 64k yes 64k new systems and standard java loader (we set datapsize=64k when linking) - // We explicitly leave no option to change page size, because only upgrading would work, - // not downgrading (if stack page size is 64k you cannot pretend its 4k). - - if (g_multipage_support.datapsize == 4*K) { - // datapsize = 4K. Data segment, thread stacks are 4K paged. - if (g_multipage_support.can_use_64K_pages || g_multipage_support.can_use_64K_mmap_pages) { - // .. but we are able to use 64K pages dynamically. - // This would be typical for java launchers which are not linked - // with datapsize=64K (like, any other launcher but our own). - // - // In this case it would be smart to allocate the java heap with 64K - // to get the performance benefit, and to fake 64k pages for the - // data segment (when dealing with thread stacks). - // - // However, leave a possibility to downgrade to 4K, using - // -XX:-Use64KPages. - if (Use64KPages) { - trcVerbose("64K page mode (faked for data segment)"); - set_page_size(64*K); - } else { - trcVerbose("4K page mode (Use64KPages=off)"); - set_page_size(4*K); - } - } else { - // .. and not able to allocate 64k pages dynamically. Here, just - // fall back to 4K paged mode and use mmap for everything. - trcVerbose("4K page mode"); - set_page_size(4*K); - FLAG_SET_ERGO(Use64KPages, false); - } - } else { - // datapsize = 64k. Data segment, thread stacks are 64k paged. - // This normally means that we can allocate 64k pages dynamically. - // (There is one special case where this may be false: EXTSHM=on. - // but we decided to not support that mode). - assert0(g_multipage_support.can_use_64K_pages || g_multipage_support.can_use_64K_mmap_pages); - set_page_size(64*K); - trcVerbose("64K page mode"); - FLAG_SET_ERGO(Use64KPages, true); - } + // datapsize = 64k. Data segment, thread stacks are 64k paged. + // This normally means that we can allocate 64k pages dynamically. + // (There is one special case where this may be false: EXTSHM=on. + // but we decided to not support that mode). + assert0(g_multipage_support.can_use_64K_pages || g_multipage_support.can_use_64K_mmap_pages); + set_page_size(64*K); // For now UseLargePages is just ignored. FLAG_SET_ERGO(UseLargePages, false); From c1142bda49aa01297c77e2f33209c06585546c6b Mon Sep 17 00:00:00 2001 From: Coleen Phillimore Date: Fri, 20 Feb 2026 12:33:02 +0000 Subject: [PATCH 24/63] 8339886: runtime/os/TestHugePageDecisionsAtVMStartup.java ignores vm flags Reviewed-by: dholmes, aartemov --- .../jtreg/runtime/os/TestHugePageDecisionsAtVMStartup.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/test/hotspot/jtreg/runtime/os/TestHugePageDecisionsAtVMStartup.java b/test/hotspot/jtreg/runtime/os/TestHugePageDecisionsAtVMStartup.java index 7c0dfb2f3bb..6c5896df058 100644 --- a/test/hotspot/jtreg/runtime/os/TestHugePageDecisionsAtVMStartup.java +++ b/test/hotspot/jtreg/runtime/os/TestHugePageDecisionsAtVMStartup.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 2026, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2023, 2024, Red Hat Inc. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * @@ -26,6 +26,7 @@ * @test id=Default * @summary Test JVM large page setup (default options) * @library /test/lib + * @requires vm.flagless * @requires os.family == "linux" * @modules java.base/jdk.internal.misc * java.management @@ -36,6 +37,7 @@ * @test id=LP_enabled * @summary Test JVM large page setup (+LP) * @library /test/lib + * @requires vm.flagless * @requires os.family == "linux" * @modules java.base/jdk.internal.misc * java.management @@ -46,6 +48,7 @@ * @test id=THP_enabled * @summary Test JVM large page setup (+THP) * @library /test/lib + * @requires vm.flagless * @requires os.family == "linux" * @library /test/lib * @modules java.base/jdk.internal.misc From aeafc5b1655858cd72de58e5f1c0b80b984d7274 Mon Sep 17 00:00:00 2001 From: Albert Mingkun Yang Date: Fri, 20 Feb 2026 12:41:34 +0000 Subject: [PATCH 25/63] 8378245: Obsolete ParallelRefProcBalancingEnabled Reviewed-by: jsikstro, dholmes, tschatzl --- src/hotspot/share/gc/shared/gc_globals.hpp | 3 --- .../share/gc/shared/referenceProcessor.cpp | 26 +------------------ .../share/gc/shared/referenceProcessor.hpp | 1 - src/hotspot/share/runtime/arguments.cpp | 2 +- 4 files changed, 2 insertions(+), 30 deletions(-) diff --git a/src/hotspot/share/gc/shared/gc_globals.hpp b/src/hotspot/share/gc/shared/gc_globals.hpp index 6aa1fcf066b..8e1073db022 100644 --- a/src/hotspot/share/gc/shared/gc_globals.hpp +++ b/src/hotspot/share/gc/shared/gc_globals.hpp @@ -202,9 +202,6 @@ "(Deprecated) Enable parallel reference processing " \ "whenever possible") \ \ - product(bool, ParallelRefProcBalancingEnabled, true, \ - "(Deprecated) Enable balancing of reference processing queues") \ - \ product(size_t, ReferencesPerThread, 1000, EXPERIMENTAL, \ "Ergonomically start one thread for this amount of " \ "references for reference processing if " \ diff --git a/src/hotspot/share/gc/shared/referenceProcessor.cpp b/src/hotspot/share/gc/shared/referenceProcessor.cpp index 0153ee13287..bff097711ca 100644 --- a/src/hotspot/share/gc/shared/referenceProcessor.cpp +++ b/src/hotspot/share/gc/shared/referenceProcessor.cpp @@ -586,33 +586,9 @@ void ReferenceProcessor::set_active_mt_degree(uint v) { _next_id = 0; } -bool ReferenceProcessor::need_balance_queues(DiscoveredList refs_lists[]) { - assert(processing_is_mt(), "why balance non-mt processing?"); - // _num_queues is the processing degree. Only list entries up to - // _num_queues will be processed, so any non-empty lists beyond - // that must be redistributed to lists in that range. Even if not - // needed for that, balancing may be desirable to eliminate poor - // distribution of references among the lists. - if (ParallelRefProcBalancingEnabled) { - return true; // Configuration says do it. - } else { - // Configuration says don't balance, but if there are non-empty - // lists beyond the processing degree, then must ignore the - // configuration and balance anyway. - for (uint i = _num_queues; i < _max_num_queues; ++i) { - if (!refs_lists[i].is_empty()) { - return true; // Must balance despite configuration. - } - } - return false; // Safe to obey configuration and not balance. - } -} - void ReferenceProcessor::maybe_balance_queues(DiscoveredList refs_lists[]) { assert(processing_is_mt(), "Should not call this otherwise"); - if (need_balance_queues(refs_lists)) { - balance_queues(refs_lists); - } + balance_queues(refs_lists); } // Balances reference queues. diff --git a/src/hotspot/share/gc/shared/referenceProcessor.hpp b/src/hotspot/share/gc/shared/referenceProcessor.hpp index b211b94a85d..67bf3d7de36 100644 --- a/src/hotspot/share/gc/shared/referenceProcessor.hpp +++ b/src/hotspot/share/gc/shared/referenceProcessor.hpp @@ -366,7 +366,6 @@ private: // Balances reference queues. void balance_queues(DiscoveredList refs_lists[]); - bool need_balance_queues(DiscoveredList refs_lists[]); // If there is need to balance the given queue, do it. void maybe_balance_queues(DiscoveredList refs_lists[]); diff --git a/src/hotspot/share/runtime/arguments.cpp b/src/hotspot/share/runtime/arguments.cpp index 546ae610769..c87be03ad0c 100644 --- a/src/hotspot/share/runtime/arguments.cpp +++ b/src/hotspot/share/runtime/arguments.cpp @@ -537,7 +537,6 @@ static SpecialFlag const special_jvm_flags[] = { { "UseCompressedClassPointers", JDK_Version::jdk(25), JDK_Version::jdk(27), JDK_Version::undefined() }, #endif { "ParallelRefProcEnabled", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, - { "ParallelRefProcBalancingEnabled", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, { "MaxRAM", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, { "AggressiveHeap", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, { "NeverActAsServerClassMachine", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, @@ -553,6 +552,7 @@ static SpecialFlag const special_jvm_flags[] = { #endif { "PSChunkLargeArrays", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, + { "ParallelRefProcBalancingEnabled", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, #ifdef ASSERT { "DummyObsoleteTestFlag", JDK_Version::undefined(), JDK_Version::jdk(18), JDK_Version::undefined() }, From e8dadf4baa643a48d7b21abe72d073792a9726c0 Mon Sep 17 00:00:00 2001 From: Jaikiran Pai Date: Fri, 20 Feb 2026 15:13:07 +0000 Subject: [PATCH 26/63] 8378003: JarURLConnection.getCertificates() and getCodeSigners() incorrectly return null for signed JAR files after JDK-8377338 Reviewed-by: mullan, dfuchs --- .../sun/net/www/protocol/jar/URLJarFile.java | 28 +++ .../JarURLConnectionCertsAndCodeSigners.java | 182 ++++++++++++++++++ 2 files changed, 210 insertions(+) create mode 100644 test/jdk/sun/net/www/protocol/jar/JarURLConnectionCertsAndCodeSigners.java diff --git a/src/java.base/share/classes/sun/net/www/protocol/jar/URLJarFile.java b/src/java.base/share/classes/sun/net/www/protocol/jar/URLJarFile.java index 45738550f59..7e4a6cb90d4 100644 --- a/src/java.base/share/classes/sun/net/www/protocol/jar/URLJarFile.java +++ b/src/java.base/share/classes/sun/net/www/protocol/jar/URLJarFile.java @@ -30,10 +30,12 @@ import java.net.*; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardCopyOption; +import java.security.cert.Certificate; import java.util.*; import java.util.jar.*; import java.util.zip.ZipFile; import java.util.zip.ZipEntry; +import java.security.CodeSigner; import sun.net.www.ParseUtil; /* URL jar file is a common JarFile subtype used for JarURLConnection */ @@ -163,9 +165,11 @@ public class URLJarFile extends JarFile { } private class URLJarFileEntry extends JarEntry { + private final JarEntry je; URLJarFileEntry(JarEntry je) { super(je); + this.je = je; } @Override @@ -180,6 +184,30 @@ public class URLJarFile extends JarFile { } return null; } + + @Override + public Certificate[] getCertificates() { + // super.getCertificates() returns Certificates that were + // captured by reading the "JarEntry.certs" field when + // the super instance was created. Some JarEntry + // implementations (like java.util.jar.JarFile$JarFileEntry) + // compute certificates lazily, so we explicitly + // call getCertificates() on the underlying JarEntry instead of + // super.getCertificates() + return je.getCertificates(); + } + + @Override + public CodeSigner[] getCodeSigners() { + // super.getCodeSigners() returns CodeSigners that were + // captured by reading the "JarEntry.signers" field when + // the super instance was created. Some JarEntry + // implementations (like java.util.jar.JarFile$JarFileEntry) + // compute codesigners lazily, so we explicitly + // call getCodeSigners() on the underlying JarEntry instead of + // super.getCodeSigners() + return je.getCodeSigners(); + } } public interface URLJarFileCloseController { diff --git a/test/jdk/sun/net/www/protocol/jar/JarURLConnectionCertsAndCodeSigners.java b/test/jdk/sun/net/www/protocol/jar/JarURLConnectionCertsAndCodeSigners.java new file mode 100644 index 00000000000..9b786938e10 --- /dev/null +++ b/test/jdk/sun/net/www/protocol/jar/JarURLConnectionCertsAndCodeSigners.java @@ -0,0 +1,182 @@ +/* + * Copyright (c) 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. + */ + +import java.io.InputStream; +import java.io.OutputStream; +import java.net.JarURLConnection; +import java.net.URI; +import java.net.URLConnection; +import java.nio.file.Files; +import java.nio.file.Path; +import java.security.CodeSigner; +import java.security.KeyStore; +import java.security.cert.Certificate; +import java.security.cert.X509Certificate; +import java.util.List; +import java.util.concurrent.TimeUnit; +import java.util.jar.Attributes; +import java.util.jar.JarEntry; +import java.util.jar.JarOutputStream; +import java.util.jar.Manifest; +import java.util.zip.ZipFile; + +import jdk.security.jarsigner.JarSigner; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import sun.security.tools.keytool.CertAndKeyGen; +import sun.security.x509.X500Name; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; + +/* + * @test + * @bug 8378003 + * @summary Verify that JarURLConnection.getCertificates() and + * JarURLConnection.getJarEntry().getCodeSigners() returns the + * expected results for entries in a signed JAR file + * @modules java.base/sun.security.x509 + * java.base/sun.security.tools.keytool + * @run junit ${test.main.class} + */ +class JarURLConnectionCertsAndCodeSigners { + + private static final String JAR_ENTRY_NAME = "foo-bar"; + private static final String CERT_SUBJECT = "CN=duke"; + private static Path SIGNED_JAR; + + @BeforeAll + static void beforeAll() throws Exception { + final KeyStore.PrivateKeyEntry key = generatePrivateKey(); + SIGNED_JAR = createSignedJar(key); + } + + /* + * Verifies that JarURLConnection.getCertificates() returns the correct + * certificates for entries in a signed JAR file. + */ + @Test + void testCertificates() throws Exception { + final URI uri = new URI("jar:" + SIGNED_JAR.toUri() + "!/" + JAR_ENTRY_NAME); + System.err.println("running test against signed JAR entry: " + uri); + final URLConnection urlConn = uri.toURL().openConnection(); + assertInstanceOf(JarURLConnection.class, urlConn, "unexpected URLConnection type"); + final JarURLConnection jarURLConn = (JarURLConnection) urlConn; + try (InputStream is = jarURLConn.getInputStream()) { + is.readAllBytes(); + } + Certificate[] prevIterationCerts = null; + for (int i = 1; i <= 2; i++) { + final Certificate[] certs = jarURLConn.getCertificates(); + assertNotNull(certs, "null certificates for signed JAR entry: " + uri); + assertNotEquals(0, certs.length, "empty certificates for signed JAR entry: " + uri); + assertInstanceOf(X509Certificate.class, certs[0], "unexpected certificate type"); + final String subject = ((X509Certificate) certs[0]).getSubjectX500Principal().getName(); + assertEquals(CERT_SUBJECT, subject, "unexpected subject in certificate"); + if (i > 1) { + // verify that each call to getCertificates() returns + // a new instance of the array. + // intentional identity check + assertNotSame(prevIterationCerts, certs, "getCertificates() did not return" + + " a new array"); + } + prevIterationCerts = certs; + } + } + + /* + * Verifies that JarURLConnection.getJarEntry().getCodeSigners() returns the correct + * codesigners for entries in a signed JAR file. + */ + @Test + void testCodeSigners() throws Exception { + final URI uri = new URI("jar:" + SIGNED_JAR.toUri() + "!/" + JAR_ENTRY_NAME); + System.err.println("running test against signed JAR entry: " + uri); + final URLConnection urlConn = uri.toURL().openConnection(); + assertInstanceOf(JarURLConnection.class, urlConn, "unexpected URLConnection type"); + final JarURLConnection jarURLConn = (JarURLConnection) urlConn; + try (InputStream is = jarURLConn.getInputStream()) { + is.readAllBytes(); + } + CodeSigner[] prevIterationCodeSigners = null; + for (int i = 1; i <= 2; i++) { + final CodeSigner[] codeSigners = jarURLConn.getJarEntry().getCodeSigners(); + assertNotNull(codeSigners, "null codesigners for signed JAR entry: " + uri); + assertNotEquals(0, codeSigners.length, "empty codesigners for signed JAR entry: " + uri); + final List certs = codeSigners[0].getSignerCertPath().getCertificates(); + assertNotNull(certs, "null certificates from codesigner"); + assertNotEquals(0, certs.size(), "empty certificates from codesigner"); + assertInstanceOf(X509Certificate.class, certs.getFirst(), "unexpected certificate type"); + final String subject = ((X509Certificate) certs.getFirst()).getSubjectX500Principal().getName(); + assertEquals(CERT_SUBJECT, subject, "unexpected subject in certificate"); + if (i > 1) { + // verify that each call to getCodeSigners() returns + // a new instance of the array. + // intentional identity check + assertNotSame(prevIterationCodeSigners, codeSigners, "getCodeSigners() did not" + + " return a new array"); + } + prevIterationCodeSigners = codeSigners; + } + } + + private static KeyStore.PrivateKeyEntry generatePrivateKey() throws Exception { + final CertAndKeyGen gen = new CertAndKeyGen("RSA", "SHA256withRSA"); + gen.generate(1048); // Small key size makes test run faster + final long oneDay = TimeUnit.DAYS.toSeconds(1); + final Certificate cert = gen.getSelfCertificate(new X500Name(CERT_SUBJECT), oneDay); + return new KeyStore.PrivateKeyEntry(gen.getPrivateKey(), new Certificate[]{cert}); + } + + private static Path createSignedJar(final KeyStore.PrivateKeyEntry privateKey) + throws Exception { + + // first create a unsigned JAR + final Path unsignedJar = Path.of("test-8377985-unsigned.jar"); + final Manifest manifest = new Manifest(); + final Attributes mainAttributes = manifest.getMainAttributes(); + mainAttributes.putValue("Manifest-Version", "1.0"); + try (OutputStream os = Files.newOutputStream(unsignedJar); + JarOutputStream jaros = new JarOutputStream(os, manifest)) { + jaros.putNextEntry(new JarEntry(JAR_ENTRY_NAME)); + jaros.write(new byte[]{0x42}); + jaros.closeEntry(); + } + + // use a JarSigner to sign the JAR + final JarSigner signer = new JarSigner.Builder(privateKey) + .signerName("abcdef") + .digestAlgorithm("SHA-256") + .signatureAlgorithm("SHA256withRSA") + .build(); + + final Path signedJar = Path.of("test-8377985-signed.jar"); + try (ZipFile zip = new ZipFile(unsignedJar.toFile()); + OutputStream out = Files.newOutputStream(signedJar)) { + signer.sign(zip, out); + } + return signedJar; + } +} From 72b28672ad2f0f70cf57c9dc753b0ba20f6bcaaa Mon Sep 17 00:00:00 2001 From: Volkan Yazici Date: Fri, 20 Feb 2026 16:26:18 +0000 Subject: [PATCH 27/63] 8367129: Move input validation checks to Java for java.lang.StringLatin1 intrinsics Reviewed-by: rriggs, rgiulietti --- src/hotspot/share/classfile/vmIntrinsics.hpp | 24 +- src/hotspot/share/opto/library_call.cpp | 18 +- .../share/classes/java/lang/StringLatin1.java | 287 ++++++++++++-- .../share/classes/java/lang/StringUTF16.java | 350 +++++++++++++++--- .../patches/java.base/java/lang/Helper.java | 2 +- 5 files changed, 567 insertions(+), 114 deletions(-) diff --git a/src/hotspot/share/classfile/vmIntrinsics.hpp b/src/hotspot/share/classfile/vmIntrinsics.hpp index 75592fd61c8..29cb5d737d8 100644 --- a/src/hotspot/share/classfile/vmIntrinsics.hpp +++ b/src/hotspot/share/classfile/vmIntrinsics.hpp @@ -257,6 +257,7 @@ class methodHandle; do_intrinsic(_bitCount_i, java_lang_Integer, bitCount_name, int_int_signature, F_S) \ do_intrinsic(_bitCount_l, java_lang_Long, bitCount_name, long_int_signature, F_S) \ do_intrinsic(_compress_i, java_lang_Integer, compress_name, int2_int_signature, F_S) \ + do_name( compress_name, "compress") \ do_intrinsic(_compress_l, java_lang_Long, compress_name, long2_long_signature, F_S) \ do_intrinsic(_expand_i, java_lang_Integer, expand_name, int2_int_signature, F_S) \ do_intrinsic(_expand_l, java_lang_Long, expand_name, long2_long_signature, F_S) \ @@ -358,11 +359,11 @@ class methodHandle; do_name( vectorizedHashCode_name, "vectorizedHashCode") \ do_signature(vectorizedHashCode_signature, "(Ljava/lang/Object;IIII)I") \ \ - do_intrinsic(_compressStringC, java_lang_StringUTF16, compress_name, encodeISOArray_signature, F_S) \ - do_name( compress_name, "compress") \ - do_intrinsic(_compressStringB, java_lang_StringUTF16, compress_name, indexOfI_signature, F_S) \ + do_intrinsic(_compressStringC, java_lang_StringUTF16, compressString_name, encodeISOArray_signature, F_S) \ + do_name( compressString_name, "compress0") \ + do_intrinsic(_compressStringB, java_lang_StringUTF16, compressString_name, indexOfI_signature, F_S) \ do_intrinsic(_inflateStringC, java_lang_StringLatin1, inflate_name, inflateC_signature, F_S) \ - do_name( inflate_name, "inflate") \ + do_name( inflate_name, "inflate0") \ do_signature(inflateC_signature, "([BI[CII)V") \ do_intrinsic(_inflateStringB, java_lang_StringLatin1, inflate_name, inflateB_signature, F_S) \ do_signature(inflateB_signature, "([BI[BII)V") \ @@ -381,9 +382,9 @@ class methodHandle; do_intrinsic(_compareToLU, java_lang_StringLatin1,compareToLU_name, compareTo_indexOf_signature, F_S) \ do_intrinsic(_compareToUL, java_lang_StringUTF16, compareToUL_name, compareTo_indexOf_signature, F_S) \ do_signature(compareTo_indexOf_signature, "([B[B)I") \ - do_name( compareTo_name, "compareTo") \ - do_name( compareToLU_name, "compareToUTF16") \ - do_name( compareToUL_name, "compareToLatin1") \ + do_name( compareTo_name, "compareTo0") \ + do_name( compareToLU_name, "compareToUTF16_0") \ + do_name( compareToUL_name, "compareToLatin1_0") \ do_intrinsic(_indexOfL, java_lang_StringLatin1,indexOf_name, compareTo_indexOf_signature, F_S) \ do_intrinsic(_indexOfU, java_lang_StringUTF16, indexOf_name, compareTo_indexOf_signature, F_S) \ do_intrinsic(_indexOfUL, java_lang_StringUTF16, indexOfUL_name, compareTo_indexOf_signature, F_S) \ @@ -392,12 +393,13 @@ class methodHandle; do_intrinsic(_indexOfIUL, java_lang_StringUTF16, indexOfUL_name, indexOfI_signature, F_S) \ do_intrinsic(_indexOfU_char, java_lang_StringUTF16, indexOfChar_name, indexOfChar_signature, F_S) \ do_intrinsic(_indexOfL_char, java_lang_StringLatin1,indexOfChar_name, indexOfChar_signature, F_S) \ - do_name( indexOf_name, "indexOf") \ - do_name( indexOfChar_name, "indexOfChar") \ - do_name( indexOfUL_name, "indexOfLatin1") \ + do_name( indexOf_name, "indexOf0") \ + do_name( indexOfChar_name, "indexOfChar0") \ + do_name( indexOfUL_name, "indexOfLatin1_0") \ do_signature(indexOfI_signature, "([BI[BII)I") \ do_signature(indexOfChar_signature, "([BIII)I") \ - do_intrinsic(_equalsL, java_lang_StringLatin1,equals_name, equalsB_signature, F_S) \ + do_intrinsic(_equalsL, java_lang_StringLatin1,equalsString_name, equalsB_signature, F_S) \ + do_name( equalsString_name, "equals0") \ \ do_intrinsic(_isDigit, java_lang_CharacterDataLatin1, isDigit_name, int_bool_signature, F_R) \ do_name( isDigit_name, "isDigit") \ diff --git a/src/hotspot/share/opto/library_call.cpp b/src/hotspot/share/opto/library_call.cpp index b4e18b596e4..3627d06a87a 100644 --- a/src/hotspot/share/opto/library_call.cpp +++ b/src/hotspot/share/opto/library_call.cpp @@ -1307,8 +1307,8 @@ bool LibraryCallKit::inline_string_indexOfI(StrIntrinsicNode::ArgEnc ae) { Node* tgt_start = array_element_address(tgt, intcon(0), T_BYTE); // Range checks - generate_string_range_check(src, src_offset, src_count, ae != StrIntrinsicNode::LL); - generate_string_range_check(tgt, intcon(0), tgt_count, ae == StrIntrinsicNode::UU); + generate_string_range_check(src, src_offset, src_count, ae != StrIntrinsicNode::LL, true); + generate_string_range_check(tgt, intcon(0), tgt_count, ae == StrIntrinsicNode::UU, true); if (stopped()) { return true; } @@ -1404,7 +1404,7 @@ bool LibraryCallKit::inline_string_indexOfChar(StrIntrinsicNode::ArgEnc ae) { Node* src_count = _gvn.transform(new SubINode(max, from_index)); // Range checks - generate_string_range_check(src, src_offset, src_count, ae == StrIntrinsicNode::U); + generate_string_range_check(src, src_offset, src_count, ae == StrIntrinsicNode::U, true); // Check for int_ch >= 0 Node* int_ch_cmp = _gvn.transform(new CmpINode(int_ch, intcon(0))); @@ -1448,11 +1448,11 @@ bool LibraryCallKit::inline_string_indexOfChar(StrIntrinsicNode::ArgEnc ae) { } //---------------------------inline_string_copy--------------------- // compressIt == true --> generate a compressed copy operation (compress char[]/byte[] to byte[]) -// int StringUTF16.compress(char[] src, int srcOff, byte[] dst, int dstOff, int len) -// int StringUTF16.compress(byte[] src, int srcOff, byte[] dst, int dstOff, int len) +// int StringUTF16.compress0(char[] src, int srcOff, byte[] dst, int dstOff, int len) +// int StringUTF16.compress0(byte[] src, int srcOff, byte[] dst, int dstOff, int len) // compressIt == false --> generate an inflated copy operation (inflate byte[] to char[]/byte[]) -// void StringLatin1.inflate(byte[] src, int srcOff, char[] dst, int dstOff, int len) -// void StringLatin1.inflate(byte[] src, int srcOff, byte[] dst, int dstOff, int len) +// void StringLatin1.inflate0(byte[] src, int srcOff, char[] dst, int dstOff, int len) +// void StringLatin1.inflate0(byte[] src, int srcOff, byte[] dst, int dstOff, int len) bool LibraryCallKit::inline_string_copy(bool compress) { if (too_many_traps(Deoptimization::Reason_intrinsic)) { return false; @@ -1495,8 +1495,8 @@ bool LibraryCallKit::inline_string_copy(bool compress) { } // Range checks - generate_string_range_check(src, src_offset, length, convert_src); - generate_string_range_check(dst, dst_offset, length, convert_dst); + generate_string_range_check(src, src_offset, length, convert_src, true); + generate_string_range_check(dst, dst_offset, length, convert_dst, true); if (stopped()) { return true; } diff --git a/src/java.base/share/classes/java/lang/StringLatin1.java b/src/java.base/share/classes/java/lang/StringLatin1.java index 21a8b2dd61a..adfd9c6dbab 100644 --- a/src/java.base/share/classes/java/lang/StringLatin1.java +++ b/src/java.base/share/classes/java/lang/StringLatin1.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 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 @@ -27,6 +27,7 @@ package java.lang; import java.util.Arrays; import java.util.Locale; +import java.util.Objects; import java.util.Spliterator; import java.util.function.Consumer; import java.util.function.IntConsumer; @@ -39,12 +40,22 @@ import jdk.internal.vm.annotation.IntrinsicCandidate; import static java.lang.String.LATIN1; import static java.lang.String.UTF16; -import static java.lang.String.checkIndex; -import static java.lang.String.checkOffset; +/** + * Latin-1 string operations. + *

    + * Unless stated otherwise, all methods assume that + *

      + *
    • {@code byte[]} arguments denote a Latin-1 string byte array + *
    • indices, offsets, and lengths (typically of type {@code int}) are in + * number of characters, i.e., the number of {@code byte}s/{@code char}s for + * Latin-1 strings, and the number of Unicode + * code units for UTF-16 strings + *
    + */ final class StringLatin1 { static char charAt(byte[] value, int index) { - checkIndex(index, value.length); + String.checkIndex(index, value.length); return (char)(value[index] & 0xff); } @@ -84,8 +95,23 @@ final class StringLatin1 { System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); } - @IntrinsicCandidate + /** + * {@return {@code true} if provided byte arrays contain identical content; {@code false} otherwise}. + * + * @param value a byte array + * @param other a byte array + * + * @throws NullPointerException if {@code value} or {@code other} is null + */ static boolean equals(byte[] value, byte[] other) { + Objects.requireNonNull(value); + Objects.requireNonNull(other); + return equals0(value, other); + } + + // vmIntrinsics::_equalsL + @IntrinsicCandidate + private static boolean equals0(byte[] value, byte[] other) { if (value.length == other.length) { for (int i = 0; i < value.length; i++) { if (value[i] != other[i]) { @@ -97,33 +123,102 @@ final class StringLatin1 { return false; } - @IntrinsicCandidate + /** + * Lexicographically compares two Latin-1 strings as specified in + * {@link String#compareTo(String) String::compareTo}. + * + * @param value a Latin-1 string byte array + * @param other a Latin-1 string byte array + * + * @return {@code 0} if {@code value} is equal to {@code other}, a value + * less than {@code 0} if {@code value} is lexicographically less than + * {@code other}; a value greater than {@code 0} otherwise. + * + * @throws NullPointerException if {@code value} or {@code other} is null + */ static int compareTo(byte[] value, byte[] other) { - int len1 = value.length; - int len2 = other.length; - return compareTo(value, other, len1, len2); + Objects.requireNonNull(value); + Objects.requireNonNull(other); + return compareTo0(value, other); } + // vmIntrinsics::_compareToL + @IntrinsicCandidate + private static int compareTo0(byte[] value, byte[] other) { + return compareTo(value, other, value.length, other.length); + } + + /** + * Lexicographically compares two Latin-1 string prefixes as specified in + * {@link String#compareTo(String) String::compareTo}. + * + * @param value a Latin-1 string byte array + * @param other a Latin-1 string byte array + * @param len1 the number of characters in {@code value} to compare + * @param len2 the number of characters in {@code other} to compare + * + * @return {@code 0} if the {@code value} prefix is equal to the + * {@code other} prefix, a value less than {@code 0} if the {@code value} + * prefix is lexicographically less than the {@code other} prefix; a + * value greater than {@code 0} otherwise. + * + * @throws NullPointerException if {@code value} or {@code other} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ static int compareTo(byte[] value, byte[] other, int len1, int len2) { + Objects.requireNonNull(value); + Objects.requireNonNull(other); + String.checkOffset(len1, length(value)); + String.checkOffset(len2, length(other)); int lim = Math.min(len1, len2); int k = ArraysSupport.mismatch(value, other, lim); return (k < 0) ? len1 - len2 : getChar(value, k) - getChar(other, k); } - @IntrinsicCandidate + /** + * Lexicographically compares a Latin-1 string to a UTF-16 string as + * specified in {@link String#compareTo(String) String::compareTo}. + * + * @param value a Latin-1 string byte array + * @param other a UTF-16 string byte array + * + * @return {@code 0} if the {@code value} is equal to the {@code other}, a + * value less than {@code 0} if the {@code value} is lexicographically less + * than the {@code other}; a value greater than {@code 0} otherwise. + * + * @throws NullPointerException if {@code value} or {@code other} is null + */ static int compareToUTF16(byte[] value, byte[] other) { + Objects.requireNonNull(value); + Objects.requireNonNull(other); + return compareToUTF16_0(value, other); + } + + // vmIntrinsics::_compareToLU + @IntrinsicCandidate + private static int compareToUTF16_0(byte[] value, byte[] other) { int len1 = length(value); int len2 = StringUTF16.length(other); return compareToUTF16Values(value, other, len1, len2); } - /* - * Checks the boundary and then compares the byte arrays. + /** + * Lexicographically compares a Latin-1 string prefix to a UTF-16 one as + * specified in {@link String#compareTo(String) String::compareTo}. + * + * @param value a Latin-1 string byte array + * @param other a UTF-16 string byte array + * @param len1 the number of characters in {@code value} to compare + * @param len2 the number of characters in {@code other} to compare + * + * @throws NullPointerException if {@code value} or {@code other} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds */ static int compareToUTF16(byte[] value, byte[] other, int len1, int len2) { - checkOffset(len1, length(value)); - checkOffset(len2, StringUTF16.length(other)); - + Objects.requireNonNull(value); + Objects.requireNonNull(other); + String.checkOffset(len1, length(value)); + String.checkOffset(len2, StringUTF16.length(other)); return compareToUTF16Values(value, other, len1, len2); } @@ -139,9 +234,12 @@ final class StringLatin1 { return len1 - len2; } + /** + * Case-insensitive {@link #compareTo(byte[], byte[]) compareTo}. + */ static int compareToCI(byte[] value, byte[] other) { - int len1 = value.length; - int len2 = other.length; + int len1 = value.length; // Implicit null check on `value` + int len2 = other.length; // Implicit null check on `other` int lim = Math.min(len1, len2); for (int k = 0; k < lim; k++) { if (value[k] != other[k]) { @@ -159,7 +257,12 @@ final class StringLatin1 { return len1 - len2; } + /** + * Case-insensitive {@link #compareToUTF16(byte[], byte[]) compareToUTF16}. + */ static int compareToCI_UTF16(byte[] value, byte[] other) { + Objects.requireNonNull(value); + Objects.requireNonNull(other); int len1 = length(value); int len2 = StringUTF16.length(other); int lim = Math.min(len1, len2); @@ -307,16 +410,34 @@ final class StringLatin1 { return ArraysSupport.hashCodeOfUnsigned(value, 0, value.length, 0); } - // Caller must ensure that from- and toIndex are within bounds + /** + * Finds the index of the first character matching the provided one in the + * given Latin-1 string byte array sub-range. {@code -1} is returned if the + * provided character cannot be encoded in Latin-1, or cannot be found in + * the target string sub-range. + * + * @param value a Latin-1 string byte array to search in + * @param ch a character to search for + * @param fromIndex the index (inclusive) of the first character in the sub-range + * @param toIndex the index (exclusive) of the last character in the sub-range + * + * @return the index of the first character matching the provided one in the + * given target string sub-range; {@code -1} otherwise + * + * @throws NullPointerException if {@code value} is null + * @throws StringIndexOutOfBoundsException if the sub-range is out of bounds + */ static int indexOf(byte[] value, int ch, int fromIndex, int toIndex) { + String.checkBoundsBeginEnd(fromIndex, toIndex, value.length); // Implicit null check on `value` if (!canEncode(ch)) { return -1; } - return indexOfChar(value, ch, fromIndex, toIndex); + return indexOfChar0(value, ch, fromIndex, toIndex); } + // vmIntrinsics::_indexOfL_char @IntrinsicCandidate - private static int indexOfChar(byte[] value, int ch, int fromIndex, int max) { + private static int indexOfChar0(byte[] value, int ch, int fromIndex, int max) { byte c = (byte)ch; for (int i = fromIndex; i < max; i++) { if (value[i] == c) { @@ -326,22 +447,67 @@ final class StringLatin1 { return -1; } - @IntrinsicCandidate + /** + * Searches for the first occurrence of {@code str} in {@code value}, and, + * if found, returns the index of the first character of the matching + * {@code value} sub-range; {@code -1} otherwise. + * + * @param value a Latin-1 string byte array to search in + * @param str a Latin-1 string byte array to search for + * + * @return the index of the first character of the matching {@code value} + * sub-range if a match is found; {@code -1} otherwise + * + * @throws NullPointerException if {@code value} or {@code str} is null + */ static int indexOf(byte[] value, byte[] str) { - if (str.length == 0) { - return 0; - } - if (value.length == 0) { - return -1; - } - return indexOf(value, value.length, str, str.length, 0); + Objects.requireNonNull(value); + Objects.requireNonNull(str); + return indexOf0(value, str); } + // vmIntrinsics::_indexOfL @IntrinsicCandidate - static int indexOf(byte[] value, int valueCount, byte[] str, int strCount, int fromIndex) { + private static int indexOf0(byte[] value, byte[] str) { + return indexOf0(value, value.length, str, str.length, 0); + } + + /** + * Searches for the first occurrence of the given {@code str} sub-range in + * the given {@code value} sub-range, and, if found, returns the index of + * the first character of the matching {@code value} sub-range; {@code -1} + * otherwise. + * + * @param value a Latin-1 string byte array to search in + * @param valueToIndex the index (exclusive) of the last character in {@code value} + * @param str a Latin-1 string byte array to search for + * @param strToIndex the index (exclusive) of the last character in {@code str} + * @param valueFromIndex the index (inclusive) of the first character in {@code value} + * + * @return the index of the first character of the matching {@code value} + * sub-range if a match is found; {@code -1} otherwise + * + * @throws NullPointerException if {@code value} or {@code str} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ + static int indexOf(byte[] value, int valueToIndex, byte[] str, int strToIndex, int valueFromIndex) { + String.checkBoundsBeginEnd(valueFromIndex, valueToIndex, value.length); // Implicit null check on `value` + String.checkBoundsBeginEnd(0, strToIndex, str.length); // Implicit null check on `str` + return indexOf0(value, valueToIndex, str, strToIndex, valueFromIndex); + } + + // vmIntrinsics::_indexOfIL + @IntrinsicCandidate + private static int indexOf0(byte[] value, int valueToIndex, byte[] str, int strToIndex, int valueFromIndex) { + if (strToIndex == 0) { + return 0; + } + if ((valueToIndex - valueFromIndex) < strToIndex) { + return -1; + } byte first = str[0]; - int max = (valueCount - strCount); - for (int i = fromIndex; i <= max; i++) { + int max = (valueToIndex - strToIndex); + for (int i = valueFromIndex; i <= max; i++) { // Look for first character. if (value[i] != first) { while (++i <= max && value[i] != first); @@ -349,7 +515,7 @@ final class StringLatin1 { // Found first character, now look at the rest of value if (i <= max) { int j = i + 1; - int end = j + strCount - 1; + int end = j + strToIndex - 1; for (int k = 1; j < end && value[j] == str[k]; j++, k++); if (j == end) { // Found whole string. @@ -855,18 +1021,65 @@ final class StringLatin1 { LATIN1); } - // inflatedCopy byte[] -> char[] - @IntrinsicCandidate + /** + * Copies characters from a Latin-1 string byte array sub-range to the + * given {@code char} array sub-range. + *

    + * This effectively inflates the content from a 1 byte per + * character representation to a 2 byte one. + * + * @param src the source Latin-1 string byte array + * @param srcOff the index (inclusive) of the first character in {@code src} + * @param dst the target {@code char} array + * @param dstOff the index (inclusive) of the first character in {@code dst} + * @param len the maximum number of characters to copy + * + * @throws NullPointerException if {@code src} or {@code dst} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ static void inflate(byte[] src, int srcOff, char[] dst, int dstOff, int len) { + String.checkBoundsOffCount(srcOff, len, src.length); // Implicit null check on `src` + String.checkBoundsOffCount(dstOff, len, dst.length); // Implicit null check on `dst` + inflate0(src, srcOff, dst, dstOff, len); + } + + // vmIntrinsics::_inflateStringC + @IntrinsicCandidate + private static void inflate0(byte[] src, int srcOff, char[] dst, int dstOff, int len) { for (int i = 0; i < len; i++) { dst[dstOff++] = (char)(src[srcOff++] & 0xff); } } - // inflatedCopy byte[] -> byte[] - @IntrinsicCandidate + /** + * Copies characters from a Latin-1 string byte array sub-range to a UTF-16 + * one. + *

    + * This effectively inflates the content from a 1 byte per + * character representation to a 2 byte one. + * + * @param src the source Latin-1 string byte array + * @param srcOff the index (inclusive) of the first character in {@code src} + * @param dst the target UTF-16 string byte array + * @param dstOff the index (inclusive) of the first character in {@code dst} + * @param len the maximum number of characters to copy + * + * @throws NullPointerException if {@code src} or {@code dst} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ static void inflate(byte[] src, int srcOff, byte[] dst, int dstOff, int len) { - StringUTF16.inflate(src, srcOff, dst, dstOff, len); + String.checkBoundsOffCount(srcOff, len, src.length); // Implicit null check on `src` + Objects.requireNonNull(dst); + String.checkBoundsOffCount(dstOff, len, StringUTF16.length(dst)); + inflate0(src, srcOff, dst, dstOff, len); + } + + // vmIntrinsics::_inflateStringB + @IntrinsicCandidate + private static void inflate0(byte[] src, int srcOff, byte[] dst, int dstOff, int len) { + for (int i = 0; i < len; i++) { + StringUTF16.putChar(dst, dstOff++, src[srcOff++] & 0xff); + } } static class CharsSpliterator implements Spliterator.OfInt { diff --git a/src/java.base/share/classes/java/lang/StringUTF16.java b/src/java.base/share/classes/java/lang/StringUTF16.java index 75c9e8239ba..27b9ae54a8a 100644 --- a/src/java.base/share/classes/java/lang/StringUTF16.java +++ b/src/java.base/share/classes/java/lang/StringUTF16.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2025, Alibaba Group Holding Limited. All Rights Reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * @@ -28,6 +28,7 @@ package java.lang; import java.util.Arrays; import java.util.Locale; +import java.util.Objects; import java.util.Spliterator; import java.util.function.Consumer; import java.util.function.IntConsumer; @@ -49,8 +50,13 @@ import static java.lang.String.UTF16; /// it has the same endianness as a char, which is the platform endianness. /// This is ensured in the static initializer of StringUTF16. /// -/// All indices and sizes for byte arrays carrying UTF16 data are in number of -/// chars instead of number of bytes. +/// Unless stated otherwise, all methods assume that +/// +/// - `byte[]` arguments denote a UTF-16 string byte array +/// - indices, offsets, and lengths (typically of type `int`) are in number of +/// characters, i.e., the number of +/// [Unicode code units](Character.html#unicode) for UTF-16 strings, and the +/// number of `byte`s/`char`s for Latin-1 strings final class StringUTF16 { // Return a new byte array for a UTF16-coded string for len chars @@ -388,9 +394,33 @@ final class StringUTF16 { return n; } - // compressedCopy char[] -> byte[] - @IntrinsicCandidate + /** + * Copies the prefix of Latin-1 characters from a {@code char} array + * sub-range to a Latin-1 string byte array sub-range. + *

    + * This effectively compresses the content from a 2 byte per + * character representation to a 1 byte one. + * + * @param src the source {@code char} array + * @param srcOff the index (inclusive) of the first character in {@code src} + * @param dst the target Latin-1 string byte array + * @param dstOff the index (inclusive) of the first character in {@code dst} + * @param len the maximum number of characters to copy + * + * @return the number of characters copied + * + * @throws NullPointerException if {@code src} or {@code dst} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ static int compress(char[] src, int srcOff, byte[] dst, int dstOff, int len) { + String.checkBoundsOffCount(srcOff, len, src.length); // Implicit null check on `src` + String.checkBoundsOffCount(dstOff, len, dst.length); // Implicit null check on `dst` + return compress0(src, srcOff, dst, dstOff, len); + } + + // vmIntrinsics::_compressStringC + @IntrinsicCandidate + private static int compress0(char[] src, int srcOff, byte[] dst, int dstOff, int len) { for (int i = 0; i < len; i++) { char c = src[srcOff]; if (c > 0xff) { @@ -403,11 +433,34 @@ final class StringUTF16 { return len; } - // compressedCopy byte[] -> byte[] - @IntrinsicCandidate + /** + * Copies the prefix of Latin-1 characters from a UTF-16 string byte array + * sub-range to a Latin-1 one. + *

    + * This effectively compresses the content from a 2 byte per + * character representation to a 1 byte one. + * + * @param src the source UTF-16 string byte array + * @param srcOff the index (inclusive) of the first character in {@code src} + * @param dst the target Latin-1 string byte array + * @param dstOff the index (inclusive) of the first character in {@code dst} + * @param len the maximum number of characters to copy + * + * @return the number of characters copied + * + * @throws NullPointerException if {@code src} or {@code dst} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ static int compress(byte[] src, int srcOff, byte[] dst, int dstOff, int len) { - // We need a range check here because 'getChar' has no checks - checkBoundsOffCount(srcOff, len, src); + Objects.requireNonNull(src); + String.checkBoundsOffCount(srcOff, len, length(src)); + String.checkBoundsOffCount(dstOff, len, dst.length); // Implicit null check on `dst` + return compress0(src, srcOff, dst, dstOff, len); + } + + // vmIntrinsics::_compressStringB + @IntrinsicCandidate + private static int compress0(byte[] src, int srcOff, byte[] dst, int dstOff, int len) { for (int i = 0; i < len; i++) { char c = getChar(src, srcOff); if (c > 0xff) { @@ -446,7 +499,7 @@ final class StringUTF16 { static void getChars(byte[] value, int srcBegin, int srcEnd, char[] dst, int dstBegin) { // We need a range check here because 'getChar' has no checks if (srcBegin < srcEnd) { - checkBoundsOffCount(srcBegin, srcEnd - srcBegin, value); + String.checkBoundsOffCount(srcBegin, srcEnd - srcBegin, length(value)); } for (int i = srcBegin; i < srcEnd; i++) { dst[dstBegin++] = getChar(value, i); @@ -462,20 +515,50 @@ final class StringUTF16 { } } - @IntrinsicCandidate + /** + * Lexicographically compares two UTF-16 strings as specified in + * {@link String#compareTo(String) String::compareTo}. + * + * @param value a UTF-16 string byte array + * @param other a UTF-16 string byte array + * + * @return {@code 0} if {@code value} is equal to {@code other}, a value + * less than {@code 0} if {@code value} is lexicographically less than + * {@code other}; a value greater than {@code 0} otherwise. + * + * @throws NullPointerException if {@code value} or {@code other} is null + */ static int compareTo(byte[] value, byte[] other) { + Objects.requireNonNull(value); + Objects.requireNonNull(other); + return compareTo0(value, other); + } + + // vmIntrinsics::_compareToU + @IntrinsicCandidate + private static int compareTo0(byte[] value, byte[] other) { int len1 = length(value); int len2 = length(other); return compareValues(value, other, len1, len2); } - /* - * Checks the boundary and then compares the byte arrays. + /** + * Lexicographically compares two UTF-16 string prefixes as specified in + * {@link String#compareTo(String) String::compareTo}. + * + * @param value a UTF-16 string byte array + * @param other a UTF-16 string byte array + * @param len1 the number of characters in {@code value} to compare + * @param len2 the number of characters in {@code other} to compare + * + * @throws NullPointerException if {@code value} or {@code other} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds */ static int compareTo(byte[] value, byte[] other, int len1, int len2) { + Objects.requireNonNull(value); + Objects.requireNonNull(other); checkOffset(len1, value); checkOffset(len2, other); - return compareValues(value, other, len1, len2); } @@ -491,16 +574,58 @@ final class StringUTF16 { return len1 - len2; } - @IntrinsicCandidate + /** + * Lexicographically compares a UTF-16 string to a Latin-1 one as specified + * in {@link String#compareTo(String) String::compareTo}. + * + * @param value a UTF-16 string byte array + * @param other a Latin-1 string byte array + * + * @return {@code 0} if {@code value} is equal to {@code other}, a value + * less than {@code 0} if {@code value} is lexicographically less than + * {@code other}; a value greater than {@code 0} otherwise. + * + * @throws NullPointerException if {@code value} or {@code other} is null + */ static int compareToLatin1(byte[] value, byte[] other) { + Objects.requireNonNull(value); + Objects.requireNonNull(other); + return compareToLatin1_0(value, other); + } + + // vmIntrinsics::_compareToUL + @IntrinsicCandidate + private static int compareToLatin1_0(byte[] value, byte[] other) { return -StringLatin1.compareToUTF16(other, value); } + /** + * Lexicographically compares a UTF-16 string prefix to a Latin-1 one as + * specified in {@link String#compareTo(String) String::compareTo}. + * + * @param value a UTF-16 string byte array + * @param other a Latin-1 string byte array + * @param len1 the number of characters from {@code value} to compare + * @param len2 the number of characters from {@code other} to compare + * + * @return {@code 0} if the {@code value} prefix is equal to the + * {@code other} prefix, a value less than {@code 0} if the {@code value} + * prefix is lexicographically less than the {@code other} prefix; a + * value greater than {@code 0} otherwise. + * + * @throws NullPointerException if {@code value} or {@code other} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ static int compareToLatin1(byte[] value, byte[] other, int len1, int len2) { return -StringLatin1.compareToUTF16(other, value, len2, len1); } + /** + * Case-insensitive {@link #compareTo(byte[], byte[]) compareTo}. + */ static int compareToCI(byte[] value, byte[] other) { + Objects.requireNonNull(value); + Objects.requireNonNull(other); return compareToCIImpl(value, 0, length(value), other, 0, length(other)); } @@ -589,6 +714,9 @@ final class StringUTF16 { return cp; } + /** + * Case-insensitive {@link #compareToLatin1(byte[], byte[]) compareToLatin1}. + */ static int compareToCI_Latin1(byte[] value, byte[] other) { return -StringLatin1.compareToCI_UTF16(other, value); } @@ -668,19 +796,52 @@ final class StringUTF16 { return ArraysSupport.hashCodeOfUTF16(value, 0, value.length >> 1, 0); } - // Caller must ensure that from- and toIndex are within bounds + /** + * {@return the index of the first character matching the provided one in + * the given UTF-16 string byte array sub-range; {@code -1} otherwise} + * + * @param value a UTF-16 string byte array to search in + * @param ch a character to search for + * @param fromIndex the index (inclusive) of the first character in the sub-range + * @param toIndex the index (exclusive) of the last character in the sub-range + * + * @throws NullPointerException if {@code value} is null + * @throws StringIndexOutOfBoundsException if the sub-range is out of bounds + */ static int indexOf(byte[] value, int ch, int fromIndex, int toIndex) { + Objects.requireNonNull(value); + checkBoundsBeginEnd(fromIndex, toIndex, value); if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { // handle most cases here (ch is a BMP code point or a // negative value (invalid code point)) - return indexOfChar(value, ch, fromIndex, toIndex); + return indexOfChar0(value, ch, fromIndex, toIndex); } else { return indexOfSupplementary(value, ch, fromIndex, toIndex); } } - @IntrinsicCandidate + /** + * Searches for the first occurrence of {@code str} in {@code value}, and, + * if found, returns the index of the first character of the matching + * {@code value} sub-range; {@code -1} otherwise. + * + * @param value a UTF-16 string byte array to search in + * @param str a UTF-16 string byte array to search for + * + * @return the index of the first character of the matching {@code value} + * sub-range if a match is found; {@code -1} otherwise + * + * @throws NullPointerException if {@code value} or {@code str} is null + */ static int indexOf(byte[] value, byte[] str) { + Objects.requireNonNull(value); + Objects.requireNonNull(str); + return indexOf0(value, str); + } + + // vmIntrinsics::_indexOfU + @IntrinsicCandidate + private static int indexOf0(byte[] value, byte[] str) { if (str.length == 0) { return 0; } @@ -690,22 +851,58 @@ final class StringUTF16 { return indexOfUnsafe(value, length(value), str, length(str), 0); } - @IntrinsicCandidate - static int indexOf(byte[] value, int valueCount, byte[] str, int strCount, int fromIndex) { - checkBoundsBeginEnd(fromIndex, valueCount, value); - checkBoundsBeginEnd(0, strCount, str); - return indexOfUnsafe(value, valueCount, str, strCount, fromIndex); + /** + * Searches for the first occurrence of the given {@code str} sub-range in + * the given {@code value} sub-range, and, if found, returns the index of + * the first character of the matching {@code value} sub-range; {@code -1} + * otherwise. + * + * @param value a UTF-16 string byte array to search in + * @param valueToIndex the index (exclusive) of the last character in {@code value} + * @param str a UTF-16 string byte array to search for + * @param strToIndex the index (exclusive) of the last character in {@code str} + * @param valueFromIndex the index (inclusive) of the first character in {@code value} + * + * @return the index of the first character of the matching {@code value} + * sub-range if a match is found; {@code -1} otherwise + * + * @throws NullPointerException if {@code value} or {@code str} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ + static int indexOf(byte[] value, int valueToIndex, byte[] str, int strToIndex, int valueFromIndex) { + Objects.requireNonNull(value); + checkBoundsBeginEnd(valueFromIndex, valueToIndex, value); + Objects.requireNonNull(str); + checkBoundsBeginEnd(0, strToIndex, str); + return indexOf0(value, valueToIndex, str, strToIndex, valueFromIndex); } + // vmIntrinsics::_indexOfIU + @IntrinsicCandidate + private static int indexOf0(byte[] value, int valueToIndex, byte[] str, int strToIndex, int valueFromIndex) { + if (strToIndex == 0) { + return 0; + } + if ((valueToIndex - valueFromIndex) < strToIndex) { + return -1; + } + return indexOfUnsafe(value, valueToIndex, str, strToIndex, valueFromIndex); + } - private static int indexOfUnsafe(byte[] value, int valueCount, byte[] str, int strCount, int fromIndex) { - assert fromIndex >= 0; - assert strCount > 0; - assert strCount <= length(str); - assert valueCount >= strCount; + // This method has the following assumptions on its inputs: + // + // - Arrays are not null + // - Sub-ranges are valid + // - The `str` sub-range is not empty + // - The `value` sub-range length is greater than or equal to the `str` sub-range length + private static int indexOfUnsafe(byte[] value, int valueToIndex, byte[] str, int strToIndex, int valueFromIndex) { + assert valueFromIndex >= 0; + assert strToIndex > 0; + assert strToIndex <= length(str); + assert (valueToIndex - valueFromIndex) >= strToIndex; char first = getChar(str, 0); - int max = (valueCount - strCount); - for (int i = fromIndex; i <= max; i++) { + int max = (valueToIndex - strToIndex); + for (int i = valueFromIndex; i <= max; i++) { // Look for first character. if (getChar(value, i) != first) { while (++i <= max && getChar(value, i) != first); @@ -713,7 +910,7 @@ final class StringUTF16 { // Found first character, now look at the rest of value if (i <= max) { int j = i + 1; - int end = j + strCount - 1; + int end = j + strToIndex - 1; for (int k = 1; j < end && getChar(value, j) == getChar(str, k); j++, k++); if (j == end) { // Found whole string. @@ -724,12 +921,29 @@ final class StringUTF16 { return -1; } - /** - * Handles indexOf Latin1 substring in UTF16 string. + * Searches for the first occurrence of the given Latin-1 string byte array + * {@code str} in the given UTF-16 string byte array {@code value}, and, if + * found, returns the index of the first character of the matching + * {@code value} sub-range; {@code -1} otherwise. + * + * @param value a UTF-16 string byte array to search in + * @param str a Latin-1 string byte array to search for + * + * @return the index of the first character of the matching {@code value} + * sub-range if a match is found; {@code -1} otherwise + * + * @throws NullPointerException if {@code value} or {@code str} is null */ - @IntrinsicCandidate static int indexOfLatin1(byte[] value, byte[] str) { + Objects.requireNonNull(value); + Objects.requireNonNull(str); + return indexOfLatin1_0(value, str); + } + + // vmIntrinsics::_indexOfUL + @IntrinsicCandidate + private static int indexOfLatin1_0(byte[] value, byte[] str) { if (str.length == 0) { return 0; } @@ -739,18 +953,54 @@ final class StringUTF16 { return indexOfLatin1Unsafe(value, length(value), str, str.length, 0); } - @IntrinsicCandidate - static int indexOfLatin1(byte[] src, int srcCount, byte[] tgt, int tgtCount, int fromIndex) { - checkBoundsBeginEnd(fromIndex, srcCount, src); - String.checkBoundsBeginEnd(0, tgtCount, tgt.length); - return indexOfLatin1Unsafe(src, srcCount, tgt, tgtCount, fromIndex); + /** + * Searches for the first occurrence of the given Latin-1 string byte array + * {@code tgt} sub-range in the given UTF-16 string byte array {@code src} + * sub-range, and, if found, returns the index of the first character in + * {@code src}; {@code -1} otherwise. + * + * @param src a UTF-16 string byte array to search in + * @param srcToIndex the index (exclusive) of the last character in {@code src} + * @param tgt a Latin-1 string byte array to search for + * @param tgtToIndex the index (exclusive) of the last character in {@code tgt} + * @param tgtFromIndex the index (inclusive) of the first character in {@code src} + * + * @return the index of the first character of the matching {@code src} + * sub-range if a match is found; {@code -1} otherwise + * + * @throws NullPointerException if {@code src} or {@code tgt} is null + * @throws StringIndexOutOfBoundsException if the sub-ranges are out of bounds + */ + static int indexOfLatin1(byte[] src, int srcToIndex, byte[] tgt, int tgtToIndex, int tgtFromIndex) { + Objects.requireNonNull(src); + checkBoundsBeginEnd(tgtFromIndex, srcToIndex, src); + String.checkBoundsBeginEnd(0, tgtToIndex, tgt.length); + return indexOfLatin1_0(src, srcToIndex, tgt, tgtToIndex, tgtFromIndex); } - static int indexOfLatin1Unsafe(byte[] src, int srcCount, byte[] tgt, int tgtCount, int fromIndex) { + // vmIntrinsics::_indexOfIUL + @IntrinsicCandidate + private static int indexOfLatin1_0(byte[] src, int srcToIndex, byte[] tgt, int tgtToIndex, int srcFromIndex) { + if (tgtToIndex == 0) { + return 0; + } + if ((srcToIndex - srcFromIndex) < tgtToIndex) { + return -1; + } + return indexOfLatin1Unsafe(src, srcToIndex, tgt, tgtToIndex, srcFromIndex); + } + + // This method has the following assumptions on its inputs: + // + // - Arrays are not null + // - Sub-ranges are valid + // - The `tgt` sub-range is not empty + // - The `src` sub-range length is greater than or equal to the `tgt` sub-range length + private static int indexOfLatin1Unsafe(byte[] src, int srcCount, byte[] tgt, int tgtCount, int fromIndex) { assert fromIndex >= 0; assert tgtCount > 0; assert tgtCount <= tgt.length; - assert srcCount >= tgtCount; + assert (srcCount - fromIndex) >= tgtCount; char first = (char)(tgt[0] & 0xff); int max = (srcCount - tgtCount); for (int i = fromIndex; i <= max; i++) { @@ -774,8 +1024,9 @@ final class StringUTF16 { return -1; } + // vmIntrinsics::_indexOfU_char @IntrinsicCandidate - private static int indexOfChar(byte[] value, int ch, int fromIndex, int max) { + private static int indexOfChar0(byte[] value, int ch, int fromIndex, int max) { for (int i = fromIndex; i < max; i++) { if (getChar(value, i) == ch) { return i; @@ -1590,7 +1841,7 @@ final class StringUTF16 { } static boolean contentEquals(byte[] v1, byte[] v2, int len) { - checkBoundsOffCount(0, len, v2); + String.checkBoundsOffCount(0, len, length(v2)); for (int i = 0; i < len; i++) { if ((char)(v1[i] & 0xff) != getChar(v2, i)) { return false; @@ -1667,15 +1918,6 @@ final class StringUTF16 { } } - // inflatedCopy byte[] -> byte[] - static void inflate(byte[] src, int srcOff, byte[] dst, int dstOff, int len) { - // We need a range check here because 'putChar' has no checks - checkBoundsOffCount(dstOff, len, dst); - for (int i = 0; i < len; i++) { - putChar(dst, dstOff++, src[srcOff++] & 0xff); - } - } - // srcCoder == UTF16 && tgtCoder == LATIN1 static int lastIndexOfLatin1(byte[] src, int srcCount, byte[] tgt, int tgtCount, int fromIndex) { @@ -1742,8 +1984,4 @@ final class StringUTF16 { String.checkBoundsBeginEnd(begin, end, length(val)); } - static void checkBoundsOffCount(int offset, int count, byte[] val) { - String.checkBoundsOffCount(offset, count, length(val)); - } - } diff --git a/test/hotspot/jtreg/compiler/patches/java.base/java/lang/Helper.java b/test/hotspot/jtreg/compiler/patches/java.base/java/lang/Helper.java index 19eb98af3ba..0693d6b3df0 100644 --- a/test/hotspot/jtreg/compiler/patches/java.base/java/lang/Helper.java +++ b/test/hotspot/jtreg/compiler/patches/java.base/java/lang/Helper.java @@ -157,7 +157,7 @@ public class Helper { } public static void inflate(byte[] src, int srcOff, byte[] dst, int dstOff, int len) { - StringUTF16.inflate(src, srcOff, dst, dstOff, len); + StringLatin1.inflate(src, srcOff, dst, dstOff, len); } public static int indexOf(byte[] src, int srcCount, From 932f28c69b8573ad85fde2e0fa00cb3a46d93c2e Mon Sep 17 00:00:00 2001 From: Oli Gillespie Date: Fri, 20 Feb 2026 16:50:00 +0000 Subject: [PATCH 28/63] 8376698: Add Spliterator tests for TreeMap sub-maps Reviewed-by: liach, rriggs --- .../share/classes/java/util/TreeMap.java | 6 +++- ...SpliteratorTraversingAndSplittingTest.java | 28 +++++++++++++++++-- 2 files changed, 31 insertions(+), 3 deletions(-) diff --git a/src/java.base/share/classes/java/util/TreeMap.java b/src/java.base/share/classes/java/util/TreeMap.java index f8eea8c8d8f..8b6e9dc0bd6 100644 --- a/src/java.base/share/classes/java/util/TreeMap.java +++ b/src/java.base/share/classes/java/util/TreeMap.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 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 @@ -2138,10 +2138,12 @@ public class TreeMap return null; } public void forEachRemaining(Consumer action) { + Objects.requireNonNull(action); while (hasNext()) action.accept(next()); } public boolean tryAdvance(Consumer action) { + Objects.requireNonNull(action); if (hasNext()) { action.accept(next()); return true; @@ -2176,10 +2178,12 @@ public class TreeMap return null; } public void forEachRemaining(Consumer action) { + Objects.requireNonNull(action); while (hasNext()) action.accept(next()); } public boolean tryAdvance(Consumer action) { + Objects.requireNonNull(action); if (hasNext()) { action.accept(next()); return true; diff --git a/test/jdk/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java b/test/jdk/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java index ece63bfe813..c8f882b599d 100644 --- a/test/jdk/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java +++ b/test/jdk/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved. + * 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 @@ -126,12 +126,19 @@ public class SpliteratorTraversingAndSplittingTest extends SpliteratorTestHelper List exp; + List expRev; + Map mExp; + Map mExpRev; + SpliteratorDataBuilder(List data, List exp) { this.data = data; this.exp = exp; + this.expRev = new ArrayList<>(exp); + Collections.reverse(this.expRev); this.mExp = createMap(exp); + this.mExpRev = createMap(expRev); } Map createMap(List l) { @@ -166,12 +173,23 @@ public class SpliteratorTraversingAndSplittingTest extends SpliteratorTestHelper addMap(m, description); } + void addDescendingMap(Function, ? extends Map> m) { + String description = "new " + m.apply(Collections.emptyMap()).getClass().getName(); + addDescendingMap(m, description); + } + void addMap(Function, ? extends Map> m, String description) { add(description + ".keySet().spliterator()", () -> m.apply(mExp).keySet().spliterator()); add(description + ".values().spliterator()", () -> m.apply(mExp).values().spliterator()); add(description + ".entrySet().spliterator()", mExp.entrySet(), () -> m.apply(mExp).entrySet().spliterator()); } + void addDescendingMap(Function, ? extends Map> m, String description) { + add(description + ".keySet().spliterator()", expRev, () -> m.apply(mExp).keySet().spliterator()); + add(description + ".values().spliterator()", expRev, () -> m.apply(mExp).values().spliterator()); + add(description + ".entrySet().spliterator()", mExpRev.entrySet(), () -> m.apply(mExp).entrySet().spliterator()); + } + StringBuilder joiner(String description) { return new StringBuilder(description). append(" {"). @@ -639,8 +657,14 @@ public class SpliteratorTraversingAndSplittingTest extends SpliteratorTestHelper return cm; }, "new java.util.WeakHashMap(1, size + 1)"); - // @@@ Descending maps etc db.addMap(TreeMap::new); + db.addMap(m -> new TreeMap<>(m).tailMap(Integer.MIN_VALUE)); + db.addMap(m -> new TreeMap<>(m).headMap(Integer.MAX_VALUE)); + db.addMap(m -> new TreeMap<>(m).subMap(Integer.MIN_VALUE, Integer.MAX_VALUE)); + db.addDescendingMap(m -> new TreeMap<>(m).descendingMap()); + db.addDescendingMap(m -> new TreeMap<>(m).descendingMap().tailMap(Integer.MAX_VALUE)); + db.addDescendingMap(m -> new TreeMap<>(m).descendingMap().headMap(Integer.MIN_VALUE)); + db.addDescendingMap(m -> new TreeMap<>(m).descendingMap().subMap(Integer.MAX_VALUE, Integer.MIN_VALUE)); db.addMap(ConcurrentHashMap::new); From c1f8209cb2b0c3c959623d6002bf60566a24eac8 Mon Sep 17 00:00:00 2001 From: Daniel Fuchs Date: Fri, 20 Feb 2026 17:22:21 +0000 Subject: [PATCH 29/63] 8378163: test/jdk/java/net/httpclient/*.java: convert tests that use ITestContext to JUnit Reviewed-by: vyazici --- .../AbstractThrowingPushPromises.java | 39 ++- .../httpclient/AggregateRequestBodyTest.java | 224 +++++++++--------- .../java/net/httpclient/BasicHTTP2Test.java | 133 +++++------ .../java/net/httpclient/BasicHTTP3Test.java | 145 +++++++----- .../net/httpclient/CancelRequestTest.java | 159 ++++++------- .../httpclient/CancelStreamedBodyTest.java | 133 +++++------ .../net/httpclient/ForbiddenHeadTest.java | 135 ++++++----- .../net/httpclient/HeadersLowerCaseTest.java | 20 +- .../HttpInputStreamAvailableTest.java | 104 ++++---- .../HttpResponseInputStreamInterruptTest.java | 16 +- .../java/net/httpclient/ISO_8859_1_Test.java | 154 ++++++------ .../net/httpclient/ProxySelectorTest.java | 167 ++++++------- .../net/httpclient/Response204V2Test.java | 132 +++++------ .../net/httpclient/ShortResponseBody.java | 168 +++++++------ .../net/httpclient/ShortResponseBodyGet.java | 23 +- .../net/httpclient/ShortResponseBodyPost.java | 24 +- .../ShortResponseBodyPostWithRetry.java | 4 +- .../net/httpclient/SpecialHeadersTest.java | 168 +++++++------ .../java/net/httpclient/StreamingBody.java | 29 ++- 19 files changed, 979 insertions(+), 998 deletions(-) diff --git a/test/jdk/java/net/httpclient/AbstractThrowingPushPromises.java b/test/jdk/java/net/httpclient/AbstractThrowingPushPromises.java index ddd9c52fc58..1e8bc461d7f 100644 --- a/test/jdk/java/net/httpclient/AbstractThrowingPushPromises.java +++ b/test/jdk/java/net/httpclient/AbstractThrowingPushPromises.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 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 @@ -22,7 +22,7 @@ */ -/** +/* * This is not a test. Actual tests are implemented by concrete subclasses. * The abstract class AbstractThrowingPushPromises provides a base framework * to test what happens when push promise handlers and their @@ -62,7 +62,6 @@ import java.net.http.HttpResponse.BodySubscriber; import java.net.http.HttpResponse.PushPromiseHandler; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; -import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.concurrent.CompletableFuture; @@ -104,7 +103,6 @@ import org.junit.jupiter.api.extension.ExtensionContext; import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.api.extension.TestWatcher; -@TestInstance(TestInstance.Lifecycle.PER_CLASS) public abstract class AbstractThrowingPushPromises implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); @@ -193,14 +191,9 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters @AfterAll - static final void printFailedTests() { + static void printFailedTests() { out.println("\n========================="); try { - // Exceptions should already have been added to FAILURES - // var failed = context.getFailedTests().getAllResults().stream() - // .collect(Collectors.toMap(r -> name(r), ITestResult::getThrowable)); - // FAILURES.putAll(failed); - out.printf("%n%sCreated %d servers and %d clients%n", now(), serverCount.get(), clientCount.get()); if (FAILURES.isEmpty()) return; @@ -339,7 +332,7 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters HttpRequest req = request(uri); BodyHandler> handler = - new ThrowingBodyHandler((w) -> {}, + new ThrowingBodyHandler<>((w) -> {}, BodyHandlers.ofLines()); Map>>> pushPromises = new ConcurrentHashMap<>(); @@ -387,9 +380,9 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters } // @Test(dataProvider = "variants") - protected void testThrowingAsStringImpl(String uri, - boolean sameClient, - Thrower thrower) + void testThrowingAsStringImpl(String uri, + boolean sameClient, + Thrower thrower) throws Exception { String test = format("testThrowingAsString(%s, %b, %s)", @@ -399,7 +392,7 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters } //@Test(dataProvider = "variants") - protected void testThrowingAsLinesImpl(String uri, + void testThrowingAsLinesImpl(String uri, boolean sameClient, Thrower thrower) throws Exception @@ -411,9 +404,9 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters } //@Test(dataProvider = "variants") - protected void testThrowingAsInputStreamImpl(String uri, - boolean sameClient, - Thrower thrower) + void testThrowingAsInputStreamImpl(String uri, + boolean sameClient, + Thrower thrower) throws Exception { String test = format("testThrowingAsInputStream(%s, %b, %s)", @@ -424,7 +417,7 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters private void testThrowing(String name, String uri, boolean sameClient, Supplier> handlers, - Finisher finisher, Thrower thrower) + Finisher finisher, Thrower thrower) throws Exception { out.printf("%n%s%s%n", now(), name); @@ -438,7 +431,7 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters private void testThrowing(String uri, boolean sameClient, Supplier> handlers, - Finisher finisher, Thrower thrower) + Finisher finisher, Thrower thrower) throws Exception { HttpClient client = null; @@ -452,7 +445,7 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters ConcurrentMap>> promiseMap = new ConcurrentHashMap<>(); Supplier> throwing = () -> - new ThrowingBodyHandler(where.select(thrower), handlers.get()); + new ThrowingBodyHandler<>(where.select(thrower), handlers.get()); PushPromiseHandler pushHandler = new ThrowingPromiseHandler<>( where.select(thrower), PushPromiseHandler.of((r) -> throwing.get(), promiseMap)); @@ -540,7 +533,7 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters return check(w, reqURI, resp, thrower, promises, extractor); } - private final List check(Where w, URI reqURI, + private List check(Where w, URI reqURI, HttpResponse resp, Thrower thrower, Map>> promises, @@ -697,7 +690,7 @@ public abstract class AbstractThrowingPushPromises implements HttpServerAdapters public BodySubscriber apply(HttpResponse.ResponseInfo rinfo) { throwing.accept(Where.BODY_HANDLER); BodySubscriber subscriber = bodyHandler.apply(rinfo); - return new ThrowingBodySubscriber(throwing, subscriber); + return new ThrowingBodySubscriber<>(throwing, subscriber); } } diff --git a/test/jdk/java/net/httpclient/AggregateRequestBodyTest.java b/test/jdk/java/net/httpclient/AggregateRequestBodyTest.java index 608b6489181..175e860c229 100644 --- a/test/jdk/java/net/httpclient/AggregateRequestBodyTest.java +++ b/test/jdk/java/net/httpclient/AggregateRequestBodyTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 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 @@ -27,7 +27,7 @@ * @library /test/lib /test/jdk/java/net/httpclient/lib * @build jdk.test.lib.net.SimpleSSLContext jdk.httpclient.test.lib.common.HttpServerAdapters * ReferenceTracker AggregateRequestBodyTest - * @run testng/othervm -Djdk.internal.httpclient.debug=true + * @run junit/othervm -Djdk.internal.httpclient.debug=true * -Djdk.httpclient.HttpClient.log=requests,responses,errors,headers,frames * AggregateRequestBodyTest * @summary Tests HttpRequest.BodyPublishers::concat @@ -41,7 +41,6 @@ import java.net.http.HttpRequest.BodyPublishers; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandlers; import java.nio.ByteBuffer; -import java.util.Arrays; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -70,40 +69,43 @@ import javax.net.ssl.SSLContext; import jdk.test.lib.net.SimpleSSLContext; import jdk.test.lib.net.URIBuilder; -import org.testng.Assert; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import static java.lang.System.out; import static java.net.http.HttpClient.Version.HTTP_1_1; import static java.net.http.HttpClient.Version.HTTP_2; import static java.net.http.HttpClient.Version.HTTP_3; import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; -import static org.testng.Assert.expectThrows; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Assertions; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class AggregateRequestBodyTest implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer http1TestServer; // HTTP/1.1 ( http ) - HttpTestServer https1TestServer; // HTTPS/1.1 ( https ) - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - HttpTestServer http3TestServer; // HTTP/3 ( h3 ) - URI http1URI; - URI https1URI; - URI http2URI; - URI https2URI; - URI http3URI; + private static HttpTestServer http1TestServer; // HTTP/1.1 ( http ) + private static HttpTestServer https1TestServer; // HTTPS/1.1 ( https ) + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static HttpTestServer http3TestServer; // HTTP/3 ( h3 ) + private static URI http1URI; + private static URI https1URI; + private static URI http2URI; + private static URI https2URI; + private static URI http3URI; static final int RESPONSE_CODE = 200; static final int ITERATION_COUNT = 4; @@ -123,8 +125,8 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; - private volatile HttpClient sharedClient; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static volatile HttpClient sharedClient; static class TestExecutor implements Executor { final AtomicLong tasks = new AtomicLong(); @@ -150,40 +152,40 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); - } - - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); } } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } } - @AfterClass - static final void printFailedTests(ITestContext context) { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @AfterAll + static void printFailedTests() { out.println("\n========================="); try { - var failed = context.getFailedTests().getAllResults().stream() - .collect(Collectors.toMap(r -> name(r), ITestResult::getThrowable)); - FAILURES.putAll(failed); - out.printf("%n%sCreated %d servers and %d clients%n", now(), serverCount.get(), clientCount.get()); if (FAILURES.isEmpty()) return; @@ -201,7 +203,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { } } - private URI[] uris() { + private static URI[] uris() { return new URI[] { http1URI, https1URI, @@ -211,13 +213,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { }; } - static AtomicLong URICOUNT = new AtomicLong(); - - @DataProvider(name = "variants") - public Object[][] variants(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - return new Object[0][]; - } + public static Object[][] variants() { URI[] uris = uris(); Object[][] result = new Object[uris.length * 2][]; int i = 0; @@ -285,8 +281,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { return s; } - @DataProvider(name = "sparseContent") - Object[][] nulls() { + static Object[][] nulls() { return new Object[][] { {"null array", null}, {"null element", strings((String)null)}, @@ -304,8 +299,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { .collect(Collectors.toList()); } - @DataProvider(name = "contentLengths") - Object[][] contentLengths() { + static Object[][] contentLengths() { return new Object[][] { {-1, lengths(-1)}, {-42, lengths(-42)}, @@ -332,8 +326,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { }; } - @DataProvider(name="negativeRequests") - Object[][] negativeRequests() { + static Object[][] negativeRequests() { return new Object[][] { {0L}, {-1L}, {-2L}, {Long.MIN_VALUE + 1L}, {Long.MIN_VALUE} }; @@ -492,31 +485,33 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { () -> new AssertionError("Should not happen!")); } - @Test(dataProvider = "sparseContent") // checks that NPE is thrown + @ParameterizedTest // checks that NPE is thrown + @MethodSource("nulls") public void testNullPointerException(String description, String[] content) { - checkSkip(); + out.printf("%n%s-- testNullPointerException %s%n%n", now(), description); BodyPublisher[] publishers = publishers(content); - Assert.assertThrows(NullPointerException.class, () -> BodyPublishers.concat(publishers)); + Assertions.assertThrows(NullPointerException.class, () -> BodyPublishers.concat(publishers)); } // Verifies that an empty array creates a "noBody" publisher @Test public void testEmpty() { - checkSkip(); + out.printf("%n%s-- testEmpty%n%n", now()); BodyPublisher publisher = BodyPublishers.concat(); RequestSubscriber subscriber = new RequestSubscriber(); - assertEquals(publisher.contentLength(), 0); + assertEquals(0, publisher.contentLength()); publisher.subscribe(subscriber); subscriber.subscriptionCF.thenAccept(s -> s.request(1)); List result = subscriber.resultCF.join(); - assertEquals(result, List.of()); + assertEquals(List.of(), result); assertTrue(subscriber.items.isEmpty()); } // verifies that error emitted by upstream publishers are propagated downstream. - @Test(dataProvider = "sparseContent") // nulls are replaced with error publisher + @ParameterizedTest // nulls are replaced with error publisher + @MethodSource("nulls") public void testOnError(String description, String[] content) { - checkSkip(); + out.printf("%n%s-- testOnError %s%n%n", now(), description); final RequestSubscriber subscriber = new RequestSubscriber(); final PublishWithError errorPublisher; final BodyPublisher[] publishers; @@ -556,13 +551,13 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { publisher.subscribe(subscriber); subscriber.subscriptionCF.thenAccept(s -> s.request(Long.MAX_VALUE)); if (errorPublisher.hasErrors()) { - CompletionException ce = expectThrows(CompletionException.class, + CompletionException ce = Assertions.assertThrows(CompletionException.class, () -> subscriber.resultCF.join()); out.println(description + ": got expected " + ce); - assertEquals(ce.getCause().getClass(), Exception.class); - assertEquals(stringFromBytes(subscriber.items.stream()) + "", result); + assertEquals(Exception.class, ce.getCause().getClass()); + assertEquals(result, stringFromBytes(subscriber.items.stream()) + ""); } else { - assertEquals(stringFromBytes(subscriber.resultCF.join().stream()), result); + assertEquals(result, stringFromBytes(subscriber.resultCF.join().stream())); out.println(description + ": got expected result: " + result); } } @@ -570,9 +565,10 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { // Verifies that if an upstream publisher has an unknown length, the // aggregate publisher will have an unknown length as well. Otherwise // the length should be known. - @Test(dataProvider = "sparseContent") // nulls are replaced with unknown length + @ParameterizedTest // nulls are replaced with unknown length + @MethodSource("nulls") public void testUnknownContentLength(String description, String[] content) { - checkSkip(); + out.printf("%n%s-- testUnknownContentLength %s%n%n", now(), description); if (content == null) { content = BODIES.toArray(String[]::new); description = "BODIES (known length)"; @@ -598,9 +594,9 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { length += content[i].length(); } } - out.printf("testUnknownContentLength(%s): %d%n", description, length); + out.printf("%stestUnknownContentLength(%s): %d%n", now(), description, length); BodyPublisher publisher = BodyPublishers.concat(publishers); - assertEquals(publisher.contentLength(), length, + assertEquals(length, publisher.contentLength(), description.replace("null", "length(-1)")); } @@ -611,9 +607,10 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { return x.getCause(); } - @Test(dataProvider = "negativeRequests") + @ParameterizedTest + @MethodSource("negativeRequests") public void testNegativeRequest(long n) { - checkSkip(); + out.printf("%n%s-- testNegativeRequest %s%n%n", now(), n); assert n <= 0 : "test for negative request called with n > 0 : " + n; BodyPublisher[] publishers = ContentLengthPublisher.of(List.of(1L, 2L, 3L)); BodyPublisher publisher = BodyPublishers.concat(publishers); @@ -621,7 +618,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { publisher.subscribe(subscriber); Subscription subscription = subscriber.subscriptionCF.join(); subscription.request(n); - CompletionException expected = expectThrows(CE, () -> subscriber.resultCF.join()); + CompletionException expected = Assertions.assertThrows(CE, () -> subscriber.resultCF.join()); Throwable cause = completionCause(expected); if (cause instanceof IllegalArgumentException) { System.out.printf("Got expected IAE for %d: %s%n", n, cause); @@ -637,7 +634,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { @Test public void testPositiveRequests() { - checkSkip(); + out.printf("%n%s-- testPositiveRequests%n%n", now()); // A composite array of publishers BodyPublisher[] publishers = Stream.of( Stream.of(ofStrings("Lorem", " ", "ipsum", " ")), @@ -657,7 +654,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { List list1 = requestSubscriber1.resultCF().join(); assertTrue(requestSubscriber1.resultCF().isDone()); String result1 = stringFromBytes(list1.stream()); - assertEquals(result1, "Lorem ipsum dolor sit amet, consectetur adipiscing elit."); + assertEquals("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", result1); System.out.println("Got expected sentence with one request: \"%s\"".formatted(result1)); // Test that we can split our requests call any which way we want @@ -675,16 +672,17 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { List list2 = requestSubscriber2.resultCF().join(); assertTrue(requestSubscriber2.resultCF().isDone()); String result2 = stringFromBytes(list2.stream()); - assertEquals(result2, "Lorem ipsum dolor sit amet, consectetur adipiscing elit."); + assertEquals("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", result2); System.out.println("Got expected sentence with 4 requests: \"%s\"".formatted(result1)); } - @Test(dataProvider = "contentLengths") + @ParameterizedTest + @MethodSource("contentLengths") public void testContentLength(long expected, List lengths) { - checkSkip(); + out.printf("%n%s-- testContentLength expected=%s %s%n%n", now(), expected, lengths); BodyPublisher[] publishers = ContentLengthPublisher.of(lengths); BodyPublisher aggregate = BodyPublishers.concat(publishers); - assertEquals(aggregate.contentLength(), expected, + assertEquals(expected, aggregate.contentLength(), "Unexpected result for %s".formatted(lengths)); } @@ -692,14 +690,13 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { // publishers are no longer subscribed etc... @Test public void testCancel() { - checkSkip(); + out.printf("%n%s-- testCancel%n%n", now()); BodyPublisher[] publishers = BODIES.stream() .map(BodyPublishers::ofString) .toArray(BodyPublisher[]::new); BodyPublisher publisher = BodyPublishers.concat(publishers); - assertEquals(publisher.contentLength(), - BODIES.stream().mapToInt(String::length).sum()); + assertEquals(BODIES.stream().mapToInt(String::length).sum(), publisher.contentLength()); Map subscribers = new LinkedHashMap<>(); for (int n=0; n < BODIES.size(); n++) { @@ -731,7 +728,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { // subscription was cancelled, so nothing should be received... try { - TimeoutException x = Assert.expectThrows(TimeoutException.class, + TimeoutException x = Assertions.assertThrows(TimeoutException.class, () -> any.get(5, TimeUnit.SECONDS)); out.println("Got expected " + x); } finally { @@ -742,8 +739,8 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { subscribers.get(rs), rs.resultCF)); } Consumer check = (rs) -> { - Assert.assertTrue(rs.items.isEmpty(), subscribers.get(rs) + " has items"); - Assert.assertFalse(rs.resultCF.isDone(), subscribers.get(rs) + " was not cancelled"); + assertTrue(rs.items.isEmpty(), subscribers.get(rs) + " has items"); + assertFalse(rs.resultCF.isDone(), subscribers.get(rs) + " was not cancelled"); out.println(subscribers.get(rs) + ": PASSED"); }; subscribers.keySet().stream().forEach(check); @@ -752,13 +749,12 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { // Verifies that cancelling the subscription is propagated downstream @Test public void testCancelSubscription() { - checkSkip(); + out.printf("%n%s-- testCancelSubscription%n%n", now()); PublishWithError upstream = new PublishWithError(BODIES, BODIES.size(), () -> new AssertionError("should not come here")); BodyPublisher publisher = BodyPublishers.concat(upstream); - assertEquals(publisher.contentLength(), - BODIES.stream().mapToInt(String::length).sum()); + assertEquals(BODIES.stream().mapToInt(String::length).sum(), publisher.contentLength()); Map subscribers = new LinkedHashMap<>(); for (int n=0; n < BODIES.size(); n++) { @@ -793,7 +789,7 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { // subscription was cancelled, so nothing should be received... try { - TimeoutException x = Assert.expectThrows(TimeoutException.class, + TimeoutException x = Assertions.assertThrows(TimeoutException.class, () -> any.get(5, TimeUnit.SECONDS)); out.println("Got expected " + x); } finally { @@ -804,17 +800,19 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { subscribers.get(rs), rs.resultCF)); } Consumer check = (rs) -> { - Assert.assertTrue(rs.items.isEmpty(), subscribers.get(rs) + " has items"); - Assert.assertFalse(rs.resultCF.isDone(), subscribers.get(rs) + " was not cancelled"); + assertTrue(rs.items.isEmpty(), subscribers.get(rs) + " has items"); + assertFalse(rs.resultCF.isDone(), subscribers.get(rs) + " was not cancelled"); out.println(subscribers.get(rs) + ": PASSED"); }; subscribers.keySet().stream().forEach(check); } - @Test(dataProvider = "variants") + @ParameterizedTest + @MethodSource("variants") public void test(URI uri, HttpClient.Version version, boolean sameClient) throws Exception { - checkSkip(); + out.printf("%n%s-- test sameClient=%s, version=%s, uri=%s%n%n", + now(), sameClient, version, uri); System.out.printf("Request to %s (sameClient: %s)%n", uri, sameClient); System.err.printf("Request to %s (sameClient: %s)%n", uri, sameClient); @@ -838,13 +836,13 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { int expectedResponse = RESPONSE_CODE; if (response.statusCode() != expectedResponse) throw new RuntimeException("wrong response code " + Integer.toString(response.statusCode())); - assertEquals(response.body(), BODIES.stream().collect(Collectors.joining())); + assertEquals(BODIES.stream().collect(Collectors.joining()), response.body()); } if (!sameClient) client.close(); System.out.println("test: DONE"); } - private URI buildURI(String scheme, String path, int port) { + private static URI buildURI(String scheme, String path, int port) { return URIBuilder.newBuilder() .scheme(scheme) .loopback() @@ -853,8 +851,8 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { .buildUnchecked(); } - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { HttpTestHandler handler = new HttpTestEchoHandler(); http1TestServer = HttpTestServer.create(HTTP_1_1); http1TestServer.addHandler(handler, "/http1/echo/"); @@ -884,8 +882,8 @@ public class AggregateRequestBodyTest implements HttpServerAdapters { http3TestServer.start(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { String sharedClientName = sharedClient == null ? null : sharedClient.toString(); sharedClient.close(); diff --git a/test/jdk/java/net/httpclient/BasicHTTP2Test.java b/test/jdk/java/net/httpclient/BasicHTTP2Test.java index 586673d62ab..4175aceea3d 100644 --- a/test/jdk/java/net/httpclient/BasicHTTP2Test.java +++ b/test/jdk/java/net/httpclient/BasicHTTP2Test.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 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 @@ -27,7 +27,7 @@ * @build jdk.test.lib.net.SimpleSSLContext * jdk.httpclient.test.lib.common.HttpServerAdapters * ReferenceTracker - * @run testng/othervm -Djdk.internal.httpclient.debug=true + * @run junit/othervm -Djdk.internal.httpclient.debug=true * -Djdk.httpclient.HttpClient.log=requests,responses,errors * BasicHTTP2Test * @summary Basic HTTP/2 test when HTTP/3 is requested @@ -44,37 +44,40 @@ import java.net.http.HttpRequest; import java.net.http.HttpRequest.Builder; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandlers; -import java.time.Duration; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicReference; import javax.net.ssl.SSLContext; import jdk.test.lib.net.SimpleSSLContext; import jdk.httpclient.test.lib.common.HttpServerAdapters; -import org.testng.ITestContext; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; import static java.lang.System.out; import static java.net.http.HttpClient.Version.HTTP_2; import static java.net.http.HttpOption.Http3DiscoveryMode.ALT_SVC; import static java.net.http.HttpOption.H3_DISCOVERY; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; + +import org.junit.jupiter.api.AfterAll; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; public class BasicHTTP2Test implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - String https2URI; - DatagramSocket udp; + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static String https2URI; + private static DatagramSocket udp; // a shared executor helps reduce the amount of threads created by the test static final Executor executor = new TestExecutor(Executors.newCachedThreadPool()); @@ -91,8 +94,7 @@ public class BasicHTTP2Test implements HttpServerAdapters { return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; - private volatile HttpClient sharedClient; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; static class TestExecutor implements Executor { final AtomicLong tasks = new AtomicLong(); @@ -118,20 +120,37 @@ public class BasicHTTP2Test implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - var x = new SkipException("Skipping: some test failed"); - x.setStackTrace(new StackTraceElement[0]); - throw x; + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + } + } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); } } - @AfterClass + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @AfterAll static final void printFailedTests() { out.println("\n========================="); try { @@ -152,14 +171,6 @@ public class BasicHTTP2Test implements HttpServerAdapters { } } - private String[] uris() { - return new String[] { - https2URI, - }; - } - - static AtomicLong URICOUNT = new AtomicLong(); - private HttpClient makeNewClient() { clientCount.incrementAndGet(); HttpClient client = HttpClient.newBuilder() @@ -170,37 +181,6 @@ public class BasicHTTP2Test implements HttpServerAdapters { return TRACKER.track(client); } - HttpClient newHttpClient(boolean share) { - if (!share) return makeNewClient(); - HttpClient shared = sharedClient; - if (shared != null) return shared; - synchronized (this) { - shared = sharedClient; - if (shared == null) { - shared = sharedClient = makeNewClient(); - } - return shared; - } - } - - - static void checkStatus(int expected, int found) throws Exception { - if (expected != found) { - System.err.printf ("Test failed: wrong status code %d/%d\n", - expected, found); - throw new RuntimeException("Test failed"); - } - } - - static void checkStrings(String expected, String found) throws Exception { - if (!expected.equals(found)) { - System.err.printf ("Test failed: wrong string %s/%s\n", - expected, found); - throw new RuntimeException("Test failed"); - } - } - - @Test public void testH2() throws Exception { @@ -220,8 +200,8 @@ public class BasicHTTP2Test implements HttpServerAdapters { HttpResponse response = client.send(request, BodyHandlers.ofString()); out.println("Response #1: " + response); out.println("Version #1: " + response.version()); - assertEquals(response.statusCode(), 200, "first response status"); - assertEquals(response.version(), HTTP_2, "first response version"); + assertEquals(200, response.statusCode(), "first response status"); + assertEquals(HTTP_2, response.version(), "first response version"); Thread.sleep(1000); @@ -232,16 +212,15 @@ public class BasicHTTP2Test implements HttpServerAdapters { response = client.send(request, BodyHandlers.ofString()); out.println("Response #2: " + response); out.println("Version #2: " + response.version()); - assertEquals(response.statusCode(), 200, "second response status"); - assertEquals(response.version(), HTTP_2, "second response version"); + assertEquals(200, response.statusCode(), "second response status"); + assertEquals(HTTP_2, response.version(), "second response version"); } - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { // HTTP/2 HttpTestHandler handler = new Handler(); - HttpTestHandler h3Handler = new Handler(); https2TestServer = HttpTestServer.create(HTTP_2, sslContext); https2TestServer.addHandler(handler, "/https2/test204/"); @@ -259,11 +238,8 @@ public class BasicHTTP2Test implements HttpServerAdapters { https2TestServer.start(); } - @AfterTest - public void teardown() throws Exception { - String sharedClientName = - sharedClient == null ? null : sharedClient.toString(); - sharedClient = null; + @AfterAll + public static void teardown() throws Exception { Thread.sleep(100); AssertionError fail = TRACKER.check(500); try { @@ -271,10 +247,7 @@ public class BasicHTTP2Test implements HttpServerAdapters { https2TestServer.stop(); } finally { if (fail != null) { - if (sharedClientName != null) { - System.err.println("Shared client name is: " + sharedClientName); - } - throw fail; + throw fail; } } } diff --git a/test/jdk/java/net/httpclient/BasicHTTP3Test.java b/test/jdk/java/net/httpclient/BasicHTTP3Test.java index 4508b32e544..aec21e421f9 100644 --- a/test/jdk/java/net/httpclient/BasicHTTP3Test.java +++ b/test/jdk/java/net/httpclient/BasicHTTP3Test.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 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 @@ -31,7 +31,6 @@ import java.net.http.HttpRequest; import java.net.http.HttpRequest.Builder; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandlers; -import java.time.Duration; import java.util.List; import java.util.Optional; import java.util.Set; @@ -40,28 +39,32 @@ import java.util.concurrent.ConcurrentMap; import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicReference; import javax.net.ssl.SSLContext; import jdk.httpclient.test.lib.common.HttpServerAdapters; import jdk.httpclient.test.lib.http2.Http2TestServer; import jdk.internal.net.quic.QuicVersion; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import static java.net.http.HttpClient.Version.HTTP_2; import static java.net.http.HttpClient.Version.HTTP_3; import static java.net.http.HttpOption.H3_DISCOVERY; -import static org.testng.Assert.*; + +import static org.junit.jupiter.api.Assertions.*; import static java.lang.System.out; import static java.net.http.HttpOption.Http3DiscoveryMode.ALT_SVC; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; /* * @test @@ -70,7 +73,7 @@ import static java.net.http.HttpOption.Http3DiscoveryMode.ALT_SVC; * jdk.httpclient.test.lib.common.HttpServerAdapters * ReferenceTracker * jdk.httpclient.test.lib.quic.QuicStandaloneServer - * @run testng/othervm -Djdk.internal.httpclient.debug=true + * @run junit/othervm -Djdk.internal.httpclient.debug=true * -Djdk.httpclient.HttpClient.log=requests,responses,errors * -Djavax.net.debug=all * BasicHTTP3Test @@ -79,20 +82,20 @@ import static java.net.http.HttpOption.Http3DiscoveryMode.ALT_SVC; public class BasicHTTP3Test implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - String https2URI; - HttpTestServer h3TestServer; // HTTP/2 ( h2 + h3) - String h3URI; - HttpTestServer h3qv2TestServer; // HTTP/2 ( h2 + h3 on Quic v2, incompatible nego) - String h3URIQv2; - HttpTestServer h3qv2CTestServer; // HTTP/2 ( h2 + h3 on Quic v2, compatible nego) - String h3URIQv2C; - HttpTestServer h3mtlsTestServer; // HTTP/2 ( h2 + h3), h3 requires client cert - String h3mtlsURI; - HttpTestServer h3TestServerWithRetry; // h3 - String h3URIRetry; - HttpTestServer h3TestServerWithTLSHelloRetry; // h3 - String h3URITLSHelloRetry; + static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + static String https2URI; + static HttpTestServer h3TestServer; // HTTP/2 ( h2 + h3) + static String h3URI; + static HttpTestServer h3qv2TestServer; // HTTP/2 ( h2 + h3 on Quic v2, incompatible nego) + static String h3URIQv2; + static HttpTestServer h3qv2CTestServer; // HTTP/2 ( h2 + h3 on Quic v2, compatible nego) + static String h3URIQv2C; + static HttpTestServer h3mtlsTestServer; // HTTP/2 ( h2 + h3), h3 requires client cert + static String h3mtlsURI; + static HttpTestServer h3TestServerWithRetry; // h3 + static String h3URIRetry; + static HttpTestServer h3TestServerWithTLSHelloRetry; // h3 + static String h3URITLSHelloRetry; static final int ITERATION_COUNT = 4; // a shared executor helps reduce the amount of threads created by the test @@ -109,8 +112,8 @@ public class BasicHTTP3Test implements HttpServerAdapters { return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; - private volatile HttpClient sharedClient; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static volatile HttpClient sharedClient; static class TestExecutor implements Executor { final AtomicLong tasks = new AtomicLong(); @@ -136,21 +139,38 @@ public class BasicHTTP3Test implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - var x = new SkipException("Skipping: some test failed"); - x.setStackTrace(new StackTraceElement[0]); - throw x; + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + } + } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); } } - @AfterClass - static final void printFailedTests() { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @AfterAll + static void printFailedTests() { out.println("\n========================="); try { out.printf("%n%sCreated %d clients%n", @@ -170,18 +190,14 @@ public class BasicHTTP3Test implements HttpServerAdapters { } } - private String[] uris() { + private static String[] uris() { return new String[] { https2URI, h3URI }; } - @DataProvider(name = "variants") - public Object[][] variants(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - return new Object[0][]; - } + public static Object[][] variants() { String[] uris = uris(); Object[][] result = new Object[uris.length * 2 * 2][]; int i = 0; @@ -196,11 +212,7 @@ public class BasicHTTP3Test implements HttpServerAdapters { return result; } - @DataProvider(name = "h3URIs") - public Object[][] versions(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - return new Object[0][]; - } + public static Object[][] versions() { Object[][] result = { {h3URI}, {h3URIRetry}, {h3URIQv2}, {h3URIQv2C}, @@ -233,9 +245,11 @@ public class BasicHTTP3Test implements HttpServerAdapters { } } - @Test(dataProvider = "variants") + @ParameterizedTest + @MethodSource("variants") public void test(String uri, boolean sameClient, Optional version) throws Exception { - System.out.println("Request to " + uri); + System.out.printf("%n%s-- test version=%s, sameClient=%s, uri=%s%n%n", + now(), version, sameClient, uri); HttpClient client = newHttpClient(sameClient); @@ -267,8 +281,10 @@ public class BasicHTTP3Test implements HttpServerAdapters { System.out.println("test: DONE"); } - @Test(dataProvider = "h3URIs") + @ParameterizedTest + @MethodSource("versions") public void testH3(final String h3URI) throws Exception { + System.out.printf("%n%s-- testH3 h3URI=%s%n%n", now(), h3URI); HttpClient client = makeNewClient(); URI uri = URI.create(h3URI); Builder builder = HttpRequest.newBuilder(uri) @@ -278,17 +294,17 @@ public class BasicHTTP3Test implements HttpServerAdapters { HttpResponse response = client.send(request, BodyHandlers.ofString()); out.println("Response #1: " + response); out.println("Version #1: " + response.version()); - assertEquals(response.statusCode(), 200, "first response status"); - assertEquals(response.version(), HTTP_2, "first response version"); + assertEquals(200, response.statusCode(), "first response status"); + assertEquals(HTTP_2, response.version(), "first response version"); request = builder.version(Version.HTTP_3).build(); response = client.send(request, BodyHandlers.ofString()); out.println("Response #2: " + response); out.println("Version #2: " + response.version()); - assertEquals(response.statusCode(), 200, "second response status"); - assertEquals(response.version(), Version.HTTP_3, "second response version"); + assertEquals(200, response.statusCode(), "second response status"); + assertEquals(Version.HTTP_3, response.version(), "second response version"); - if (h3URI == h3mtlsURI) { + if (h3URI.equals(h3mtlsURI)) { assertNotNull(response.sslSession().get().getLocalCertificates()); } else { assertNull(response.sslSession().get().getLocalCertificates()); @@ -303,6 +319,7 @@ public class BasicHTTP3Test implements HttpServerAdapters { // verify that the client handles HTTP/3 reset stream correctly @Test public void testH3Reset() throws Exception { + System.out.printf("%n%s-- testH3Reset uri=%s%n%n", now(), h3URI); HttpClient client = makeNewClient(); URI uri = URI.create(h3URI); Builder builder = HttpRequest.newBuilder(uri) @@ -312,8 +329,8 @@ public class BasicHTTP3Test implements HttpServerAdapters { HttpResponse response = client.send(request, BodyHandlers.ofString()); out.println("Response #1: " + response); out.println("Version #1: " + response.version()); - assertEquals(response.statusCode(), 200, "first response status"); - assertEquals(response.version(), HTTP_2, "first response version"); + assertEquals(200, response.statusCode(), "first response status"); + assertEquals(HTTP_2, response.version(), "first response version"); // instruct the server side handler to throw an exception // that then causes the test server to reset the stream @@ -341,8 +358,8 @@ public class BasicHTTP3Test implements HttpServerAdapters { if (error != null) throw error; } - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { https2TestServer = HttpTestServer.create(HTTP_2, sslContext); https2TestServer.addHandler(new Handler(), "/https2/test/"); https2URI = "https://" + https2TestServer.serverAuthority() + "/https2/test/x"; @@ -360,7 +377,7 @@ public class BasicHTTP3Test implements HttpServerAdapters { .enableH3AltServiceOnEphemeralPortWithVersion(QuicVersion.QUIC_V2, false); h3qv2TestServer = HttpTestServer.of(h2q2Server); h3qv2TestServer.addHandler(h3Handler, "/h3/testH3/"); - h3URIQv2 = "https://" + h3qv2TestServer.serverAuthority() + "/h3/testH3/h3qv2";; + h3URIQv2 = "https://" + h3qv2TestServer.serverAuthority() + "/h3/testH3/h3qv2"; assertTrue(h3qv2TestServer.canHandle(HTTP_2, Version.HTTP_3), "Server was expected" + " to handle both HTTP2 and HTTP3, but doesn't"); @@ -369,7 +386,7 @@ public class BasicHTTP3Test implements HttpServerAdapters { .enableH3AltServiceOnEphemeralPortWithVersion(QuicVersion.QUIC_V2, true); h3qv2CTestServer = HttpTestServer.of(h2q2CServer); h3qv2CTestServer.addHandler(h3Handler, "/h3/testH3/"); - h3URIQv2C = "https://" + h3qv2CTestServer.serverAuthority() + "/h3/testH3/h3qv2c";; + h3URIQv2C = "https://" + h3qv2CTestServer.serverAuthority() + "/h3/testH3/h3qv2c"; assertTrue(h3qv2CTestServer.canHandle(HTTP_2, Version.HTTP_3), "Server was expected" + " to handle both HTTP2 and HTTP3, but doesn't"); @@ -411,8 +428,8 @@ public class BasicHTTP3Test implements HttpServerAdapters { h3TestServerWithTLSHelloRetry.start(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { System.err.println("======================================================="); System.err.println(" Tearing down test"); System.err.println("======================================================="); diff --git a/test/jdk/java/net/httpclient/CancelRequestTest.java b/test/jdk/java/net/httpclient/CancelRequestTest.java index 2a0ec19a0ed..df808ad2dab 100644 --- a/test/jdk/java/net/httpclient/CancelRequestTest.java +++ b/test/jdk/java/net/httpclient/CancelRequestTest.java @@ -29,7 +29,7 @@ * @key randomness * @build jdk.httpclient.test.lib.common.HttpServerAdapters jdk.test.lib.net.SimpleSSLContext * ReferenceTracker CancelRequestTest - * @run testng/othervm -Djdk.internal.httpclient.debug=true + * @run junit/othervm -Djdk.internal.httpclient.debug=true * -Djdk.httpclient.enableAllMethodRetry=true * CancelRequestTest */ @@ -38,15 +38,6 @@ import jdk.internal.net.http.common.OperationTrackers.Tracker; import jdk.test.lib.RandomFactory; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.net.ssl.SSLContext; import java.io.IOException; @@ -61,7 +52,6 @@ import java.net.http.HttpOption.Http3DiscoveryMode; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandler; import java.net.http.HttpResponse.BodyHandlers; -import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.Objects; @@ -76,7 +66,6 @@ import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; -import java.util.stream.Collectors; import jdk.httpclient.test.lib.common.HttpServerAdapters; import static java.lang.System.out; @@ -85,10 +74,21 @@ import static java.net.http.HttpClient.Version.*; import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY; import static java.net.http.HttpOption.H3_DISCOVERY; import static java.nio.charset.StandardCharsets.UTF_8; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertNotEquals; -import static org.testng.Assert.assertTrue; + +import org.junit.jupiter.api.AfterAll; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class CancelRequestTest implements HttpServerAdapters { @@ -97,19 +97,19 @@ public class CancelRequestTest implements HttpServerAdapters { = new ConcurrentHashMap<>(); private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ] - HttpTestServer httpsTestServer; // HTTPS/1.1 - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - HttpTestServer h2h3TestServer; // HTTP/3 ( h2 + h3 ) - HttpTestServer h3TestServer; // HTTP/3 ( h3 ) - String httpURI; - String httpsURI; - String http2URI; - String https2URI; - String h2h3URI; - String h2h3Head; - String h3URI; + private static HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ] + private static HttpTestServer httpsTestServer; // HTTPS/1.1 + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static HttpTestServer h2h3TestServer; // HTTP/3 ( h2 + h3 ) + private static HttpTestServer h3TestServer; // HTTP/3 ( h3 ) + private static String httpURI; + private static String httpsURI; + private static String http2URI; + private static String https2URI; + private static String h2h3URI; + private static String h2h3Head; + private static String h3URI; static final long SERVER_LATENCY = 75; static final int MAX_CLIENT_DELAY = 75; @@ -130,8 +130,8 @@ public class CancelRequestTest implements HttpServerAdapters { return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; - private volatile HttpClient sharedClient; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static volatile HttpClient sharedClient; static class TestExecutor implements Executor { final AtomicLong tasks = new AtomicLong(); @@ -157,38 +157,39 @@ public class CancelRequestTest implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); - } - - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); } } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } } - @AfterClass - static void printFailedTests(ITestContext context) { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @AfterAll + static void printFailedTests() { out.println("\n========================="); - var failed = context.getFailedTests().getAllResults().stream() - .collect(Collectors.toMap(CancelRequestTest::name, ITestResult::getThrowable)); - FAILURES.putAll(failed); try { out.printf("%n%sCreated %d servers and %d clients%n", now(), serverCount.get(), clientCount.get()); @@ -206,7 +207,7 @@ public class CancelRequestTest implements HttpServerAdapters { } } - private String[] uris() { + private static String[] uris() { return new String[] { httpURI, httpsURI, @@ -217,8 +218,7 @@ public class CancelRequestTest implements HttpServerAdapters { }; } - @DataProvider(name = "asyncurls") - public Object[][] asyncurls() { + public static Object[][] asyncurls() { String[] uris = uris(); Object[][] result = new Object[uris.length * 2 * 3][]; //Object[][] result = new Object[uris.length][]; @@ -238,8 +238,7 @@ public class CancelRequestTest implements HttpServerAdapters { return result; } - @DataProvider(name = "urls") - public Object[][] alltests() { + public static Object[][] alltests() { String[] uris = uris(); Object[][] result = new Object[uris.length * 2][]; //Object[][] result = new Object[uris.length][]; @@ -327,7 +326,7 @@ public class CancelRequestTest implements HttpServerAdapters { .HEAD() .build(); var resp = client.send(request, BodyHandlers.discarding()); - assertEquals(resp.statusCode(), 200); + assertEquals(200, resp.statusCode()); } private static void releaseLatches() { @@ -348,10 +347,10 @@ public class CancelRequestTest implements HttpServerAdapters { return latch; } - @Test(dataProvider = "asyncurls") + @ParameterizedTest + @MethodSource("asyncurls") public void testGetSendAsync(String uri, boolean sameClient, boolean mayInterruptIfRunning) throws Exception { - checkSkip(); HttpClient client = null; uri = uri + "/get"; out.printf("%n%s testGetSendAsync(%s, %b, %b)%n", now(), uri, sameClient, mayInterruptIfRunning); @@ -386,7 +385,7 @@ public class CancelRequestTest implements HttpServerAdapters { out.println("cf2 after cancel: " + cf2); try { String body = cf2.get().body(); - assertEquals(body, String.join("", BODY.split("\\|"))); + assertEquals(String.join("", BODY.split("\\|")), body); throw new AssertionError("Expected CancellationException not received"); } catch (ExecutionException x) { out.println(now() + "Got expected exception: " + x); @@ -409,7 +408,7 @@ public class CancelRequestTest implements HttpServerAdapters { // completed yet - so wait for it here... try { String body = response.get().body(); - assertEquals(body, String.join("", BODY.split("\\|"))); + assertEquals(String.join("", BODY.split("\\|")), body); if (mayInterruptIfRunning) { // well actually - this could happen... In which case we'll need to // increase the latency in the server handler... @@ -448,10 +447,10 @@ public class CancelRequestTest implements HttpServerAdapters { assertTrue(response.isDone()); assertFalse(response.isCancelled()); - assertEquals(cf1.isCancelled(), hasCancellationException); + assertEquals(hasCancellationException, cf1.isCancelled()); assertTrue(cf2.isDone()); assertFalse(cf2.isCancelled()); - assertEquals(latch.getCount(), 0); + assertEquals(0, latch.getCount()); var error = TRACKER.check(tracker, 1000, (t) -> t.getOutstandingOperations() > 0 || t.getOutstandingSubscribers() > 0, @@ -464,10 +463,10 @@ public class CancelRequestTest implements HttpServerAdapters { if (!sameClient) client.close(); } - @Test(dataProvider = "asyncurls") + @ParameterizedTest + @MethodSource("asyncurls") public void testPostSendAsync(String uri, boolean sameClient, boolean mayInterruptIfRunning) throws Exception { - checkSkip(); uri = uri + "/post"; HttpClient client = null; out.printf("%n%s testPostSendAsync(%s, %b, %b)%n", now(), uri, sameClient, mayInterruptIfRunning); @@ -521,7 +520,7 @@ public class CancelRequestTest implements HttpServerAdapters { out.println("cf2 after cancel: " + cf2); try { String body = cf2.get().body(); - assertEquals(body, String.join("", BODY.split("\\|"))); + assertEquals(String.join("", BODY.split("\\|")), body); throw new AssertionError("Expected CancellationException not received"); } catch (ExecutionException x) { out.println(now() + "Got expected exception: " + x); @@ -544,7 +543,7 @@ public class CancelRequestTest implements HttpServerAdapters { // completed yet - so wait for it here... try { String body = response.get().body(); - assertEquals(body, String.join("", BODY.split("\\|"))); + assertEquals(String.join("", BODY.split("\\|")), body); if (mayInterruptIfRunning) { // well actually - this could happen... In which case we'll need to // increase the latency in the server handler... @@ -577,10 +576,10 @@ public class CancelRequestTest implements HttpServerAdapters { assertTrue(response.isDone()); assertFalse(response.isCancelled()); - assertEquals(cf1.isCancelled(), hasCancellationException); + assertEquals(hasCancellationException, cf1.isCancelled()); assertTrue(cf2.isDone()); assertFalse(cf2.isCancelled()); - assertEquals(latch.getCount(), 0); + assertEquals(0, latch.getCount()); var error = TRACKER.check(tracker, 1000, (t) -> t.getOutstandingOperations() > 0 || t.getOutstandingSubscribers() > 0, @@ -593,10 +592,10 @@ public class CancelRequestTest implements HttpServerAdapters { if (!sameClient) client.close(); } - @Test(dataProvider = "urls") + @ParameterizedTest + @MethodSource("alltests") public void testPostInterrupt(String uri, boolean sameClient) throws Exception { - checkSkip(); HttpClient client = null; out.printf("%n%s testPostInterrupt(%s, %b)%n", now(), uri, sameClient); for (int i=0; i< ITERATION_COUNT; i++) { @@ -661,7 +660,7 @@ public class CancelRequestTest implements HttpServerAdapters { } else { assert failed == null; out.println(now() + req.uri() + ": got body: " + body); - assertEquals(body, String.join("", BODY.split("\\|"))); + assertEquals(String.join("", BODY.split("\\|")), body); } out.println(now() + "next iteration"); @@ -678,8 +677,8 @@ public class CancelRequestTest implements HttpServerAdapters { - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { // HTTP/1.1 HttpTestHandler h1_chunkHandler = new HTTPSlowHandler(); httpTestServer = HttpTestServer.create(HTTP_1_1); @@ -721,8 +720,8 @@ public class CancelRequestTest implements HttpServerAdapters { h3TestServer.start(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { String sharedClientName = sharedClient == null ? null : sharedClient.toString(); sharedClient = null; diff --git a/test/jdk/java/net/httpclient/CancelStreamedBodyTest.java b/test/jdk/java/net/httpclient/CancelStreamedBodyTest.java index 0035a3f4302..48f23ebf370 100644 --- a/test/jdk/java/net/httpclient/CancelStreamedBodyTest.java +++ b/test/jdk/java/net/httpclient/CancelStreamedBodyTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 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 @@ -29,19 +29,10 @@ * @library /test/lib /test/jdk/java/net/httpclient/lib * @build jdk.httpclient.test.lib.common.HttpServerAdapters jdk.test.lib.net.SimpleSSLContext * ReferenceTracker CancelStreamedBodyTest - * @run testng/othervm -Djdk.internal.httpclient.debug=true + * @run junit/othervm -Djdk.internal.httpclient.debug=true * CancelStreamedBodyTest */ import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.net.ssl.SSLContext; import java.io.IOException; @@ -53,7 +44,6 @@ import java.net.http.HttpClient; import java.net.http.HttpClient.Version; import java.net.http.HttpRequest; import java.net.http.HttpResponse.BodyHandlers; -import java.util.Arrays; import java.util.List; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; @@ -61,7 +51,6 @@ import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; -import java.util.stream.Collectors; import java.util.stream.Stream; import jdk.httpclient.test.lib.common.HttpServerAdapters; @@ -72,23 +61,34 @@ import static java.net.http.HttpClient.Version.HTTP_3; import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY; import static java.net.http.HttpOption.H3_DISCOVERY; import static java.nio.charset.StandardCharsets.UTF_8; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; + +import org.junit.jupiter.api.AfterAll; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class CancelStreamedBodyTest implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ] - HttpTestServer httpsTestServer; // HTTPS/1.1 - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - HttpTestServer http3TestServer; // HTTP/3 ( h3 ) - String httpURI; - String httpsURI; - String http2URI; - String https2URI; - String https3URI; + private static HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ] + private static HttpTestServer httpsTestServer; // HTTPS/1.1 + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static HttpTestServer http3TestServer; // HTTP/3 ( h3 ) + private static String httpURI; + private static String httpsURI; + private static String http2URI; + private static String https2URI; + private static String https3URI; static final long SERVER_LATENCY = 75; static final int ITERATION_COUNT = 3; @@ -108,8 +108,8 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; - private volatile HttpClient sharedClient; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static volatile HttpClient sharedClient; static class TestExecutor implements Executor { final AtomicLong tasks = new AtomicLong(); @@ -135,38 +135,40 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); - } - - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); } } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } } - @AfterClass - static final void printFailedTests(ITestContext context) { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + + @AfterAll + static void printFailedTests() { out.println("\n========================="); - var failed = context.getFailedTests().getAllResults().stream() - .collect(Collectors.toMap(r -> name(r), ITestResult::getThrowable)); - FAILURES.putAll(failed); try { out.printf("%n%sCreated %d servers and %d clients%n", now(), serverCount.get(), clientCount.get()); @@ -184,7 +186,7 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { } } - private String[] uris() { + private static String[] uris() { return new String[] { https3URI, httpURI, @@ -195,8 +197,7 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { } - @DataProvider(name = "urls") - public Object[][] alltests() { + public static Object[][] alltests() { String[] uris = uris(); Object[][] result = new Object[uris.length * 2][]; int i = 0; @@ -265,10 +266,10 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { final static String BODY = "Some string |\n that ?\n can |\n be split ?\n several |\n ways."; - @Test(dataProvider = "urls") + @ParameterizedTest + @MethodSource("alltests") public void testAsLines(String uri, boolean sameClient) throws Exception { - checkSkip(); HttpClient client = null; uri = uri + "/testAsLines"; out.printf("%n%s testAsLines(%s, %b)%n", now(), uri, sameClient); @@ -284,8 +285,8 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { for (int j = 0; j < 2; j++) { try (Stream body = client.send(req, BodyHandlers.ofLines()).body()) { lines = body.limit(j).toList(); - assertEquals(lines, BODY.replaceAll("\\||\\?", "") - .lines().limit(j).toList()); + assertEquals(BODY.replaceAll("\\||\\?", "") + .lines().limit(j).toList(), lines); } // Only check our still alive client for outstanding operations // and outstanding subscribers here: it should have none. @@ -306,10 +307,10 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { } } - @Test(dataProvider = "urls") + @ParameterizedTest + @MethodSource("alltests") public void testInputStream(String uri, boolean sameClient) throws Exception { - checkSkip(); HttpClient client = null; uri = uri + "/testInputStream"; out.printf("%n%s testInputStream(%s, %b)%n", now(), uri, sameClient); @@ -326,7 +327,7 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { try (InputStream is = client.send(req, BodyHandlers.ofInputStream()).body()) { for (int k = 0; k < j; k++) { read = is.read(); - assertEquals(read, BODY.charAt(k)); + assertEquals(BODY.charAt(k), read); } } // Only check our still alive client for outstanding operations @@ -350,8 +351,8 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { // HTTP/1.1 HttpTestHandler h1_chunkHandler = new HTTPSlowHandler(); httpTestServer = HttpTestServer.create(HTTP_1_1); @@ -385,8 +386,8 @@ public class CancelStreamedBodyTest implements HttpServerAdapters { http3TestServer.start(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { String sharedClientName = sharedClient == null ? null : sharedClient.toString(); sharedClient = null; diff --git a/test/jdk/java/net/httpclient/ForbiddenHeadTest.java b/test/jdk/java/net/httpclient/ForbiddenHeadTest.java index 57fd627b2b0..f2011766b2b 100644 --- a/test/jdk/java/net/httpclient/ForbiddenHeadTest.java +++ b/test/jdk/java/net/httpclient/ForbiddenHeadTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 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 @@ -28,7 +28,7 @@ * @library /test/lib /test/jdk/java/net/httpclient/lib * @build DigestEchoServer ForbiddenHeadTest jdk.httpclient.test.lib.common.HttpServerAdapters * jdk.test.lib.net.SimpleSSLContext - * @run testng/othervm + * @run junit/othervm * -Djdk.http.auth.tunneling.disabledSchemes * -Djdk.httpclient.HttpClient.log=headers,requests * -Djdk.internal.httpclient.debug=true @@ -36,15 +36,6 @@ */ import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.net.ssl.SSLContext; import java.io.IOException; @@ -61,7 +52,6 @@ import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandlers; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; @@ -81,27 +71,40 @@ import static java.net.http.HttpClient.Version.HTTP_3; import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY; import static java.net.http.HttpOption.H3_DISCOVERY; import static java.nio.charset.StandardCharsets.UTF_8; -import static org.testng.Assert.assertEquals; + +import org.junit.jupiter.api.AfterAll; + +import static jdk.httpclient.test.lib.common.HttpServerAdapters.createClientBuilderForH3; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ForbiddenHeadTest implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer httpTestServer; // HTTP/1.1 - HttpTestServer httpsTestServer; // HTTPS/1.1 - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - HttpTestServer http3TestServer; // HTTP/3 ( h3 ) - DigestEchoServer.TunnelingProxy proxy; - DigestEchoServer.TunnelingProxy authproxy; - String httpURI; - String httpsURI; - String http2URI; - String https2URI; - String https3URI; - HttpClient authClient; - HttpClient noAuthClient; + private static HttpTestServer httpTestServer; // HTTP/1.1 + private static HttpTestServer httpsTestServer; // HTTPS/1.1 + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static HttpTestServer http3TestServer; // HTTP/3 ( h3 ) + private static DigestEchoServer.TunnelingProxy proxy; + private static DigestEchoServer.TunnelingProxy authproxy; + private static String httpURI; + private static String httpsURI; + private static String http2URI; + private static String https2URI; + private static String https3URI; + private static HttpClient authClient; + private static HttpClient noAuthClient; - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; static final long SLEEP_AFTER_TEST = 0; // milliseconds static final int ITERATIONS = 3; static final Executor executor = new TestExecutor(Executors.newCachedThreadPool()); @@ -142,34 +145,39 @@ public class ForbiddenHeadTest implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); - } - - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); } } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } } - @AfterClass - static final void printFailedTests(ITestContext context) { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + + @AfterAll + static void printFailedTests() { out.println("\n========================="); try { // Exceptions should already have been added to FAILURES @@ -201,8 +209,7 @@ public class ForbiddenHeadTest implements HttpServerAdapters { static final String MESSAGE = "Unauthorized"; - @DataProvider(name = "all") - public Object[][] allcases() { + public static Object[][] allcases() { List result = new ArrayList<>(); for (boolean useAuth : List.of(true, false)) { for (boolean async : List.of(true, false)) { @@ -226,8 +233,6 @@ public class ForbiddenHeadTest implements HttpServerAdapters { return result.toArray(new Object[0][0]); } - static final AtomicLong requestCounter = new AtomicLong(); - static final Authenticator authenticator = new Authenticator() { @Override protected PasswordAuthentication getPasswordAuthentication() { @@ -237,9 +242,9 @@ public class ForbiddenHeadTest implements HttpServerAdapters { static final AtomicLong sleepCount = new AtomicLong(); - @Test(dataProvider = "all") + @ParameterizedTest + @MethodSource("allcases") void test(String uriString, int code, boolean async, boolean useAuth) throws Throwable { - checkSkip(); HttpClient client = useAuth ? authClient : noAuthClient; var name = String.format("test(%s, %d, %s, %s)", uriString, code, async ? "async" : "sync", client.authenticator().isPresent() ? "authClient" : "noAuthClient"); @@ -318,23 +323,23 @@ public class ForbiddenHeadTest implements HttpServerAdapters { out.println(" Got response: " + response); - assertEquals(response.statusCode(), forbidden? FORBIDDEN : code); - assertEquals(response.body(), expectedValue == null ? null : ""); - assertEquals(response.headers().firstValue("X-value"), Optional.ofNullable(expectedValue)); + assertEquals(forbidden? FORBIDDEN : code, response.statusCode()); + assertEquals(expectedValue == null ? null : "", response.body()); + assertEquals(Optional.ofNullable(expectedValue), response.headers().firstValue("X-value")); // when the CONNECT request fails, its body is discarded - but // the response header may still contain its content length. // don't check content length in that case. if (expectedValue != null) { String clen = String.valueOf(expectedValue.getBytes(UTF_8).length); - assertEquals(response.headers().firstValue("Content-Length"), Optional.of(clen)); + assertEquals(Optional.of(clen), response.headers().firstValue("Content-Length")); } } // -- Infrastructure - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { httpTestServer = HttpTestServer.create(HTTP_1_1); httpTestServer.addHandler(new UnauthorizedHandler(), "/http1/"); httpTestServer.addHandler(new UnauthorizedHandler(), "/http2/proxy/"); @@ -357,7 +362,7 @@ public class ForbiddenHeadTest implements HttpServerAdapters { proxy = DigestEchoServer.createHttpsProxyTunnel(DigestEchoServer.HttpAuthSchemeType.NONE); authproxy = DigestEchoServer.createHttpsProxyTunnel(DigestEchoServer.HttpAuthSchemeType.BASIC); - authClient = TRACKER.track(newClientBuilderForH3() + authClient = TRACKER.track(createClientBuilderForH3() .proxy(TestProxySelector.of(proxy, authproxy, httpTestServer)) .sslContext(sslContext) .executor(executor) @@ -365,7 +370,7 @@ public class ForbiddenHeadTest implements HttpServerAdapters { .build()); clientCount.incrementAndGet(); - noAuthClient = TRACKER.track(newClientBuilderForH3() + noAuthClient = TRACKER.track(createClientBuilderForH3() .proxy(TestProxySelector.of(proxy, authproxy, httpTestServer)) .sslContext(sslContext) .executor(executor) @@ -384,8 +389,8 @@ public class ForbiddenHeadTest implements HttpServerAdapters { serverCount.incrementAndGet(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { authClient = noAuthClient = null; Thread.sleep(100); AssertionError fail = TRACKER.check(1500); diff --git a/test/jdk/java/net/httpclient/HeadersLowerCaseTest.java b/test/jdk/java/net/httpclient/HeadersLowerCaseTest.java index b1e4e569010..00a709a3387 100644 --- a/test/jdk/java/net/httpclient/HeadersLowerCaseTest.java +++ b/test/jdk/java/net/httpclient/HeadersLowerCaseTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 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 @@ -43,7 +43,6 @@ import jdk.internal.net.http.common.Utils; import jdk.test.lib.net.SimpleSSLContext; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.TestInstance; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; @@ -63,19 +62,18 @@ import static org.junit.jupiter.api.Assertions.assertThrows; * jdk.httpclient.test.lib.common.HttpServerAdapters * @run junit/othervm -Djdk.internal.httpclient.debug=true HeadersLowerCaseTest */ -@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class HeadersLowerCaseTest implements HttpServerAdapters { private static Set REQUEST_HEADERS; - private HttpTestServer h2server; - private HttpTestServer h3server; - private String h2ReqURIBase; - private String h3ReqURIBase; + private static HttpTestServer h2server; + private static HttpTestServer h3server; + private static String h2ReqURIBase; + private static String h3ReqURIBase; private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); @BeforeAll - public void beforeAll() throws Exception { + public static void beforeAll() throws Exception { h2server = HttpTestServer.create(HTTP_2, sslContext); h2server.start(); h2ReqURIBase = "https://" + h2server.serverAuthority(); @@ -100,7 +98,7 @@ public class HeadersLowerCaseTest implements HttpServerAdapters { } @AfterAll - public void afterAll() throws Exception { + public static void afterAll() throws Exception { if (h2server != null) { h2server.stop(); } @@ -157,14 +155,14 @@ public class HeadersLowerCaseTest implements HttpServerAdapters { } } - private Stream params() throws Exception { + private static Stream params() throws Exception { return Stream.of( Arguments.of(HTTP_2, new URI(h2ReqURIBase + "/h2verifyReqHeaders")), Arguments.of(Version.HTTP_3, new URI(h3ReqURIBase + "/h3verifyReqHeaders"))); } /** - * Issues a HTTP/2 or HTTP/3 request with header names of varying case (some in lower, + * Issues an HTTP/2 or HTTP/3 request with header names of varying case (some in lower, * some mixed, some upper case) and expects that the client internally converts them * to lower case before encoding and sending to the server. The server side handler verifies * that it receives the header names in lower case and if it doesn't then it returns a diff --git a/test/jdk/java/net/httpclient/HttpInputStreamAvailableTest.java b/test/jdk/java/net/httpclient/HttpInputStreamAvailableTest.java index 5cca88716b6..99897a69a8c 100644 --- a/test/jdk/java/net/httpclient/HttpInputStreamAvailableTest.java +++ b/test/jdk/java/net/httpclient/HttpInputStreamAvailableTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 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 @@ -21,7 +21,7 @@ * questions. */ -/** +/* * @test * @bug 8306040 * @summary HttpResponseInputStream.available() returns 1 on empty stream @@ -47,19 +47,17 @@ import java.net.http.HttpResponse; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.TestInstance; import static org.junit.jupiter.api.Assertions.assertEquals; -@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class HttpInputStreamAvailableTest { - private HttpServer server; - private int port; - static final String TEST_MESSAGE = "This is test message"; - static final int ZERO = 0; + private static HttpServer server; + private static int port; + private static final String TEST_MESSAGE = "This is test message"; + private static final int ZERO = 0; @BeforeAll - void setup() throws Exception { + static void setup() throws Exception { InetAddress loopback = InetAddress.getLoopbackAddress(); InetSocketAddress addr = new InetSocketAddress(loopback, 0); server = HttpServer.create(addr, 0); @@ -72,69 +70,71 @@ public class HttpInputStreamAvailableTest { } @AfterAll - void teardown() throws Exception { + static void teardown() throws Exception { server.stop(0); } @Test public void test() throws Exception { - HttpClient client = HttpClient + try (HttpClient client = HttpClient .newBuilder() .proxy(HttpClient.Builder.NO_PROXY) - .build(); + .build()) { - URI uri = URIBuilder.newBuilder() - .scheme("http") - .loopback() - .port(port) - .path("/NonZeroResponse/") - .build(); + URI uri = URIBuilder.newBuilder() + .scheme("http") + .loopback() + .port(port) + .path("/NonZeroResponse/") + .build(); - HttpRequest request = HttpRequest - .newBuilder(uri) - .GET() - .build(); + HttpRequest request = HttpRequest + .newBuilder(uri) + .GET() + .build(); - // Send a httpRequest and assert the bytes available - HttpResponse response = client.send(request, - HttpResponse.BodyHandlers.ofInputStream()); - try ( InputStream in = response.body()) { - in.readNBytes(2); - // this is not guaranteed, but a failure here would be surprising - assertEquals(TEST_MESSAGE.length() - 2, in.available()); - //read the remaining data - in.readAllBytes(); - //available should return 0 - assertEquals(ZERO, in.available()); + // Send a httpRequest and assert the bytes available + HttpResponse response = client.send(request, + HttpResponse.BodyHandlers.ofInputStream()); + try (InputStream in = response.body()) { + in.readNBytes(2); + // this is not guaranteed, but a failure here would be surprising + assertEquals(TEST_MESSAGE.length() - 2, in.available()); + //read the remaining data + in.readAllBytes(); + //available should return 0 + assertEquals(ZERO, in.available()); + } } } @Test public void test1() throws Exception { - HttpClient client = HttpClient + try (HttpClient client = HttpClient .newBuilder() .proxy(HttpClient.Builder.NO_PROXY) - .build(); + .build()) { - URI uri = URIBuilder.newBuilder() - .scheme("http") - .loopback() - .port(port) - .path("/ZeroResponse/") - .build(); + URI uri = URIBuilder.newBuilder() + .scheme("http") + .loopback() + .port(port) + .path("/ZeroResponse/") + .build(); - HttpRequest request = HttpRequest - .newBuilder(uri) - .GET() - .build(); + HttpRequest request = HttpRequest + .newBuilder(uri) + .GET() + .build(); - // Send a httpRequest and assert the bytes available - HttpResponse response = client.send(request, - HttpResponse.BodyHandlers.ofInputStream()); - try ( InputStream in = response.body()) { - assertEquals(ZERO, in.available()); - in.readAllBytes(); - assertEquals(ZERO, in.available()); + // Send a httpRequest and assert the bytes available + HttpResponse response = client.send(request, + HttpResponse.BodyHandlers.ofInputStream()); + try (InputStream in = response.body()) { + assertEquals(ZERO, in.available()); + in.readAllBytes(); + assertEquals(ZERO, in.available()); + } } } diff --git a/test/jdk/java/net/httpclient/HttpResponseInputStreamInterruptTest.java b/test/jdk/java/net/httpclient/HttpResponseInputStreamInterruptTest.java index 6468175ab59..3b955b8feb7 100644 --- a/test/jdk/java/net/httpclient/HttpResponseInputStreamInterruptTest.java +++ b/test/jdk/java/net/httpclient/HttpResponseInputStreamInterruptTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 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 @@ -35,7 +35,6 @@ import jdk.test.lib.net.URIBuilder; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.TestInstance; import java.io.IOException; import java.io.InputStream; @@ -53,18 +52,17 @@ import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; -@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class HttpResponseInputStreamInterruptTest { - HttpServer server; - int port; - private final CountDownLatch interruptReadyLatch = new CountDownLatch(2); - private final CountDownLatch interruptDoneLatch = new CountDownLatch(1); + private static HttpServer server; + private static int port; + private static final CountDownLatch interruptReadyLatch = new CountDownLatch(2); + private static final CountDownLatch interruptDoneLatch = new CountDownLatch(1); static final String FIRST_MESSAGE = "Should be received"; static final String SECOND_MESSAGE = "Shouldn't be received"; @BeforeAll - void before() throws Exception { + static void before() throws Exception { InetAddress loopback = InetAddress.getLoopbackAddress(); InetSocketAddress addr = new InetSocketAddress(loopback, 0); server = HttpServer.create(addr, 0); @@ -75,7 +73,7 @@ public class HttpResponseInputStreamInterruptTest { } @AfterAll - void after() throws Exception { + static void after() throws Exception { server.stop(0); } diff --git a/test/jdk/java/net/httpclient/ISO_8859_1_Test.java b/test/jdk/java/net/httpclient/ISO_8859_1_Test.java index d629a6f3105..103284c9d54 100644 --- a/test/jdk/java/net/httpclient/ISO_8859_1_Test.java +++ b/test/jdk/java/net/httpclient/ISO_8859_1_Test.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 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 @@ -27,7 +27,7 @@ * @library /test/lib /test/jdk/java/net/httpclient/lib * @build jdk.httpclient.test.lib.common.HttpServerAdapters jdk.test.lib.net.SimpleSSLContext * ReferenceTracker - * @run testng/othervm -Djdk.internal.httpclient.debug=true + * @run junit/othervm -Djdk.internal.httpclient.debug=true * -Djdk.httpclient.HttpClient.log=requests,responses,errors * ISO_8859_1_Test * @summary Tests that a client is able to receive ISO-8859-1 encoded header values. @@ -48,7 +48,6 @@ import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandlers; import java.nio.charset.StandardCharsets; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; @@ -60,21 +59,11 @@ import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; -import java.util.stream.Collectors; import javax.net.ssl.SSLContext; import jdk.httpclient.test.lib.common.HttpServerAdapters; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import static java.lang.System.out; import static java.net.http.HttpClient.Version.HTTP_1_1; @@ -82,30 +71,38 @@ import static java.net.http.HttpClient.Version.HTTP_2; import static java.net.http.HttpClient.Version.HTTP_3; import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY; import static java.net.http.HttpOption.H3_DISCOVERY; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; + +import org.junit.jupiter.api.AfterAll; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ISO_8859_1_Test implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - DummyServer http1DummyServer; - HttpTestServer http1TestServer; // HTTP/1.1 ( http ) - HttpTestServer https1TestServer; // HTTPS/1.1 ( https ) - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - HttpTestServer http3TestServer; // HTTP/3 ( h3 ) - String http1Dummy; - String http1URI; - String https1URI; - String http2URI; - String https2URI; - String http3URI; + private static DummyServer http1DummyServer; + private static HttpTestServer http1TestServer; // HTTP/1.1 ( http ) + private static HttpTestServer https1TestServer; // HTTPS/1.1 ( https ) + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static HttpTestServer http3TestServer; // HTTP/3 ( h3 ) + private static String http1Dummy; + private static String http1URI; + private static String https1URI; + private static String http2URI; + private static String https2URI; + private static String http3URI; - static final int RESPONSE_CODE = 200; static final int ITERATION_COUNT = 4; - static final Class IAE = IllegalArgumentException.class; - static final Class CE = CompletionException.class; // a shared executor helps reduce the amount of threads created by the test static final Executor executor = new TestExecutor(Executors.newCachedThreadPool()); static final ConcurrentMap FAILURES = new ConcurrentHashMap<>(); @@ -121,8 +118,8 @@ public class ISO_8859_1_Test implements HttpServerAdapters { return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; - private volatile HttpClient sharedClient; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static volatile HttpClient sharedClient; static class TestExecutor implements Executor { final AtomicLong tasks = new AtomicLong(); @@ -148,40 +145,40 @@ public class ISO_8859_1_Test implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); - } - - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); } } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } } - @AfterClass - static final void printFailedTests(ITestContext context) { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @AfterAll + static void printFailedTests() { out.println("\n========================="); try { - var failed = context.getFailedTests().getAllResults().stream() - .collect(Collectors.toMap(r -> name(r), ITestResult::getThrowable)); - FAILURES.putAll(failed); - out.printf("%n%sCreated %d servers and %d clients%n", now(), serverCount.get(), clientCount.get()); if (FAILURES.isEmpty()) return; @@ -199,7 +196,7 @@ public class ISO_8859_1_Test implements HttpServerAdapters { } } - private String[] uris() { + private static String[] uris() { return new String[] { http3URI, http1Dummy, @@ -210,13 +207,7 @@ public class ISO_8859_1_Test implements HttpServerAdapters { }; } - static AtomicLong URICOUNT = new AtomicLong(); - - @DataProvider(name = "variants") - public Object[][] variants(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - return new Object[0][]; - } + public static Object[][] variants() { String[] uris = uris(); Object[][] result = new Object[uris.length * 2][]; int i = 0; @@ -265,7 +256,7 @@ public class ISO_8859_1_Test implements HttpServerAdapters { } } - private static final Exception completionCause(CompletionException x) { + private static Exception completionCause(CompletionException x) { Throwable c = x; while (c instanceof CompletionException || c instanceof ExecutionException) { @@ -285,10 +276,11 @@ public class ISO_8859_1_Test implements HttpServerAdapters { return builder; } - @Test(dataProvider = "variants") + @ParameterizedTest + @MethodSource("variants") public void test(String uri, boolean sameClient) throws Exception { - checkSkip(); - System.out.println("Request to " + uri); + + System.out.printf("%n%s-- test sameClient=%s uri=%s%n%n", now(), sameClient, uri); HttpClient client = newHttpClient(uri, sameClient); @@ -307,7 +299,7 @@ public class ISO_8859_1_Test implements HttpServerAdapters { var response = cf.get(); System.out.println("Got: " + response); var value = response.headers().firstValue("Header8859").orElse(null); - assertEquals(value, "U\u00ffU"); + assertEquals("U\u00ffU", value); } System.out.println("HttpClient: PASSED"); if (uri.contains("http1")) { @@ -317,10 +309,10 @@ public class ISO_8859_1_Test implements HttpServerAdapters { conn.connect(); conn.getInputStream().readAllBytes(); var value = conn.getHeaderField("Header8859"); - assertEquals(value, "U\u00ffU", "legacy stack failed"); + assertEquals("U\u00ffU", value, "legacy stack failed"); System.out.println("URLConnection: PASSED"); } - System.out.println("test: DONE"); + System.out.println(now() + "test: DONE"); } static final class DummyServer extends Thread implements AutoCloseable { @@ -335,8 +327,8 @@ public class ISO_8859_1_Test implements HttpServerAdapters { static final InetSocketAddress LOOPBACK = new InetSocketAddress(InetAddress.getLoopbackAddress(), 0); final ServerSocket socket; - final CopyOnWriteArrayList accepted = new CopyOnWriteArrayList(); - final CompletableFuture done = new CompletableFuture(); + final CopyOnWriteArrayList accepted = new CopyOnWriteArrayList<>(); + final CompletableFuture done = new CompletableFuture<>(); volatile boolean closed; DummyServer() throws IOException { socket = new ServerSocket(); @@ -387,11 +379,11 @@ public class ISO_8859_1_Test implements HttpServerAdapters { } } - final void close(AutoCloseable toclose) { + void close(AutoCloseable toclose) { try { toclose.close(); } catch (Exception x) {}; } - final public void close() { + public void close() { closed = true; close(socket); accepted.forEach(this::close); @@ -410,8 +402,8 @@ public class ISO_8859_1_Test implements HttpServerAdapters { } } - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { HttpServerAdapters.HttpTestHandler handler = new ISO88591Handler(); InetSocketAddress loopback = new InetSocketAddress(InetAddress.getLoopbackAddress(), 0); @@ -448,8 +440,8 @@ public class ISO_8859_1_Test implements HttpServerAdapters { http3TestServer.start(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { String sharedClientName = sharedClient == null ? null : sharedClient.toString(); sharedClient = null; diff --git a/test/jdk/java/net/httpclient/ProxySelectorTest.java b/test/jdk/java/net/httpclient/ProxySelectorTest.java index bf63e5a77b5..bb339e91bdc 100644 --- a/test/jdk/java/net/httpclient/ProxySelectorTest.java +++ b/test/jdk/java/net/httpclient/ProxySelectorTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 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 @@ -27,34 +27,20 @@ * @summary checks that a different proxy returned for * the same host:port is taken into account * @library /test/lib /test/jdk/java/net/httpclient/lib - * @build DigestEchoServer ProxySelectorTest jdk.httpclient.test.lib.http2.Http2TestServer + * @build DigestEchoServer ProxySelectorTest * jdk.test.lib.net.SimpleSSLContext - * @run testng/othervm + * @run junit/othervm * -Djdk.http.auth.tunneling.disabledSchemes * -Djdk.httpclient.HttpClient.log=headers,requests * -Djdk.internal.httpclient.debug=true * ProxySelectorTest */ -import com.sun.net.httpserver.HttpServer; -import com.sun.net.httpserver.HttpsConfigurator; -import com.sun.net.httpserver.HttpsServer; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.net.ssl.SSLContext; import java.io.IOException; import java.io.InputStream; -import java.net.InetAddress; -import java.net.InetSocketAddress; import java.net.Proxy; import java.net.ProxySelector; import java.net.SocketAddress; @@ -63,7 +49,6 @@ import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandlers; -import java.util.Arrays; import java.util.List; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; @@ -73,37 +58,44 @@ import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; -import java.util.stream.Collectors; import jdk.httpclient.test.lib.common.HttpServerAdapters; -import jdk.httpclient.test.lib.http2.Http2TestServer; import static java.lang.System.err; import static java.lang.System.out; import static java.net.http.HttpClient.Version.HTTP_1_1; import static java.net.http.HttpClient.Version.HTTP_2; import static java.nio.charset.StandardCharsets.UTF_8; -import static org.testng.Assert.assertEquals; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import static org.junit.jupiter.api.Assertions.*; public class ProxySelectorTest implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer httpTestServer; // HTTP/1.1 - HttpTestServer proxyHttpTestServer; // HTTP/1.1 - HttpTestServer authProxyHttpTestServer; // HTTP/1.1 - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer httpsTestServer; // HTTPS/1.1 - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - DigestEchoServer.TunnelingProxy proxy; - DigestEchoServer.TunnelingProxy authproxy; - String httpURI; - String httpsURI; - String proxyHttpURI; - String authProxyHttpURI; - String http2URI; - String https2URI; - HttpClient client; + private static HttpTestServer httpTestServer; // HTTP/1.1 + private static HttpTestServer proxyHttpTestServer; // HTTP/1.1 + private static HttpTestServer authProxyHttpTestServer; // HTTP/1.1 + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer httpsTestServer; // HTTPS/1.1 + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static DigestEchoServer.TunnelingProxy proxy; + private static DigestEchoServer.TunnelingProxy authproxy; + private static String httpURI; + private static String httpsURI; + private static String proxyHttpURI; + private static String http2URI; + private static String https2URI; + private static HttpClient client; - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; static final long SLEEP_AFTER_TEST = 0; // milliseconds static final int ITERATIONS = 3; static final Executor executor = new TestExecutor(Executors.newCachedThreadPool()); @@ -144,34 +136,38 @@ public class ProxySelectorTest implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); - } - - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); } } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } } - @AfterClass - static final void printFailedTests() { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @AfterAll + static void printFailedTests() { out.println("\n========================="); try { // Exceptions should already have been added to FAILURES @@ -204,12 +200,10 @@ public class ProxySelectorTest implements HttpServerAdapters { static final int UNAUTHORIZED = 401; static final int PROXY_UNAUTHORIZED = 407; static final int HTTP_OK = 200; - static final String MESSAGE = "Unauthorized"; enum Schemes { HTTP, HTTPS } - @DataProvider(name = "all") - public Object[][] positive() { + public static Object[][] positive() { return new Object[][] { { Schemes.HTTP, HTTP_1_1, httpURI, true}, { Schemes.HTTP, HttpClient.Version.HTTP_2, http2URI, true}, @@ -222,15 +216,13 @@ public class ProxySelectorTest implements HttpServerAdapters { }; } - static final AtomicLong requestCounter = new AtomicLong(); - static final AtomicLong sleepCount = new AtomicLong(); - @Test(dataProvider = "all") + @ParameterizedTest + @MethodSource("positive") void test(Schemes scheme, HttpClient.Version version, String uri, boolean async) throws Throwable { - checkSkip(); var name = String.format("test(%s, %s, %s)", scheme, version, async); out.printf("%n---- starting %s ----%n", name); @@ -260,7 +252,7 @@ public class ProxySelectorTest implements HttpServerAdapters { HttpRequest request = requestBuilder.build(); out.println("Sending request: " + request.uri()); - HttpResponse response = null; + HttpResponse response; if (async) { response = client.send(request, handler); } else { @@ -288,9 +280,11 @@ public class ProxySelectorTest implements HttpServerAdapters { // A plain server or https server should serve it, and we should get 200 OK response = send(client, uri1, BodyHandlers.ofString(), async); out.println("Got response from plain server: " + response); - assertEquals(response.statusCode(), HTTP_OK); - assertEquals(response.headers().firstValue("X-value"), - scheme == Schemes.HTTPS ? Optional.of("https-server") : Optional.of("plain-server")); + assertEquals(HTTP_OK, response.statusCode()); + assertEquals(scheme == Schemes.HTTPS + ? Optional.of("https-server") + : Optional.of("plain-server"), + response.headers().firstValue("X-value")); // Second request should go through a non authenticating proxy. // For a clear connection - a proxy-server should serve it, and we should get 200 OK @@ -298,9 +292,11 @@ public class ProxySelectorTest implements HttpServerAdapters { // authenticating proxy - and we should receive 200 OK from an https-server response = send(client, uri2, BodyHandlers.ofString(), async); out.println("Got response through noauth proxy: " + response); - assertEquals(response.statusCode(), HTTP_OK); - assertEquals(response.headers().firstValue("X-value"), - scheme == Schemes.HTTPS ? Optional.of("https-server") : Optional.of("proxy-server")); + assertEquals(HTTP_OK, response.statusCode()); + assertEquals(scheme == Schemes.HTTPS + ? Optional.of("https-server") + : Optional.of("proxy-server"), + response.headers().firstValue("X-value")); // Third request should go through an authenticating proxy. // For a clear connection - an auth-proxy-server should serve it, and we @@ -310,16 +306,18 @@ public class ProxySelectorTest implements HttpServerAdapters { // proxy - so the X-value header will be absent response = send(client, uri3, BodyHandlers.ofString(), async); out.println("Got response through auth proxy: " + response); - assertEquals(response.statusCode(), PROXY_UNAUTHORIZED); - assertEquals(response.headers().firstValue("X-value"), - scheme == Schemes.HTTPS ? Optional.empty() : Optional.of("auth-proxy-server")); + assertEquals(PROXY_UNAUTHORIZED, response.statusCode()); + assertEquals(scheme == Schemes.HTTPS + ? Optional.empty() + : Optional.of("auth-proxy-server"), + response.headers().firstValue("X-value")); } // -- Infrastructure - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { httpTestServer = HttpTestServer.create(HTTP_1_1); httpTestServer.addHandler(new PlainServerHandler("plain-server"), "/http1/"); httpURI = "http://" + httpTestServer.serverAuthority() + "/http1"; @@ -368,8 +366,8 @@ public class ProxySelectorTest implements HttpServerAdapters { serverCount.incrementAndGet(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { client = null; Thread.sleep(100); AssertionError fail = TRACKER.check(1500); @@ -387,7 +385,7 @@ public class ProxySelectorTest implements HttpServerAdapters { } } - class TestProxySelector extends ProxySelector { + static final class TestProxySelector extends ProxySelector { @Override public List select(URI uri) { String path = uri.getPath(); @@ -426,11 +424,8 @@ public class ProxySelectorTest implements HttpServerAdapters { String path = t.getRequestURI().getPath(); HttpTestRequestHeaders reqh = t.getRequestHeaders(); HttpTestResponseHeaders rsph = t.getResponseHeaders(); - - String xValue = serverType; rsph.addHeader("X-value", serverType); - t.getResponseHeaders().addHeader("X-value", xValue); byte[] body = "RESPONSE".getBytes(UTF_8); t.sendResponseHeaders(HTTP_OK, body.length); try (var out = t.getResponseBody()) { @@ -449,20 +444,16 @@ public class ProxySelectorTest implements HttpServerAdapters { @Override public void handle(HttpTestExchange t) throws IOException { readAllRequestData(t); // shouldn't be any - String method = t.getRequestMethod(); String path = t.getRequestURI().getPath(); - HttpTestRequestHeaders reqh = t.getRequestHeaders(); HttpTestResponseHeaders rsph = t.getResponseHeaders(); - String xValue = serverType; - String srv = path.contains("/proxy/") ? "proxy" : "server"; String prefix = path.contains("/proxy/") ? "Proxy-" : "WWW-"; int code = path.contains("/proxy/") ? PROXY_UNAUTHORIZED : UNAUTHORIZED; String resp = prefix + "Unauthorized"; rsph.addHeader(prefix + "Authenticate", "Basic realm=\"earth\", charset=\"UTF-8\""); byte[] body = resp.getBytes(UTF_8); - t.getResponseHeaders().addHeader("X-value", xValue); + rsph.addHeader("X-value", serverType); t.sendResponseHeaders(code, body.length); try (var out = t.getResponseBody()) { out.write(body); diff --git a/test/jdk/java/net/httpclient/Response204V2Test.java b/test/jdk/java/net/httpclient/Response204V2Test.java index c9dbd8eccf9..835f7aa65f7 100644 --- a/test/jdk/java/net/httpclient/Response204V2Test.java +++ b/test/jdk/java/net/httpclient/Response204V2Test.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 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 @@ -27,7 +27,7 @@ * @library /test/lib /test/jdk/java/net/httpclient/lib * @build jdk.test.lib.net.SimpleSSLContext * ReferenceTracker jdk.httpclient.test.lib.common.HttpServerAdapters - * @run testng/othervm -Djdk.internal.httpclient.debug=true + * @run junit/othervm -Djdk.internal.httpclient.debug=true * -Djdk.httpclient.HttpClient.log=requests,responses,errors * Response204V2Test * @summary Tests that streams are closed after receiving a 204 response. @@ -44,7 +44,6 @@ import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandlers; -import java.util.Arrays; import java.util.List; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; @@ -52,19 +51,9 @@ import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; -import java.util.stream.Collectors; import jdk.httpclient.test.lib.common.HttpServerAdapters; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.net.ssl.SSLContext; @@ -74,15 +63,25 @@ import static java.net.http.HttpClient.Version.HTTP_3; import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY; import static java.net.http.HttpOption.H3_DISCOVERY; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + public class Response204V2Test implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - HttpTestServer http3TestServer; // HTTP/3 ( h3 ) - String http2URI; - String https2URI; - String http3URI; + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static HttpTestServer http3TestServer; // HTTP/3 ( h3 ) + private static String http2URI; + private static String https2URI; + private static String http3URI; static final int RESPONSE_CODE = 204; static final int ITERATION_COUNT = 4; @@ -101,8 +100,8 @@ public class Response204V2Test implements HttpServerAdapters { return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; - private volatile HttpClient sharedClient; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static volatile HttpClient sharedClient; static class TestExecutor implements Executor { final AtomicLong tasks = new AtomicLong(); @@ -128,40 +127,40 @@ public class Response204V2Test implements HttpServerAdapters { } } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); - } - - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); } } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } } - @AfterClass - static final void printFailedTests(ITestContext context) { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @AfterAll + static final void printFailedTests() { out.println("\n========================="); try { - var failed = context.getFailedTests().getAllResults().stream() - .collect(Collectors.toMap(r -> name(r), ITestResult::getThrowable)); - FAILURES.putAll(failed); - out.printf("%n%sCreated %d servers and %d clients%n", now(), serverCount.get(), clientCount.get()); if (FAILURES.isEmpty()) return; @@ -179,7 +178,7 @@ public class Response204V2Test implements HttpServerAdapters { } } - private String[] uris() { + private static String[] uris() { return new String[] { http3URI, http2URI, @@ -187,13 +186,7 @@ public class Response204V2Test implements HttpServerAdapters { }; } - static AtomicLong URICOUNT = new AtomicLong(); - - @DataProvider(name = "variants") - public Object[][] variants(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - return new Object[0][]; - } + public static Object[][] variants() { String[] uris = uris(); Object[][] result = new Object[uris.length * 2][]; int i = 0; @@ -232,23 +225,6 @@ public class Response204V2Test implements HttpServerAdapters { } } - - static void checkStatus(int expected, int found) throws Exception { - if (expected != found) { - System.err.printf ("Test failed: wrong status code %d/%d\n", - expected, found); - throw new RuntimeException("Test failed"); - } - } - - static void checkStrings(String expected, String found) throws Exception { - if (!expected.equals(found)) { - System.err.printf ("Test failed: wrong string %s/%s\n", - expected, found); - throw new RuntimeException("Test failed"); - } - } - private HttpRequest.Builder newRequestBuilder(URI uri) { var builder = HttpRequest.newBuilder(uri); if (uri.getRawPath().contains("/http3/")) { @@ -258,10 +234,10 @@ public class Response204V2Test implements HttpServerAdapters { return builder; } - @Test(dataProvider = "variants") + @ParameterizedTest + @MethodSource("variants") public void test(String uri, boolean sameClient) throws Exception { - checkSkip(); - out.println("Request to " + uri); + out.printf("%n%s-- test sameClient=%s, uri=%s%n%n", now(), sameClient, uri); HttpClient client = newHttpClient(uri, sameClient); @@ -282,8 +258,8 @@ public class Response204V2Test implements HttpServerAdapters { out.println("test: DONE"); } - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { // HTTP/2 HttpTestHandler handler204 = new Handler204(); @@ -305,8 +281,8 @@ public class Response204V2Test implements HttpServerAdapters { http3TestServer.start(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { String sharedClientName = sharedClient == null ? null : sharedClient.toString(); sharedClient = null; diff --git a/test/jdk/java/net/httpclient/ShortResponseBody.java b/test/jdk/java/net/httpclient/ShortResponseBody.java index b4fd83585ee..5f931cd1ed3 100644 --- a/test/jdk/java/net/httpclient/ShortResponseBody.java +++ b/test/jdk/java/net/httpclient/ShortResponseBody.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 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 @@ -36,24 +36,16 @@ import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.util.Arrays; import java.util.List; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; -import java.util.stream.Collectors; import java.util.stream.Stream; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLHandshakeException; import javax.net.ssl.SSLServerSocketFactory; @@ -64,28 +56,40 @@ import static java.net.http.HttpClient.Builder.NO_PROXY; import static java.net.http.HttpResponse.BodyHandlers.ofString; import static java.nio.charset.StandardCharsets.US_ASCII; import static java.util.stream.Collectors.toList; -import static org.testng.Assert.assertTrue; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.fail; + +import org.junit.jupiter.api.AfterAll; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public abstract class ShortResponseBody { - Server closeImmediatelyServer; - Server closeImmediatelyHttpsServer; - Server variableLengthServer; - Server variableLengthHttpsServer; - Server fixedLengthServer; + private static Server closeImmediatelyServer; + private static Server closeImmediatelyHttpsServer; + private static Server variableLengthServer; + private static Server variableLengthHttpsServer; + private static Server fixedLengthServer; - String httpURIClsImed; - String httpsURIClsImed; - String httpURIVarLen; - String httpsURIVarLen; - String httpURIFixLen; + private static String httpURIClsImed; + private static String httpsURIClsImed; + private static String httpURIVarLen; + private static String httpsURIVarLen; + private static String httpURIFixLen; private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - SSLParameters sslParameters; - HttpClient client; - int numberOfRequests; + private static SSLParameters sslParameters; + protected static HttpClient client; + private static int numberOfRequests; static final int REQUESTS_PER_CLIENT = 10; // create new client every 10 requests static final long PAUSE_FOR_GC = 5; // 5ms to let gc work @@ -99,7 +103,7 @@ public abstract class ShortResponseBody { static final AtomicLong reqnb = new AtomicLong(); static final AtomicLong ids = new AtomicLong(); - final ThreadFactory factory = new ThreadFactory() { + private static final ThreadFactory factory = new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, "HttpClient-Worker-" + ids.incrementAndGet()); @@ -107,21 +111,49 @@ public abstract class ShortResponseBody { return thread; } }; - final ExecutorService service = Executors.newCachedThreadPool(factory); - - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); + private static final ExecutorService service = Executors.newCachedThreadPool(factory); + static final ConcurrentMap FAILURES = new ConcurrentHashMap<>(); + static final long start = System.nanoTime(); + public static String now() { + long now = System.nanoTime() - start; + long secs = now / 1000_000_000; + long mill = (now % 1000_000_000) / 1000_000; + long nan = now % 1000_000; + return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - @BeforeMethod - void beforeMethod(ITestContext context) { + private static boolean stopAfterFirstFailure() { + return Boolean.getBoolean("jdk.internal.httpclient.debug"); + } + + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + } + } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } + } + + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @BeforeEach + void beforeMethod() { if (client == null || numberOfRequests == REQUESTS_PER_CLIENT) { numberOfRequests = 0; out.println("--- new client"); @@ -134,22 +166,12 @@ public abstract class ShortResponseBody { } } numberOfRequests++; - if (context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); - } - } } - @AfterClass - static final void printFailedTests(ITestContext context) { + @AfterAll + static void printFailedTests() { out.println("\n=========================\n"); try { - var FAILURES = context.getFailedTests().getAllResults().stream() - .collect(Collectors.toMap(r -> name(r), ITestResult::getThrowable)); - if (FAILURES.isEmpty()) return; out.println("Failed tests: "); FAILURES.entrySet().forEach((e) -> { @@ -162,8 +184,7 @@ public abstract class ShortResponseBody { } } - @DataProvider(name = "sanity") - public Object[][] sanity() { + public static Object[][] sanity() { return new Object[][]{ { httpURIVarLen + "?length=all" }, { httpsURIVarLen + "?length=all" }, @@ -175,22 +196,22 @@ public abstract class ShortResponseBody { return url.replace("%reqnb%", String.valueOf(reqnb.incrementAndGet())); } - @Test(dataProvider = "sanity") + @ParameterizedTest + @MethodSource("sanity") void sanity(String url) throws Exception { url = uniqueURL(url); HttpRequest request = HttpRequest.newBuilder(URI.create(url)).build(); out.println("Request: " + request); HttpResponse response = client.send(request, ofString()); String body = response.body(); - assertEquals(body, EXPECTED_RESPONSE_BODY); + assertEquals(EXPECTED_RESPONSE_BODY, body); client.sendAsync(request, ofString()) .thenApply(resp -> resp.body()) - .thenAccept(b -> assertEquals(b, EXPECTED_RESPONSE_BODY)) + .thenAccept(b -> assertEquals(EXPECTED_RESPONSE_BODY, b)) .join(); } - @DataProvider(name = "sanityBadRequest") - public Object[][] sanityBadRequest() { + public static Object[][] sanityBadRequest() { return new Object[][]{ { httpURIVarLen }, // no query string { httpsURIVarLen }, @@ -198,18 +219,18 @@ public abstract class ShortResponseBody { }; } - @Test(dataProvider = "sanityBadRequest") + @ParameterizedTest + @MethodSource("sanityBadRequest") void sanityBadRequest(String url) throws Exception { url = uniqueURL(url); HttpRequest request = HttpRequest.newBuilder(URI.create(url)).build(); out.println("Request: " + request); HttpResponse response = client.send(request, ofString()); - assertEquals(response.statusCode(), 400); - assertEquals(response.body(), ""); + assertEquals(400, response.statusCode()); + assertEquals("", response.body()); } - @DataProvider(name = "uris") - public Object[][] variants(ITestContext context) { + public static Object[][] variants() { String[][] cases = new String[][] { // The length query string is the total number of bytes in the reply, // including headers, before the server closes the connection. The @@ -268,13 +289,6 @@ public abstract class ShortResponseBody { { httpsURIClsImed, "no bytes"}, }; - if (context.getFailedTests().size() > 0) { - // Shorten the log output by preventing useless - // skip traces to be printed for subsequent methods - // if one of the previous @Test method has failed. - return new Object[0][]; - } - return cases; } @@ -618,7 +632,7 @@ public abstract class ShortResponseBody { String response( ) { return RESPONSE; } } - /** A server that issues a, possibly-partial, chunked reply over SSL. */ + /** A server that issues a possibly-partial, chunked reply over SSL. */ static final class SSLVariableLengthServer extends PlainVariableLengthServer { SSLVariableLengthServer() throws IOException { super("SSLVariableLengthServer"); @@ -655,8 +669,8 @@ public abstract class ShortResponseBody { + server.getPort(); } - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { SSLContext.setDefault(sslContext); sslParameters = new SSLParameters(); @@ -682,8 +696,8 @@ public abstract class ShortResponseBody { + "/http1/fixed/req=%reqnb%/baz"; } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { closeImmediatelyServer.close(); closeImmediatelyHttpsServer.close(); variableLengthServer.close(); diff --git a/test/jdk/java/net/httpclient/ShortResponseBodyGet.java b/test/jdk/java/net/httpclient/ShortResponseBodyGet.java index 0a9041020a5..47be508c8c1 100644 --- a/test/jdk/java/net/httpclient/ShortResponseBodyGet.java +++ b/test/jdk/java/net/httpclient/ShortResponseBodyGet.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 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 @@ -28,7 +28,7 @@ * received before a socket exception or eof. * @library /test/lib * @build jdk.test.lib.net.SimpleSSLContext ShortResponseBody ShortResponseBodyGet - * @run testng/othervm + * @run junit/othervm * -Djdk.httpclient.HttpClient.log=headers,errors,channel * ShortResponseBodyGet */ @@ -38,21 +38,24 @@ import java.net.URI; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.util.concurrent.ExecutionException; -import org.testng.annotations.Test; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + import static java.lang.System.out; import static java.net.http.HttpResponse.BodyHandlers.ofString; -import static org.testng.Assert.fail; +import static org.junit.jupiter.api.Assertions.fail; public class ShortResponseBodyGet extends ShortResponseBody { - @Test(dataProvider = "uris") + @ParameterizedTest + @MethodSource("variants") void testSynchronousGET(String urlp, String expectedMsg) throws Exception { - checkSkip(); String url = uniqueURL(urlp); HttpRequest request = HttpRequest.newBuilder(URI.create(url)).build(); - out.println("Request: " + request); + out.printf("%n%s-- testSynchronousGET Request: %s%n%n", now(), request); try { HttpResponse response = client.send(request, ofString()); String body = response.body(); @@ -67,14 +70,14 @@ public class ShortResponseBodyGet extends ShortResponseBody { } } - @Test(dataProvider = "uris") + @ParameterizedTest + @MethodSource("variants") void testAsynchronousGET(String urlp, String expectedMsg) throws Exception { - checkSkip(); String url = uniqueURL(urlp); HttpRequest request = HttpRequest.newBuilder(URI.create(url)).build(); - out.println("Request: " + request); + out.printf("%n%s-- testAsynchronousGET Request: %s%n%n", now(), request); try { HttpResponse response = client.sendAsync(request, ofString()).get(); String body = response.body(); diff --git a/test/jdk/java/net/httpclient/ShortResponseBodyPost.java b/test/jdk/java/net/httpclient/ShortResponseBodyPost.java index c72540c5990..60d2796b34f 100644 --- a/test/jdk/java/net/httpclient/ShortResponseBodyPost.java +++ b/test/jdk/java/net/httpclient/ShortResponseBodyPost.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 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 @@ -28,7 +28,7 @@ * received before a socket exception or eof. * @library /test/lib * @build jdk.test.lib.net.SimpleSSLContext ShortResponseBody ShortResponseBodyPost - * @run testng/othervm + * @run junit/othervm * -Djdk.httpclient.HttpClient.log=headers,errors,channel * -Djdk.internal.httpclient.debug=true * ShortResponseBodyPost @@ -42,10 +42,14 @@ import java.net.http.HttpResponse; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutionException; -import org.testng.annotations.Test; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + import static java.lang.System.out; import static java.net.http.HttpResponse.BodyHandlers.ofString; -import static org.testng.Assert.fail; +import static org.junit.jupiter.api.Assertions.fail; + public class ShortResponseBodyPost extends ShortResponseBody { // POST tests are racy in what may be received before writing may cause a @@ -56,16 +60,16 @@ public class ShortResponseBodyPost extends ShortResponseBody { List.of("no bytes", "status line", "header"); - @Test(dataProvider = "uris") + @ParameterizedTest + @MethodSource("variants") void testSynchronousPOST(String urlp, String expectedMsg) throws Exception { - checkSkip(); String url = uniqueURL(urlp); HttpRequest request = HttpRequest.newBuilder(URI.create(url)) .POST(BodyPublishers.ofInputStream(() -> new InfiniteInputStream())) .build(); - out.println("Request: " + request); + out.printf("%n%s-- testSynchronousPOST Request: %s%n%n", now(), request); try { HttpResponse response = client.send(request, ofString()); String body = response.body(); @@ -86,16 +90,16 @@ public class ShortResponseBodyPost extends ShortResponseBody { } } - @Test(dataProvider = "uris") + @ParameterizedTest + @MethodSource("variants") void testAsynchronousPOST(String urlp, String expectedMsg) throws Exception { - checkSkip(); String url = uniqueURL(urlp); HttpRequest request = HttpRequest.newBuilder(URI.create(url)) .POST(BodyPublishers.ofInputStream(() -> new InfiniteInputStream())) .build(); - out.println("Request: " + request); + out.printf("%n%s-- testAsynchronousPOST Request: %s%n%n", now(), request); try { HttpResponse response = client.sendAsync(request, ofString()).get(); String body = response.body(); diff --git a/test/jdk/java/net/httpclient/ShortResponseBodyPostWithRetry.java b/test/jdk/java/net/httpclient/ShortResponseBodyPostWithRetry.java index bd234690526..0ab404e556a 100644 --- a/test/jdk/java/net/httpclient/ShortResponseBodyPostWithRetry.java +++ b/test/jdk/java/net/httpclient/ShortResponseBodyPostWithRetry.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 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 @@ -27,7 +27,7 @@ * @library /test/lib * @build jdk.test.lib.net.SimpleSSLContext * @build ShortResponseBody ShortResponseBodyPost - * @run testng/othervm + * @run junit/othervm * -Djdk.httpclient.HttpClient.log=headers,errors,channel * -Djdk.httpclient.enableAllMethodRetry * -Djdk.internal.httpclient.debug=true diff --git a/test/jdk/java/net/httpclient/SpecialHeadersTest.java b/test/jdk/java/net/httpclient/SpecialHeadersTest.java index d33135dd4ce..d4d5f2a85e2 100644 --- a/test/jdk/java/net/httpclient/SpecialHeadersTest.java +++ b/test/jdk/java/net/httpclient/SpecialHeadersTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 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 @@ -31,35 +31,22 @@ * jdk.httpclient.test.lib.http2.Http2TestServer * jdk.test.lib.net.SimpleSSLContext * @requires (vm.compMode != "Xcomp") - * @run testng/othervm/timeout=480 + * @run junit/othervm/timeout=480 * -Djdk.httpclient.HttpClient.log=requests,headers,errors * SpecialHeadersTest - * @run testng/othervm/timeout=480 -Djdk.httpclient.allowRestrictedHeaders=Host + * @run junit/othervm/timeout=480 -Djdk.httpclient.allowRestrictedHeaders=Host * -Djdk.httpclient.HttpClient.log=requests,headers,errors * SpecialHeadersTest */ -import com.sun.net.httpserver.HttpServer; -import com.sun.net.httpserver.HttpsConfigurator; -import com.sun.net.httpserver.HttpsServer; import jdk.internal.net.http.common.OperationTrackers.Tracker; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.ITestContext; -import org.testng.ITestResult; -import org.testng.SkipException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterTest; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.net.ssl.SSLContext; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; -import java.net.InetSocketAddress; import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpHeaders; @@ -83,9 +70,7 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Function; -import java.util.stream.Collectors; import jdk.httpclient.test.lib.common.HttpServerAdapters; -import jdk.httpclient.test.lib.http2.Http2TestServer; import static java.lang.System.err; import static java.lang.System.out; @@ -93,22 +78,37 @@ import static java.net.http.HttpClient.Builder.NO_PROXY; import static java.net.http.HttpClient.Version.HTTP_1_1; import static java.net.http.HttpClient.Version.HTTP_2; import static java.net.http.HttpClient.Version.HTTP_3; +import static java.net.http.HttpOption.H3_DISCOVERY; +import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY; import static java.nio.charset.StandardCharsets.US_ASCII; -import org.testng.Assert; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Assertions; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.extension.TestWatcher; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class SpecialHeadersTest implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ] - HttpTestServer httpsTestServer; // HTTPS/1.1 - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - String httpURI; - String httpsURI; - String http2URI; - String https2URI; + private static HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ] + private static HttpTestServer httpsTestServer; // HTTPS/1.1 + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static HttpTestServer http3TestServer; // HTTP/3 + private static String httpURI; + private static String httpsURI; + private static String http2URI; + private static String https2URI; + private static String https3URI; static final String[][] headerNamesAndValues = new String[][]{ {"User-Agent: "}, @@ -132,8 +132,7 @@ public class SpecialHeadersTest implements HttpServerAdapters { {"hoSt: mixed"} }; - @DataProvider(name = "variants") - public Object[][] variants() { + public static Object[][] variants() { String prop = System.getProperty("jdk.httpclient.allowRestrictedHeaders"); boolean hostTest = prop != null && prop.equalsIgnoreCase("host"); final String[][] testInput = hostTest ? headerNamesAndValues1 : headerNamesAndValues; @@ -153,6 +152,9 @@ public class SpecialHeadersTest implements HttpServerAdapters { Arrays.asList(testInput).stream() .map(e -> new Object[] {https2URI, e[0], sameClient}) .forEach(list::add); + Arrays.asList(testInput).stream() + .map(e -> new Object[] {https3URI, e[0], sameClient}) + .forEach(list::add); } return list.stream().toArray(Object[][]::new); } @@ -173,8 +175,8 @@ public class SpecialHeadersTest implements HttpServerAdapters { return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan); } - final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; - private volatile HttpClient sharedClient; + private static final ReferenceTracker TRACKER = ReferenceTracker.INSTANCE; + private static volatile HttpClient sharedClient; static class TestExecutor implements Executor { final AtomicLong tasks = new AtomicLong(); @@ -209,38 +211,39 @@ public class SpecialHeadersTest implements HttpServerAdapters { } - protected boolean stopAfterFirstFailure() { + private static boolean stopAfterFirstFailure() { return Boolean.getBoolean("jdk.internal.httpclient.debug"); } - final AtomicReference skiptests = new AtomicReference<>(); - void checkSkip() { - var skip = skiptests.get(); - if (skip != null) throw skip; - } - static String name(ITestResult result) { - var params = result.getParameters(); - return result.getName() - + (params == null ? "()" : Arrays.toString(result.getParameters())); - } - - @BeforeMethod - void beforeMethod(ITestContext context) { - if (stopAfterFirstFailure() && context.getFailedTests().size() > 0) { - if (skiptests.get() == null) { - SkipException skip = new SkipException("some tests failed"); - skip.setStackTrace(new StackTraceElement[0]); - skiptests.compareAndSet(null, skip); + static final class TestStopper implements TestWatcher, BeforeEachCallback { + final AtomicReference failed = new AtomicReference<>(); + TestStopper() { } + @Override + public void testFailed(ExtensionContext context, Throwable cause) { + if (stopAfterFirstFailure()) { + String msg = "Aborting due to: " + cause; + failed.compareAndSet(null, msg); + FAILURES.putIfAbsent(context.getDisplayName(), cause); + System.out.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); + System.err.printf("%nTEST FAILED: %s%s%n\tAborting due to %s%n%n", + now(), context.getDisplayName(), cause); } } + + @Override + public void beforeEach(ExtensionContext context) { + String msg = failed.get(); + Assumptions.assumeTrue(msg == null, msg); + } } - @AfterClass - static final void printFailedTests(ITestContext context) { + @RegisterExtension + static final TestStopper stopper = new TestStopper(); + + @AfterAll + static void printFailedTests() { out.println("\n========================="); - var failed = context.getFailedTests().getAllResults().stream() - .collect(Collectors.toMap(r -> name(r), ITestResult::getThrowable)); - FAILURES.putAll(failed); try { out.printf("%n%sCreated %d servers and %d clients%n", now(), serverCount.get(), clientCount.get()); @@ -260,7 +263,7 @@ public class SpecialHeadersTest implements HttpServerAdapters { private HttpClient makeNewClient() { clientCount.incrementAndGet(); - return HttpClient.newBuilder() + return newClientBuilderForH3() .proxy(NO_PROXY) .executor(executor) .sslContext(sslContext) @@ -307,7 +310,8 @@ public class SpecialHeadersTest implements HttpServerAdapters { if (throwable instanceof Error e) throw e; } - @Test(dataProvider = "variants") + @ParameterizedTest + @MethodSource("variants") void test(String uriString, String headerNameAndValue, boolean sameClient) @@ -335,6 +339,10 @@ public class SpecialHeadersTest implements HttpServerAdapters { } HttpRequest.Builder requestBuilder = HttpRequest.newBuilder(uri); + if (uriString.contains("/http3")) { + requestBuilder.version(HTTP_3); + requestBuilder.setOption(H3_DISCOVERY, HTTP_3_URI_ONLY); + } if (!useDefault) { requestBuilder.header(name, value); } @@ -343,7 +351,7 @@ public class SpecialHeadersTest implements HttpServerAdapters { out.println("Got response: " + resp); out.println("Got body: " + resp.body()); - assertEquals(resp.statusCode(), 200, + assertEquals(200, resp.statusCode(), "Expected 200, got:" + resp.statusCode()); boolean isInitialRequest = i == 0; @@ -366,10 +374,10 @@ public class SpecialHeadersTest implements HttpServerAdapters { : resp.headers().firstValue("X-" + key).get(); out.println("Got X-" + key + ": " + resp.headers().allValues("X-" + key)); if (value != null) { - assertEquals(receivedHeaderString, value); - assertEquals(resp.headers().allValues("X-" + key), List.of(value)); + assertEquals(value, receivedHeaderString); + assertEquals(List.of(value), resp.headers().allValues("X-" + key)); } else { - assertEquals(resp.headers().allValues("X-" + key).size(), 0); + assertEquals(0, resp.headers().allValues("X-" + key).size()); } } } catch (Throwable x) { @@ -389,7 +397,8 @@ public class SpecialHeadersTest implements HttpServerAdapters { } } - @Test(dataProvider = "variants") + @ParameterizedTest + @MethodSource("variants") void testHomeMadeIllegalHeader(String uriString, String headerNameAndValue, boolean sameClient) @@ -443,7 +452,7 @@ public class SpecialHeadersTest implements HttpServerAdapters { try { HttpResponse response = client.send(req, BodyHandlers.ofString()); - Assert.fail("Unexpected reply: " + response); + Assertions.fail("Unexpected reply: " + response); } catch (IllegalArgumentException ee) { out.println("Got IAE as expected"); } @@ -465,7 +474,8 @@ public class SpecialHeadersTest implements HttpServerAdapters { - @Test(dataProvider = "variants") + @ParameterizedTest + @MethodSource("variants") void testAsync(String uriString, String headerNameAndValue, boolean sameClient) throws Exception { @@ -490,6 +500,10 @@ public class SpecialHeadersTest implements HttpServerAdapters { } HttpRequest.Builder requestBuilder = HttpRequest.newBuilder(uri); + if (uriString.contains("/http3")) { + requestBuilder.version(HTTP_3); + requestBuilder.setOption(H3_DISCOVERY, HTTP_3_URI_ONLY); + } if (!useDefault) { requestBuilder.header(name, value); } @@ -504,7 +518,7 @@ public class SpecialHeadersTest implements HttpServerAdapters { .thenApply(response -> { out.println("Got response: " + response); out.println("Got body: " + response.body()); - assertEquals(response.statusCode(), 200); + assertEquals(200, response.statusCode()); return response; }) .thenAccept(resp -> { @@ -522,10 +536,10 @@ public class SpecialHeadersTest implements HttpServerAdapters { : resp.headers().firstValue("X-" + key).orElse(null); out.println("Got X-" + key + ": " + resp.headers().allValues("X-" + key)); if (value != null) { - assertEquals(receivedHeaderString, value); - assertEquals(resp.headers().allValues("X-" + key), List.of(value)); + assertEquals(value, receivedHeaderString); + assertEquals(List.of(value), resp.headers().allValues("X-" + key)); } else { - assertEquals(resp.headers().allValues("X-" + key).size(), 1); + assertEquals(1, resp.headers().allValues("X-" + key).size()); } } }) @@ -552,8 +566,8 @@ public class SpecialHeadersTest implements HttpServerAdapters { + server.getAddress().getPort(); } - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { out.println("--- Starting setup " + now()); HttpTestHandler handler = new HttpUriStringHandler(); @@ -573,14 +587,19 @@ public class SpecialHeadersTest implements HttpServerAdapters { https2TestServer.addHandler(handler, "/https2"); https2URI = "https://" + https2TestServer.serverAuthority() + "/https2"; + http3TestServer = HttpTestServer.create(HTTP_3_URI_ONLY, sslContext); + http3TestServer.addHandler(handler, "/http3"); + https3URI = "https://" + http3TestServer.serverAuthority() + "/http3"; + httpTestServer.start(); httpsTestServer.start(); http2TestServer.start(); https2TestServer.start(); + http3TestServer.start(); } - @AfterTest - public void teardown() throws Exception { + @AfterAll + public static void teardown() throws Exception { out.println("\n--- Teardown " + now()); HttpClient shared = sharedClient; String sharedClientName = @@ -595,6 +614,7 @@ public class SpecialHeadersTest implements HttpServerAdapters { httpsTestServer.stop(); http2TestServer.stop(); https2TestServer.stop(); + http3TestServer.start(); executor.shutdown(); } finally { if (fail != null) { diff --git a/test/jdk/java/net/httpclient/StreamingBody.java b/test/jdk/java/net/httpclient/StreamingBody.java index 3fb4f29208e..d0577596038 100644 --- a/test/jdk/java/net/httpclient/StreamingBody.java +++ b/test/jdk/java/net/httpclient/StreamingBody.java @@ -72,20 +72,19 @@ import org.junit.jupiter.api.extension.TestWatcher; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; -@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class StreamingBody implements HttpServerAdapters { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ] - HttpTestServer httpsTestServer; // HTTPS/1.1 - HttpTestServer http2TestServer; // HTTP/2 ( h2c ) - HttpTestServer https2TestServer; // HTTP/2 ( h2 ) - HttpTestServer http3TestServer; // HTTP/3 ( h3 ) - String httpURI; - String httpsURI; - String http2URI; - String https2URI; - String http3URI; + private static HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ] + private static HttpTestServer httpsTestServer; // HTTPS/1.1 + private static HttpTestServer http2TestServer; // HTTP/2 ( h2c ) + private static HttpTestServer https2TestServer; // HTTP/2 ( h2 ) + private static HttpTestServer http3TestServer; // HTTP/3 ( h3 ) + private static String httpURI; + private static String httpsURI; + private static String http2URI; + private static String https2URI; + private static String http3URI; static final AtomicLong clientCount = new AtomicLong(); static final AtomicLong serverCount = new AtomicLong(); @@ -186,7 +185,7 @@ public class StreamingBody implements HttpServerAdapters { static final String MESSAGE = "StreamingBody message body"; static final int ITERATIONS = 100; - public Object[][] positive() { + public static Object[][] positive() { return new Object[][] { { http3URI, }, { httpURI, }, @@ -253,7 +252,7 @@ public class StreamingBody implements HttpServerAdapters { // -- Infrastructure @BeforeAll - public void setup() throws Exception { + public static void setup() throws Exception { httpTestServer = HttpTestServer.create(HTTP_1_1); httpTestServer.addHandler(new MessageHandler(), "/http1/streamingbody/"); httpURI = "http://" + httpTestServer.serverAuthority() + "/http1/streamingbody/w"; @@ -290,7 +289,7 @@ public class StreamingBody implements HttpServerAdapters { } @AfterAll - public void teardown() throws Exception { + public static void teardown() throws Exception { try { httpTestServer.stop(); httpsTestServer.stop(); @@ -303,7 +302,7 @@ public class StreamingBody implements HttpServerAdapters { } } - static final void printFailedTests() { + static void printFailedTests() { out.println("\n========================="); try { out.printf("%n%sCreated %s servers and %s clients%n", From feecb042fe4abbb9bb3aa9324de4e40393e03ae1 Mon Sep 17 00:00:00 2001 From: Daishi Tabata Date: Fri, 20 Feb 2026 17:59:54 +0000 Subject: [PATCH 30/63] 8378218: MSYS2 reports cygwin triplet causing bash configure failure Reviewed-by: erikj --- make/autoconf/platform.m4 | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/make/autoconf/platform.m4 b/make/autoconf/platform.m4 index 1b247e159ac..90d5d795626 100644 --- a/make/autoconf/platform.m4 +++ b/make/autoconf/platform.m4 @@ -1,5 +1,5 @@ # -# Copyright (c) 2011, 2025, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2011, 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 @@ -311,6 +311,12 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD], else OPENJDK_BUILD_OS_ENV="$VAR_OS" fi + # Special handling for MSYS2 that reports a Cygwin triplet as the default host triplet. + case `uname` in + MSYS*) + OPENJDK_BUILD_OS_ENV=windows.msys2 + ;; + esac OPENJDK_BUILD_CPU="$VAR_CPU" OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH" OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS" From 2ebd612634bfc7314a489a8de8f951127b03b26d Mon Sep 17 00:00:00 2001 From: Daniel Fuchs Date: Fri, 20 Feb 2026 20:21:00 +0000 Subject: [PATCH 31/63] 8378276: Refactor test/jdk/java/net/httpclient/quic/ TestNG tests to JUnit Reviewed-by: vyazici --- .../net/httpclient/quic/AckElicitingTest.java | 73 ++-- .../net/httpclient/quic/AckFrameTest.java | 119 ++----- .../httpclient/quic/BuffersReaderVLTest.java | 166 +++++----- .../httpclient/quic/ConnectionIDSTest.java | 41 +-- .../quic/CryptoWriterQueueTest.java | 12 +- .../net/httpclient/quic/KeyUpdateTest.java | 32 +- .../net/httpclient/quic/OrderedFlowTest.java | 62 ++-- .../java/net/httpclient/quic/PacerTest.java | 19 +- .../httpclient/quic/PacketEncodingTest.java | 311 +++++++++--------- .../httpclient/quic/PacketNumbersTest.java | 35 +- .../quic/PacketSpaceManagerTest.java | 74 +++-- .../quic/QuicFramesDecoderTest.java | 32 +- .../quic/QuicRequestResponseTest.java | 23 +- .../httpclient/quic/VariableLengthTest.java | 149 +++++---- .../quic/VersionNegotiationTest.java | 28 +- .../quic/tls/PacketEncryptionTest.java | 118 +++---- .../quic/tls/Quicv2PacketEncryptionTest.java | 108 +++--- 17 files changed, 678 insertions(+), 724 deletions(-) diff --git a/test/jdk/java/net/httpclient/quic/AckElicitingTest.java b/test/jdk/java/net/httpclient/quic/AckElicitingTest.java index 47fdb935598..7fbc00f9148 100644 --- a/test/jdk/java/net/httpclient/quic/AckElicitingTest.java +++ b/test/jdk/java/net/httpclient/quic/AckElicitingTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -71,8 +71,6 @@ import jdk.internal.net.quic.QuicTLSEngine; import jdk.internal.net.quic.QuicTransportException; import jdk.internal.net.quic.QuicTransportParametersConsumer; import jdk.test.lib.RandomFactory; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.crypto.AEADBadTagException; import javax.net.ssl.SSLParameters; @@ -80,16 +78,19 @@ import javax.net.ssl.SSLSession; import static jdk.internal.net.http.quic.frames.QuicFrame.*; import static jdk.internal.net.http.quic.frames.ConnectionCloseFrame.CONNECTION_CLOSE_VARIANT; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertNull; -/** +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +/* * @test * @summary tests the logic to decide whether a packet or * a frame is ACK-eliciting. * @library /test/lib - * @run testng AckElicitingTest - * @run testng/othervm -Dseed=-7997973196290088038 AckElicitingTest + * @run junit AckElicitingTest + * @run junit/othervm -Dseed=-7997973196290088038 AckElicitingTest */ public class AckElicitingTest { @@ -307,7 +308,7 @@ public class AckElicitingTest { * {@code obj.ackEliciting()} * @param A concrete subclass of {@link QuicFrame} or {@link QuicPacket} */ - static record TestCase(Class type, + record TestCase(Class type, Function describer, Predicate ackEliciting, T obj, @@ -336,7 +337,7 @@ public class AckElicitingTest { */ public static TestCase of(Class type, T frame, boolean expected) { - return new TestCase(type, TestCase::describeFrame, + return new TestCase<>(type, TestCase::describeFrame, QuicFrame::isAckEliciting, frame, expected); } @@ -349,7 +350,7 @@ public class AckElicitingTest { * @return a new instance of {@code TestCase} */ public static TestCase of(T frame, boolean expected) { - return new TestCase((Class)frame.getClass(), + return new TestCase<>((Class)frame.getClass(), TestCase::describeFrame, QuicFrame::isAckEliciting, frame, expected); @@ -391,7 +392,7 @@ public class AckElicitingTest { * @param a concrete subclass of {@code QuicFrame} * @return a new instance of the given concrete class. */ - T newFrame(Class frameClass) { + static T newFrame(Class frameClass) { var frameType = QuicFrame.frameTypeOf(frameClass); if (frameType == CONNECTION_CLOSE) { if (RANDOM.nextBoolean()) { @@ -454,7 +455,7 @@ public class AckElicitingTest { * @return a list of {@code TestCase} to test all possible concrete * subclasses of {@code QuicFrame} */ - public List> createFramesTests() { + static List> createFramesTests() { List> frames = new ArrayList<>(); frames.add(of(newFrame(AckFrame.class), false)); frames.add(of(newFrame(ConnectionCloseFrame.class), false)); @@ -476,7 +477,7 @@ public class AckElicitingTest { * @param frames a list of frames * @return a new instance of {@code QuicPacket} */ - QuicPacket createPacket(List frames) { + static QuicPacket createPacket(List frames) { PacketType[] values = PacketType.values(); int index = PacketType.NONE.ordinal(); while (index == PacketType.NONE.ordinal()) { @@ -506,9 +507,9 @@ public class AckElicitingTest { * pseudo random list of concrete {@link QuicFrame} instances. * @param ackEliciting whether the returned packet should be * ack eliciting. - * @return + * @return a new QuicPacket */ - QuicPacket createPacket(boolean ackEliciting) { + static QuicPacket createPacket(boolean ackEliciting) { List frames = new ArrayList<>(); int mincount = ackEliciting ? 1 : 0; int ackCount = RANDOM.nextInt(mincount, 5); @@ -542,7 +543,7 @@ public class AckElicitingTest { return createPacket(mergeConsecutivePaddingFrames(frames)); } - private List mergeConsecutivePaddingFrames(List frames) { + private static List mergeConsecutivePaddingFrames(List frames) { var iterator = frames.listIterator(); QuicFrame previous = null; @@ -567,7 +568,7 @@ public class AckElicitingTest { * @return a list of {@code TestCase} to test random instances of * {@code QuicPacket} containing random instances of {@link QuicFrame} */ - public List> createPacketsTests() { + static List> createPacketsTests() { List> packets = new ArrayList<>(); packets.add(of(createPacket(List.of(newFrame(AckFrame.class))), false)); packets.add(of(createPacket(List.of(newFrame(ConnectionCloseFrame.class))), false)); @@ -593,8 +594,7 @@ public class AckElicitingTest { * @return test case to test * {@link QuicFrame#isAckEliciting()} */ - @DataProvider(name = "frames") - public Object[][] framesDataProvider() { + public static Object[][] framesDataProvider() { return createFramesTests().stream() .map(List::of) .map(List::toArray) @@ -607,8 +607,7 @@ public class AckElicitingTest { * @return test case to test * {@link QuicPacket#isAckEliciting()} */ - @DataProvider(name = "packets") - public Object[][] packetsDataProvider() { + public static Object[][] packetsDataProvider() { return createPacketsTests().stream() .map(List::of) .map(List::toArray) @@ -621,8 +620,9 @@ public class AckElicitingTest { * @param test the test inputs * @param a concrete subclass of QuicFrame */ - @Test(dataProvider = "frames") - public void testFrames(TestCase test) { + @ParameterizedTest + @MethodSource("framesDataProvider") + void testFrames(TestCase test) { testAckEliciting(test.type(), test.describer(), test.ackEliciting(), @@ -636,8 +636,9 @@ public class AckElicitingTest { * @param test the test inputs * @param a concrete subclass of QuickPacket */ - @Test(dataProvider = "packets") - public void testPackets(TestCase test) { + @ParameterizedTest + @MethodSource("packetsDataProvider") + void testPackets(TestCase test) { testAckEliciting(test.type(), test.describer(), test.ackEliciting(), @@ -664,7 +665,7 @@ public class AckElicitingTest { type.getSimpleName(), describer.apply(obj), expected); - assertEquals(ackEliciting.test(obj), expected, describer.apply(obj)); + assertEquals(expected, ackEliciting.test(obj), describer.apply(obj)); if (obj instanceof QuicFrame frame) { checkFrame(frame); } else if (obj instanceof QuicPacket packet) { @@ -695,10 +696,10 @@ public class AckElicitingTest { System.out.printf("Comparing frames: %s with %s%n", decoded.getClass().getSimpleName(), expected.getClass().getSimpleName()); - assertEquals(decoded.getClass(), expected.getClass()); - assertEquals(decoded.size(), expected.size()); - assertEquals(decoded.getTypeField(), expected.getTypeField()); - assertEquals(decoded.isAckEliciting(), expected.isAckEliciting()); + assertEquals(expected.getClass(), decoded.getClass()); + assertEquals(expected.size(), decoded.size()); + assertEquals(expected.getTypeField(), decoded.getTypeField()); + assertEquals(expected.isAckEliciting(), decoded.isAckEliciting()); } // This is not a full-fledged test for packet encoding/decoding. @@ -714,13 +715,13 @@ public class AckElicitingTest { encoder.encode(packet, buffer, CONTEXT); buffer.flip(); var decoded = decoder.decode(buffer, CONTEXT); - assertEquals(decoded.size(), packet.size()); - assertEquals(decoded.packetType(), packet.packetType()); - assertEquals(decoded.payloadSize(), packet.payloadSize()); - assertEquals(decoded.isAckEliciting(), packet.isAckEliciting()); + assertEquals(packet.size(), decoded.size()); + assertEquals(packet.packetType(), decoded.packetType()); + assertEquals(packet.payloadSize(), decoded.payloadSize()); + assertEquals(packet.isAckEliciting(), decoded.isAckEliciting()); var frames = packet.frames(); var decodedFrames = decoded.frames(); - assertEquals(decodedFrames.size(), frames.size()); + assertEquals(frames.size(), decodedFrames.size()); } catch (Exception x) { throw new AssertionError(packet.getClass().getName(), x); } diff --git a/test/jdk/java/net/httpclient/quic/AckFrameTest.java b/test/jdk/java/net/httpclient/quic/AckFrameTest.java index 129394f126c..3c8c027e73b 100644 --- a/test/jdk/java/net/httpclient/quic/AckFrameTest.java +++ b/test/jdk/java/net/httpclient/quic/AckFrameTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -21,20 +21,12 @@ * questions. */ -import jdk.internal.net.http.quic.CodingContext; import jdk.internal.net.http.quic.frames.AckFrame; import jdk.internal.net.http.quic.frames.AckFrame.AckFrameBuilder; import jdk.internal.net.http.quic.frames.AckFrame.AckRange; import jdk.internal.net.http.quic.frames.QuicFrame; -import jdk.internal.net.http.quic.packets.QuicPacket; -import jdk.internal.net.http.quic.packets.QuicPacket.PacketNumberSpace; -import jdk.internal.net.http.quic.QuicConnectionId; -import jdk.internal.net.quic.QuicTLSEngine; import jdk.test.lib.RandomFactory; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import java.io.IOException; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Collections; @@ -43,66 +35,24 @@ import java.util.Random; import java.util.function.LongPredicate; import java.util.stream.LongStream; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; -import static org.testng.Assert.assertFalse; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -/** +/* * @test * @summary tests the logic to build an AckFrame * @library /test/lib - * @run testng AckFrameTest + * @run junit AckFrameTest */ public class AckFrameTest { static final Random RANDOM = RandomFactory.getRandom(); - private static abstract class TestCodingContext implements CodingContext { - TestCodingContext() { } - @Override - public int writePacket(QuicPacket packet, ByteBuffer buffer) { - throw new AssertionError("should not come here!"); - } - @Override - public QuicPacket parsePacket(ByteBuffer src) throws IOException { - throw new AssertionError("should not come here!"); - } - @Override - public boolean verifyToken(QuicConnectionId destinationID, byte[] token) { - return true; - } - @Override - public QuicTLSEngine getTLSEngine() { - throw new AssertionError("should not come here!"); - } - } - - static final int CIDLEN = RANDOM.nextInt(5, QuicConnectionId.MAX_CONNECTION_ID_LENGTH + 1); - - private static final TestCodingContext CONTEXT = new TestCodingContext() { - - @Override - public long largestProcessedPN(PacketNumberSpace packetSpace) { - return 0; - } - - @Override - public long largestAckedPN(PacketNumberSpace packetSpace) { - return 0; - } - - @Override - public int connectionIdLength() { - return CIDLEN; - } - - @Override - public QuicConnectionId originalServerConnId() { - return null; - } - }; - - public static record Acknowledged(long first, long last) { + public record Acknowledged(long first, long last) { public boolean contains(long packet) { return first <= packet && last >= packet; } @@ -116,7 +66,7 @@ public class AckFrameTest { return List.copyOf(res); } } - public static record Packet(long packetNumber) { + public record Packet(long packetNumber) { static List ofAcks(List acks) { return packets(acks); } @@ -125,7 +75,7 @@ public class AckFrameTest { } } - public static record TestCase(List acks, List packets, boolean shuffled) { + public record TestCase(List acks, List packets, boolean shuffled) { public TestCase(List acks) { this(acks, Packet.ofAcks(acks), false); } @@ -137,7 +87,7 @@ public class AckFrameTest { } } - List generateTests() { + static List generateTests() { List tests = new ArrayList<>(); List simples = List.of( new TestCase(List.of(new Acknowledged(5,5))), @@ -177,7 +127,7 @@ public class AckFrameTest { return tests; } - List generateAcks() { + static List generateAcks() { int count = RANDOM.nextInt(3, 10); List acks = new ArrayList<>(count); long prev = -1; @@ -202,22 +152,19 @@ public class AckFrameTest { return res; } - @DataProvider(name = "tests") - public Object[][] tests() { + public static Object[][] tests() { return generateTests().stream() .map(List::of) .map(List::toArray) .toArray(Object[][]::new); } - @Test(dataProvider = "tests") + @ParameterizedTest + @MethodSource("tests") public void testAckFrames(TestCase testCase) { AckFrameBuilder builder = new AckFrameBuilder(); List acks = testCase.acks; List packets = testCase.packets; - long largest = packets.stream() - .mapToLong(Packet::packetNumber) - .max().getAsLong(); System.out.printf("%ntestAckFrames(%s, %s)%n", acks, testCase.shuffled); builder.ackDelay(250); packets.stream().mapToLong(Packet::packetNumber).forEach(builder::addAck); @@ -227,8 +174,8 @@ public class AckFrameTest { checkAcknowledging(builder::isAcknowledging, testCase, packets); AckFrameBuilder dup = new AckFrameBuilder(frame); - assertEquals(frame, dup.build()); - assertEquals(frame, builder.build()); + assertEquals(dup.build(), frame); + assertEquals(builder.build(), frame); checkAcknowledging(dup::isAcknowledging, testCase, packets); packets.stream().mapToLong(Packet::packetNumber).forEach(builder::addAck); @@ -255,25 +202,25 @@ public class AckFrameTest { long largest = testCase.packets.stream() .mapToLong(Packet::packetNumber) .max().getAsLong(); - assertEquals(frame.largestAcknowledged(), largest); + assertEquals(largest, frame.largestAcknowledged()); checkAcknowledging(frame::isAcknowledging, testCase, packets); for (var ack : testCase.acks) { checkRangeAcknowledged(frame, ack.first, ack.last); } - assertEquals(frame, reference); + assertEquals(reference, frame); int size = frame.size(); ByteBuffer buffer = ByteBuffer.allocate(size + 10); buffer.position(5); buffer.limit(size + 5); try { frame.encode(buffer); - assertEquals(buffer.position(), buffer.limit()); + assertEquals(buffer.limit(), buffer.position()); buffer.position(5); buffer.limit(buffer.capacity()); var decoded = QuicFrame.decode(buffer); - assertEquals(buffer.position(), size + 5); - assertEquals(decoded, frame); - assertEquals(decoded, reference); + assertEquals(size + 5, buffer.position()); + assertEquals(frame, decoded); + assertEquals(reference, decoded); } catch (Exception e) { throw new AssertionError("Can't encode or decode frame: " + frame, e); } @@ -327,14 +274,14 @@ public class AckFrameTest { if (isAcknowledging != expected && testCase.shuffled) { System.out.printf(" -> %s%n", packets); } - assertEquals(isAcknowledging, expected, String.valueOf(pn)); + assertEquals(expected, isAcknowledging, String.valueOf(pn)); } for (var p : testCase.packets) { boolean isAcknowledging = isAckPredicate.test(p.packetNumber); if (!isAcknowledging && testCase.shuffled) { System.out.printf(" -> %s%n", packets); } - assertEquals(isAcknowledging, true, p.toString()); + assertEquals(true, isAcknowledging, p.toString()); } } @@ -345,9 +292,9 @@ public class AckFrameTest { assertTrue(frame.isAcknowledging(1), "1 should be acked"); assertFalse(frame.isAcknowledging(0), "0 should not be acked"); assertFalse(frame.isAcknowledging(2), "2 should not be acked"); - assertEquals(frame.smallestAcknowledged(), 1); - assertEquals(frame.largestAcknowledged(), 1); - assertEquals(frame.acknowledged().toArray(), new long[] {1L}); + assertEquals(1, frame.smallestAcknowledged()); + assertEquals(1, frame.largestAcknowledged()); + assertEquals(List.of(1L), frame.acknowledged().boxed().toList()); assertTrue(frame.isRangeAcknowledged(1,1), "[1,1] should be acked"); assertFalse(frame.isRangeAcknowledged(0, 1), "[0,1] should not be acked"); assertFalse(frame.isRangeAcknowledged(1, 2), "[1,2] should not be acked"); @@ -358,9 +305,9 @@ public class AckFrameTest { assertTrue(frame.isAcknowledging(1), "1 should be acked"); assertTrue(frame.isAcknowledging(0), "0 should be acked"); assertFalse(frame.isAcknowledging(2), "2 should not be acked"); - assertEquals(frame.smallestAcknowledged(), 0); - assertEquals(frame.largestAcknowledged(), 1); - assertEquals(frame.acknowledged().toArray(), new long[] {1L, 0L}); + assertEquals(0, frame.smallestAcknowledged()); + assertEquals(1, frame.largestAcknowledged()); + assertEquals(List.of(1L, 0L), frame.acknowledged().boxed().toList()); assertTrue(frame.isRangeAcknowledged(0,0), "[0,0] should be acked"); assertTrue(frame.isRangeAcknowledged(1,1), "[1,1] should be acked"); assertTrue(frame.isRangeAcknowledged(0, 1), "[0,1] should be acked"); diff --git a/test/jdk/java/net/httpclient/quic/BuffersReaderVLTest.java b/test/jdk/java/net/httpclient/quic/BuffersReaderVLTest.java index 5064bbd5cb3..100a6112de5 100644 --- a/test/jdk/java/net/httpclient/quic/BuffersReaderVLTest.java +++ b/test/jdk/java/net/httpclient/quic/BuffersReaderVLTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -27,29 +27,26 @@ import java.util.List; import jdk.internal.net.http.quic.BuffersReader; import jdk.internal.net.http.quic.BuffersReader.ListBuffersReader; import jdk.internal.net.http.quic.VariableLengthEncoder; -import jtreg.SkippedException; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertThrows; -import static org.testng.Assert.assertTrue; -import static org.testng.Assert.expectThrows; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; /* * @test * @library /test/lib * @modules java.net.http/jdk.internal.net.http.quic - * @run testng/othervm BuffersReaderVLTest + * @run junit/othervm BuffersReaderVLTest * @summary Tests to check quic/util methods encode/decodeVariableLength methods * work as expected. */ public class BuffersReaderVLTest { static final Class IAE = IllegalArgumentException.class; - @DataProvider(name = "decode invariants") - public Object[][] decodeInvariants() { + public static Object[][] decodeInvariants() { return new Object[][] { { new byte[]{7}, 7, 1 }, // 00 @@ -61,8 +58,7 @@ public class BuffersReaderVLTest { { new byte[]{-65}, -1, 0 }, }; } - @DataProvider(name = "prefix invariants") - public Object[][] prefixInvariants() { + public static Object[][] prefixInvariants() { return new Object[][] { { Long.MAX_VALUE, 0, IAE }, @@ -101,44 +97,47 @@ public class BuffersReaderVLTest { }; } - @Test(dataProvider = "decode invariants") + @ParameterizedTest + @MethodSource("decodeInvariants") public void testDecode(byte[] values, long expectedLength, int expectedPosition) { ByteBuffer bb = ByteBuffer.wrap(values); BuffersReader br = BuffersReader.list(bb); var actualLength = VariableLengthEncoder.decode(br); - assertEquals(actualLength, expectedLength); + assertEquals(expectedLength, actualLength); var actualPosition = bb.position(); - assertEquals(actualPosition, expectedPosition); - assertEquals(br.position(), expectedPosition); + assertEquals(expectedPosition, actualPosition); + assertEquals(expectedPosition, br.position()); br.release(); - assertEquals(br.read(), expectedPosition); + assertEquals(expectedPosition, br.read()); } - @Test(dataProvider = "decode invariants") + @ParameterizedTest + @MethodSource("decodeInvariants") public void testPeek(byte[] values, long expectedLength, int expectedPosition) { ByteBuffer bb = ByteBuffer.wrap(values); BuffersReader br = BuffersReader.list(bb); var actualLength = VariableLengthEncoder.peekEncodedValue(br, 0); - assertEquals(actualLength, expectedLength); + assertEquals(expectedLength, actualLength); var actualPosition = bb.position(); - assertEquals(actualPosition, 0); - assertEquals(br.position(), 0); + assertEquals(0, actualPosition); + assertEquals(0, br.position()); br.release(); - assertEquals(br.read(), 0); + assertEquals(0, br.read()); } // Encode the given length and then decodes it and compares // the results, asserting various invariants along the way. - @Test(dataProvider = "prefix invariants") + @ParameterizedTest + @MethodSource("prefixInvariants") public void testEncodeDecode(long length, int expectedPrefix, Class exception) { if (exception != null) { assertThrows(exception, () -> VariableLengthEncoder.getEncodedSize(length)); assertThrows(exception, () -> VariableLengthEncoder.encode(ByteBuffer.allocate(16), length)); } else { var actualSize = VariableLengthEncoder.getEncodedSize(length); - assertEquals(actualSize, 1 << expectedPrefix); + assertEquals(1 << expectedPrefix, actualSize); assertTrue(actualSize > 0, "length is negative or zero: " + actualSize); assertTrue(actualSize < 9, "length is too big: " + actualSize); @@ -158,33 +157,33 @@ public class BuffersReaderVLTest { longer.position(offset); // attempt to encode with a buffer too short - expectThrows(IAE, () -> VariableLengthEncoder.encode(shorter, length)); - assertEquals(shorter.position(), offset); - assertEquals(shorter.limit(), shorter.capacity()); + assertThrows(IAE, () -> VariableLengthEncoder.encode(shorter, length)); + assertEquals(offset, shorter.position()); + assertEquals(shorter.capacity(), shorter.limit()); - assertEquals(shorter.mismatch(shorterref), -1); - assertEquals(shorterref.mismatch(shorter), -1); + assertEquals(-1, shorter.mismatch(shorterref)); + assertEquals(-1, shorterref.mismatch(shorter)); // attempt to encode with a buffer that has the exact size var exactres = VariableLengthEncoder.encode(exact, length); - assertEquals(exactres, actualSize); - assertEquals(exact.position(), actualSize + offset); + assertEquals(actualSize, exactres); + assertEquals(actualSize + offset, exact.position()); assertFalse(exact.hasRemaining()); // attempt to encode with a buffer that has more bytes var longres = VariableLengthEncoder.encode(longer, length); - assertEquals(longres, actualSize); - assertEquals(longer.position(), offset + actualSize); - assertEquals(longer.limit(), longer.capacity()); - assertEquals(longer.remaining(), 10); + assertEquals(actualSize, longres); + assertEquals(offset + actualSize, longer.position()); + assertEquals(longer.capacity(), longer.limit()); + assertEquals(10, longer.remaining()); // compare encodings // first reset buffer positions for reading. exact.position(offset); longer.position(offset); - assertEquals(longer.mismatch(exact), actualSize); - assertEquals(exact.mismatch(longer), actualSize); + assertEquals(actualSize, longer.mismatch(exact)); + assertEquals(actualSize, exact.mismatch(longer)); // decode with a buffer that is missing the last // byte... @@ -193,23 +192,23 @@ public class BuffersReaderVLTest { shortSlice.limit(offset + actualSize -1); ListBuffersReader br = BuffersReader.list(shortSlice); var actualLength = VariableLengthEncoder.decode(br); - assertEquals(actualLength, -1L); - assertEquals(shortSlice.position(), offset); - assertEquals(shortSlice.limit(), offset + actualSize - 1); - assertEquals(br.position(), offset); - assertEquals(br.limit(), offset + actualSize - 1); + assertEquals(-1L, actualLength); + assertEquals(offset, shortSlice.position()); + assertEquals(offset + actualSize - 1, shortSlice.limit()); + assertEquals(offset, br.position()); + assertEquals(offset + actualSize - 1, br.limit()); br.release(); // decode with the exact buffer br = BuffersReader.list(exact); actualLength = VariableLengthEncoder.decode(br); - assertEquals(actualLength, length); - assertEquals(exact.position(), offset + actualSize); + assertEquals(length, actualLength); + assertEquals(offset + actualSize, exact.position()); assertFalse(exact.hasRemaining()); - assertEquals(br.position(), offset + actualSize); + assertEquals(offset + actualSize, br.position()); assertFalse(br.hasRemaining()); br.release(); - assertEquals(br.read(), actualSize); + assertEquals(actualSize, br.read()); assertFalse(br.hasRemaining()); @@ -217,14 +216,14 @@ public class BuffersReaderVLTest { long read = br.read(); br.add(longer); actualLength = VariableLengthEncoder.decode(br); - assertEquals(actualLength, length); - assertEquals(longer.position(), offset + actualSize); - assertEquals(longer.remaining(), 10); - assertEquals(br.position(), offset + actualSize); - assertEquals(br.remaining(), 10); + assertEquals(length, actualLength); + assertEquals(offset + actualSize, longer.position()); + assertEquals(10, longer.remaining()); + assertEquals(offset + actualSize, br.position()); + assertEquals(10, br.remaining()); br.release(); - assertEquals(br.read() - read, actualSize); - assertEquals(br.remaining(), 10); + assertEquals(actualSize, br.read() - read); + assertEquals(10, br.remaining()); } } @@ -232,7 +231,8 @@ public class BuffersReaderVLTest { // Encode the given length and then peeks it and compares // the results, asserting various invariants along the way. - @Test(dataProvider = "prefix invariants") + @ParameterizedTest + @MethodSource("prefixInvariants") public void testEncodePeek(long length, int expectedPrefix, Class exception) { if (exception != null) { assertThrows(exception, () -> VariableLengthEncoder.getEncodedSize(length)); @@ -241,7 +241,7 @@ public class BuffersReaderVLTest { } var actualSize = VariableLengthEncoder.getEncodedSize(length); - assertEquals(actualSize, 1 << expectedPrefix); + assertEquals(1 << expectedPrefix, actualSize); assertTrue(actualSize > 0, "length is negative or zero: " + actualSize); assertTrue(actualSize < 9, "length is too big: " + actualSize); @@ -258,24 +258,24 @@ public class BuffersReaderVLTest { // attempt to encode with a buffer that has the exact size var exactres = VariableLengthEncoder.encode(exact, length); - assertEquals(exactres, actualSize); - assertEquals(exact.position(), actualSize + offset); + assertEquals(actualSize, exactres); + assertEquals(actualSize + offset, exact.position()); assertFalse(exact.hasRemaining()); // attempt to encode with a buffer that has more bytes var longres = VariableLengthEncoder.encode(longer, length); - assertEquals(longres, actualSize); - assertEquals(longer.position(), offset + actualSize); - assertEquals(longer.limit(), longer.capacity()); - assertEquals(longer.remaining(), 10); + assertEquals(actualSize, longres); + assertEquals(offset + actualSize, longer.position()); + assertEquals(longer.capacity(), longer.limit()); + assertEquals(10, longer.remaining()); // compare encodings // first reset buffer positions for reading. exact.position(offset); longer.position(offset); - assertEquals(longer.mismatch(exact), actualSize); - assertEquals(exact.mismatch(longer), actualSize); + assertEquals(actualSize, longer.mismatch(exact)); + assertEquals(actualSize, exact.mismatch(longer)); exact.position(0); longer.position(0); exact.limit(exact.capacity()); @@ -288,38 +288,26 @@ public class BuffersReaderVLTest { shortSlice.limit(offset + actualSize - 1); // need at least one byte to decode the size len... var expectedSize = shortSlice.limit() <= offset ? -1 : actualSize; - assertEquals(VariableLengthEncoder.peekEncodedValueSize(shortSlice, offset), expectedSize); + assertEquals(expectedSize, VariableLengthEncoder.peekEncodedValueSize(shortSlice, offset)); var actualLength = VariableLengthEncoder.peekEncodedValue(shortSlice, offset); - assertEquals(actualLength, -1L); - assertEquals(shortSlice.position(), 0); - assertEquals(shortSlice.limit(), offset + actualSize - 1); + assertEquals(-1L, actualLength); + assertEquals(0, shortSlice.position()); + assertEquals(offset + actualSize - 1, shortSlice.limit()); // decode with the exact buffer - assertEquals(VariableLengthEncoder.peekEncodedValueSize(exact, offset), actualSize); + assertEquals(actualSize, VariableLengthEncoder.peekEncodedValueSize(exact, offset)); actualLength = VariableLengthEncoder.peekEncodedValue(exact, offset); - assertEquals(actualLength, length); - assertEquals(exact.position(), 0); - assertEquals(exact.limit(), exact.capacity()); + assertEquals(length, actualLength); + assertEquals(0, exact.position()); + assertEquals(exact.capacity(), exact.limit()); // decode with the longer buffer - assertEquals(VariableLengthEncoder.peekEncodedValueSize(longer, offset), actualSize); + assertEquals(actualSize, VariableLengthEncoder.peekEncodedValueSize(longer, offset)); actualLength = VariableLengthEncoder.peekEncodedValue(longer, offset); - assertEquals(actualLength, length); - assertEquals(longer.position(), 0); - assertEquals(longer.limit(), longer.capacity()); + assertEquals(length, actualLength); + assertEquals(0, longer.position()); + assertEquals(longer.capacity(), longer.limit()); } } - - - private ByteBuffer getTestBuffer(long length, int capacity) { - return switch (capacity) { - case 0 -> ByteBuffer.allocate(1).put((byte) length); - case 1 -> ByteBuffer.allocate(capacity).put((byte) length); - case 2 -> ByteBuffer.allocate(capacity).putShort((short) length); - case 4 -> ByteBuffer.allocate(capacity).putInt((int) length); - case 8 -> ByteBuffer.allocate(capacity).putLong(length); - default -> throw new SkippedException("bad value used for capacity"); - }; - } } diff --git a/test/jdk/java/net/httpclient/quic/ConnectionIDSTest.java b/test/jdk/java/net/httpclient/quic/ConnectionIDSTest.java index e7fabeeecac..96aeace0898 100644 --- a/test/jdk/java/net/httpclient/quic/ConnectionIDSTest.java +++ b/test/jdk/java/net/httpclient/quic/ConnectionIDSTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -29,12 +29,13 @@ import java.util.List; import java.util.Map; import jdk.internal.net.http.quic.QuicConnectionIdFactory; -import org.testng.annotations.Test; -import static org.testng.Assert.*; -/** +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; + +/* * @test - * @run testng/othervm ConnectionIDSTest + * @run junit/othervm ConnectionIDSTest */ public class ConnectionIDSTest { @@ -76,14 +77,14 @@ public class ConnectionIDSTest { int expectedLength = Math.min(length, 20); expectedLength = Math.max(9, expectedLength); long token = idFactory.newToken(); - assertEquals(token, previous +1); + assertEquals(previous +1, token); previous = token; var id = idFactory.newConnectionId(length, token); var cid = new ConnID(token, id); System.out.printf("%s: %s/%s%n", length, token, cid); - assertEquals(id.length, expectedLength); - assertEquals(idFactory.getConnectionIdLength(id), expectedLength); - assertEquals(idFactory.getConnectionIdToken(id), token); + assertEquals(expectedLength, id.length); + assertEquals(expectedLength, idFactory.getConnectionIdLength(id)); + assertEquals(token, idFactory.getConnectionIdToken(id)); ids.add(cid); } @@ -101,9 +102,9 @@ public class ConnectionIDSTest { var id = idFactory.newConnectionId(length, token); var cid = new ConnID(expectedToken, id); System.out.printf("%s: %s/%s%n", length, token, cid); - assertEquals(id.length, length); - assertEquals(idFactory.getConnectionIdLength(id), length); - assertEquals(idFactory.getConnectionIdToken(id), expectedToken); + assertEquals(length, id.length); + assertEquals(length, idFactory.getConnectionIdLength(id)); + assertEquals(expectedToken, idFactory.getConnectionIdToken(id)); ids.add(cid); } } @@ -119,15 +120,15 @@ public class ConnectionIDSTest { var id = idFactory.newConnectionId(length, token); var cid = new ConnID(expectedToken, id); System.out.printf("%s: %s/%s%n", length, token, cid); - assertEquals(id.length, length); - assertEquals(idFactory.getConnectionIdLength(id), length); - assertEquals(idFactory.getConnectionIdToken(id), expectedToken); + assertEquals(length, id.length); + assertEquals(length, idFactory.getConnectionIdLength(id)); + assertEquals(expectedToken, idFactory.getConnectionIdToken(id)); ids.add(cid); } } // now verify uniqueness - Map tested = new HashMap(); + Map tested = new HashMap<>(); record duplicates(ConnID first, ConnID second) {} List duplicates = new ArrayList<>(); for (var cid : ids) { @@ -144,9 +145,9 @@ public class ConnectionIDSTest { // and the token value is too big; check and remove them for (var iter = duplicates.iterator(); iter.hasNext(); ) { var dup = iter.next(); - assertEquals(dup.first.token(), dup.second.token()); - assertEquals(dup.first.bytes().length, dup.second.bytes().length); - assertEquals(dup.first.bytes(), dup.second.bytes()); + assertEquals(dup.second.token(), dup.first.token()); + assertEquals(dup.second.bytes().length, dup.first.bytes().length); + assertArrayEquals(dup.second.bytes(), dup.first.bytes()); long mask = 0x00FFFFFF00000000L; for (int i=0; i<3; i++) { mask = mask << 8; @@ -165,6 +166,6 @@ public class ConnectionIDSTest { for (var dup : duplicates) { System.out.println("unexpected duplicate: " + dup); } - assertEquals(duplicates.size(), 0); + assertEquals(0, duplicates.size()); } } diff --git a/test/jdk/java/net/httpclient/quic/CryptoWriterQueueTest.java b/test/jdk/java/net/httpclient/quic/CryptoWriterQueueTest.java index cfc62625605..422d71ca964 100644 --- a/test/jdk/java/net/httpclient/quic/CryptoWriterQueueTest.java +++ b/test/jdk/java/net/httpclient/quic/CryptoWriterQueueTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 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 @@ -23,18 +23,18 @@ import jdk.internal.net.http.quic.frames.CryptoFrame; import jdk.internal.net.http.quic.streams.CryptoWriterQueue; -import org.testng.annotations.Test; import java.nio.ByteBuffer; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; -/** +/* * @test * @summary Tests jdk.internal.net.http.quic.streams,CryptoWriterQueue * @modules java.net.http/jdk.internal.net.http.quic.streams * java.net.http/jdk.internal.net.http.quic.frames - * @run testng CryptoWriterQueueTest + * @run junit CryptoWriterQueueTest */ public class CryptoWriterQueueTest { @@ -54,7 +54,7 @@ public class CryptoWriterQueueTest { writerQueue.enqueue(buff2); writerQueue.enqueue(buff3); final int expectedRemaining = buff1.remaining() + buff2.remaining() + buff3.remaining(); - assertEquals(writerQueue.remaining(), expectedRemaining, + assertEquals(expectedRemaining, writerQueue.remaining(), "Unexpected remaining bytes in CryptoWriterQueue"); // create frame(s) from the enqueued buffers final int maxPayloadSize = 1134; diff --git a/test/jdk/java/net/httpclient/quic/KeyUpdateTest.java b/test/jdk/java/net/httpclient/quic/KeyUpdateTest.java index d6d287be9e0..d13b8d9b865 100644 --- a/test/jdk/java/net/httpclient/quic/KeyUpdateTest.java +++ b/test/jdk/java/net/httpclient/quic/KeyUpdateTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 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 @@ -48,12 +48,14 @@ import jdk.internal.net.quic.QuicKeyUnavailableException; import jdk.internal.net.quic.QuicTLSContext; import jdk.internal.net.quic.QuicVersion; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.annotations.AfterClass; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; + import sun.security.ssl.QuicTLSEngineImpl; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; /* * @test @@ -78,22 +80,22 @@ import static org.testng.Assert.assertTrue; * jdk.test.lib.net.SimpleSSLContext * @comment the test is run with -Djava.security.properties= to augment * the master java.security file - * @run testng/othervm -Djava.security.properties=${test.src}/quic-tls-keylimits-java.security + * @run junit/othervm -Djava.security.properties=${test.src}/quic-tls-keylimits-java.security * -Djdk.internal.httpclient.debug=true * -Djavax.net.debug=all * KeyUpdateTest */ public class KeyUpdateTest { - private QuicStandaloneServer server; + private static QuicStandaloneServer server; private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - private ExecutorService executor; + private static ExecutorService executor; private static final byte[] HELLO_MSG = "Hello Quic".getBytes(StandardCharsets.UTF_8); private static final EchoHandler handler = new EchoHandler(HELLO_MSG.length); - @BeforeClass - public void beforeClass() throws Exception { + @BeforeAll + public static void beforeClass() throws Exception { executor = Executors.newCachedThreadPool(); server = QuicStandaloneServer.newBuilder() .availableVersions(new QuicVersion[]{QuicVersion.QUIC_V1}) @@ -105,8 +107,8 @@ public class KeyUpdateTest { System.out.println("Server started at " + server.getAddress()); } - @AfterClass - public void afterClass() throws Exception { + @AfterAll + public static void afterClass() throws Exception { if (server != null) { System.out.println("Stopping server " + server.getAddress()); server.close(); @@ -163,7 +165,7 @@ public class KeyUpdateTest { // keep track of the 1-RTT key phase that was used by the client connection final int invocation = i; getKeyPhase(conn.underlyingQuicConnection()).ifPresent((keyPhase) -> { - if (clientConnKeyPhases.empty() || clientConnKeyPhases.peek() != keyPhase) { + if (clientConnKeyPhases.empty() || !keyPhase.equals(clientConnKeyPhases.peek())) { // new key phase detected, add it clientConnKeyPhases.push(keyPhase); System.out.println("Detected client 1-RTT key phase " + keyPhase @@ -223,7 +225,7 @@ public class KeyUpdateTest { // keep track of the 1-RTT key phase that was used by the server connection getKeyPhase(conn).ifPresent((keyPhase) -> { if (this.serverConnKeyPhases.empty() - || this.serverConnKeyPhases.peek() != keyPhase) { + || !keyPhase.equals(this.serverConnKeyPhases.peek())) { // new key phase detected, add it this.serverConnKeyPhases.push(keyPhase); System.out.println("Detected server 1-RTT key phase " + keyPhase diff --git a/test/jdk/java/net/httpclient/quic/OrderedFlowTest.java b/test/jdk/java/net/httpclient/quic/OrderedFlowTest.java index cb95620c00e..a1fafba8760 100644 --- a/test/jdk/java/net/httpclient/quic/OrderedFlowTest.java +++ b/test/jdk/java/net/httpclient/quic/OrderedFlowTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -37,24 +37,24 @@ import jdk.internal.net.http.quic.OrderedFlow; import jdk.internal.net.http.quic.frames.CryptoFrame; import jdk.internal.net.http.quic.frames.QuicFrame; import jdk.internal.net.http.quic.frames.StreamFrame; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertNotEquals; -import static org.testng.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -/** +/* * @test * @summary tests the reordering logic implemented by OrderedFlow * and its two concrete subclasses * @library /test/lib - * @run testng OrderedFlowTest - * @run testng/othervm -Dseed=-2680947227866359853 OrderedFlowTest - * @run testng/othervm -Dseed=-273117134353023275 OrderedFlowTest - * @run testng/othervm -Dseed=3649132517916066643 OrderedFlowTest - * @run testng/othervm -Dseed=4568737726943220431 OrderedFlowTest + * @run junit OrderedFlowTest + * @run junit/othervm -Dseed=-2680947227866359853 OrderedFlowTest + * @run junit/othervm -Dseed=-273117134353023275 OrderedFlowTest + * @run junit/othervm -Dseed=3649132517916066643 OrderedFlowTest + * @run junit/othervm -Dseed=4568737726943220431 OrderedFlowTest */ public class OrderedFlowTest { @@ -135,13 +135,13 @@ public class OrderedFlowTest { """; interface FramesFactory { - public T create(int offset, String payload, boolean fin); - public int length(T frame); - public long offset(T frame); - public String getPayload(T frame); - public OrderedFlow flow(); - public Class frameType(); - public Comparator comparator(); + T create(int offset, String payload, boolean fin); + int length(T frame); + long offset(T frame); + String getPayload(T frame); + OrderedFlow flow(); + Class frameType(); + Comparator comparator(); } static class StreamFrameFactory implements FramesFactory { @@ -307,7 +307,7 @@ public class OrderedFlowTest { // not be buffered. static TestData reversed(TestData data) { List sorted = new ArrayList<>(data.frames()); - Collections.sort(sorted, data.framesComparator().reversed()); + sorted.sort(data.framesComparator().reversed()); return new TestData<>(data.frameType(),data.flowSupplier(), data.payloadAccessor(), data.framesComparator(), List.copyOf(sorted), data.expectedResult(), data.duplicates(), true); @@ -336,8 +336,7 @@ public class OrderedFlowTest { return List.copyOf(result); } - @DataProvider(name="CryptoFrame") - Object[][] generateCryptoFrames() { + static Object[][] generateCryptoFrames() { return generateData(new CryptoFrameFactory()) .stream() .map(List::of) @@ -345,8 +344,7 @@ public class OrderedFlowTest { .toArray(Object[][]::new); } - @DataProvider(name="StreamFrame") - Object[][] generateStreanFrames() { + static Object[][] generateStreanFrames() { return generateData(new StreamFrameFactory()) .stream() .map(List::of) @@ -380,21 +378,23 @@ public class OrderedFlowTest { "buffered data %s exceeds or equals payload size %s".formatted(buffered, size)); while (received != null) { var payload = testData.payloadAccessor.apply(received); - assertNotEquals(payload, "", "empty frames not expected: " + received); + assertNotEquals("", payload, "empty frames not expected: " + received); result.append(payload); received = flow.poll(); } } - assertEquals(result.toString(), testData.expectedResult); + assertEquals(testData.expectedResult, result.toString()); } - @Test(dataProvider = "CryptoFrame") - public void testCryptoFlow(TestData testData) { + @ParameterizedTest + @MethodSource("generateCryptoFrames") + void testCryptoFlow(TestData testData) { testOrderedFlow(testData, CryptoFrame::offset); } - @Test(dataProvider = "StreamFrame") - public void testStreamFlow(TestData testData) { + @ParameterizedTest + @MethodSource("generateStreanFrames") + void testStreamFlow(TestData testData) { testOrderedFlow(testData, StreamFrame::offset); } diff --git a/test/jdk/java/net/httpclient/quic/PacerTest.java b/test/jdk/java/net/httpclient/quic/PacerTest.java index d54f4125a46..aebbbce34d3 100644 --- a/test/jdk/java/net/httpclient/quic/PacerTest.java +++ b/test/jdk/java/net/httpclient/quic/PacerTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 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 @@ -26,20 +26,21 @@ import jdk.internal.net.http.quic.QuicCongestionController; import jdk.internal.net.http.quic.QuicPacer; import jdk.internal.net.http.quic.QuicRttEstimator; import jdk.internal.net.http.quic.packets.QuicPacket; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.time.temporal.ChronoUnit; import java.util.Collection; import java.util.List; import java.util.stream.Stream; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; /* * @test - * @run testng/othervm -Djdk.httpclient.quic.timerFrequency=1000 PacerTest + * @run junit/othervm -Djdk.httpclient.quic.timerFrequency=1000 PacerTest */ public class PacerTest { @@ -136,8 +137,7 @@ public class PacerTest { int initialPermit, int periodicPermit, boolean slowStart) { } - @DataProvider - public Object[][] pacerFirstFlight() { + public static Object[][] pacerFirstFlight() { return List.of( // Should permit initial window before blocking new TestCase(1200, 10, 32, 16, 10, 4, true), @@ -150,7 +150,8 @@ public class PacerTest { .toArray(Object[][]::new); } - @Test(dataProvider = "pacerFirstFlight") + @ParameterizedTest + @MethodSource("pacerFirstFlight") public void testBasicPacing(TestCase test) { int maxDatagramSize = test.maxDatagramSize; int packetsInIW = test.packetsInIW; diff --git a/test/jdk/java/net/httpclient/quic/PacketEncodingTest.java b/test/jdk/java/net/httpclient/quic/PacketEncodingTest.java index 495e8d41403..a96904c8410 100644 --- a/test/jdk/java/net/httpclient/quic/PacketEncodingTest.java +++ b/test/jdk/java/net/httpclient/quic/PacketEncodingTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -52,8 +52,6 @@ import jdk.internal.net.http.quic.QuicConnectionId; import jdk.internal.net.quic.QuicTLSEngine; import jdk.internal.net.quic.QuicTransportParametersConsumer; import jdk.internal.net.http.quic.VariableLengthEncoder; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.crypto.AEADBadTagException; import javax.net.ssl.SSLParameters; @@ -71,29 +69,32 @@ import java.util.function.IntFunction; import java.util.stream.Collectors; import static jdk.internal.net.http.quic.packets.QuicPacketNumbers.computePacketNumberLength; -import static org.testng.Assert.*; -/** +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +/* * @test * @library /test/lib * @summary test packet encoding and decoding in unencrypted form and without * any network involvement. - * @run testng/othervm -Dseed=2646683818688275736 PacketEncodingTest - * @run testng/othervm -Dseed=-3723256402256409075 PacketEncodingTest - * @run testng/othervm -Dseed=-3689060484817342283 PacketEncodingTest - * @run testng/othervm -Dseed=2425718686525936108 PacketEncodingTest - * @run testng/othervm -Dseed=-2996954753243104355 PacketEncodingTest - * @run testng/othervm -Dseed=8750823652999067800 PacketEncodingTest - * @run testng/othervm -Dseed=2906555779406889127 PacketEncodingTest - * @run testng/othervm -Dseed=902801756808168822 PacketEncodingTest - * @run testng/othervm -Dseed=5643545543196691308 PacketEncodingTest - * @run testng/othervm -Dseed=2646683818688275736 PacketEncodingTest - * @run testng/othervm -Djdk.internal.httpclient.debug=true PacketEncodingTest + * @run junit/othervm -Dseed=2646683818688275736 PacketEncodingTest + * @run junit/othervm -Dseed=-3723256402256409075 PacketEncodingTest + * @run junit/othervm -Dseed=-3689060484817342283 PacketEncodingTest + * @run junit/othervm -Dseed=2425718686525936108 PacketEncodingTest + * @run junit/othervm -Dseed=-2996954753243104355 PacketEncodingTest + * @run junit/othervm -Dseed=8750823652999067800 PacketEncodingTest + * @run junit/othervm -Dseed=2906555779406889127 PacketEncodingTest + * @run junit/othervm -Dseed=902801756808168822 PacketEncodingTest + * @run junit/othervm -Dseed=5643545543196691308 PacketEncodingTest + * @run junit/othervm -Dseed=2646683818688275736 PacketEncodingTest + * @run junit/othervm -Djdk.internal.httpclient.debug=true PacketEncodingTest */ public class PacketEncodingTest { - @DataProvider - public Object[][] longHeaderPacketProvider() { + public static Object[][] longHeaderPacketProvider() { final QuicVersion[] quicVersions = QuicVersion.values(); final List params = new ArrayList<>(); for (final QuicVersion version : quicVersions) { @@ -117,8 +118,7 @@ public class PacketEncodingTest { return params.toArray(Object[][]::new); } - @DataProvider - public Object[][] shortHeaderPacketProvider() { + public static Object[][] shortHeaderPacketProvider() { final QuicVersion[] quicVersions = QuicVersion.values(); final List params = new ArrayList<>(); for (final QuicVersion version : quicVersions) { @@ -141,8 +141,7 @@ public class PacketEncodingTest { return params.toArray(Object[][]::new); } - @DataProvider - public Object[][] versionAndRetryProvider() { + public static Object[][] versionAndRetryProvider() { final QuicVersion[] quicVersions = QuicVersion.values(); final List params = new ArrayList<>(); for (final QuicVersion version : quicVersions) { @@ -393,23 +392,23 @@ public class PacketEncodingTest { QuicConnectionId destConnectionId, List payload) { // Check created packet - assertEquals(packet.headersType(), HeadersType.LONG); - assertEquals(packet.packetType(), packetType); + assertEquals(HeadersType.LONG, packet.headersType()); + assertEquals(packetType, packet.packetType()); boolean hasLength = switch (packetType) { case VERSIONS, RETRY -> false; default -> true; }; - assertEquals(packet.hasLength(), hasLength); - assertEquals(packet.numberSpace(), packetNumberSpace); + assertEquals(hasLength, packet.hasLength()); + assertEquals(packetNumberSpace, packet.numberSpace()); if (payload == null) { assertTrue(packet.frames().isEmpty()); } else { - assertEquals(getBuffers(packet.frames()), getBuffers(payload)); + assertEquals(getBuffers(payload), getBuffers(packet.frames())); } - assertEquals(packet.version(), versionNumber); - assertEquals(packet.packetNumber(), packetNumber); - assertEquals(packet.sourceId(), srcConnectionId); - assertEquals(packet.destinationId(), destConnectionId); + assertEquals(versionNumber, packet.version()); + assertEquals(packetNumber, packet.packetNumber()); + assertEquals(srcConnectionId, packet.sourceId()); + assertEquals(destConnectionId, packet.destinationId()); } @@ -446,11 +445,11 @@ public class PacketEncodingTest { PacketType packetType, int versionNumber, QuicConnectionId srcConnectionId, QuicConnectionId destConnectionId) { - assertEquals(QuicPacketDecoder.peekHeaderType(datagram, offset), HeadersType.LONG); - assertEquals(QuicPacketDecoder.of(datagram, offset).peekPacketType(datagram, offset), packetType); + assertEquals(HeadersType.LONG, QuicPacketDecoder.peekHeaderType(datagram, offset)); + assertEquals(packetType, QuicPacketDecoder.of(datagram, offset).peekPacketType(datagram, offset)); LongHeader header = QuicPacketDecoder.peekLongHeader(datagram, offset); assertNotNull(header, "Could not parse packet header"); - assertEquals(header.version(), versionNumber); + assertEquals(versionNumber, header.version()); assertTrue(header.destinationId() .matches(destConnectionId.asReadOnlyBuffer()), "Destination ID doesn't match"); assertTrue(header.sourceId() @@ -494,10 +493,10 @@ public class PacketEncodingTest { padding.encode(buf); } if (insert) { - assertEquals(buf.position(), remaining); - assertEquals(buf.remaining(), payloadSize - remaining); + assertEquals(remaining, buf.position()); + assertEquals(payloadSize - remaining, buf.remaining()); } else { - assertEquals(buf.remaining(), 0); + assertEquals(0, buf.remaining()); } return List.copyOf(frames); } @@ -507,7 +506,7 @@ public class PacketEncodingTest { int size = outgoingQuicPacket.size(); ByteBuffer buffer = ByteBuffer.allocate(size); encoder.encode(outgoingQuicPacket, buffer, context); - assertEquals(buffer.position(), size, " for " + outgoingQuicPacket); + assertEquals(size, buffer.position(), " for " + outgoingQuicPacket); buffer.flip(); return buffer; } @@ -520,33 +519,34 @@ public class PacketEncodingTest { List payload, int minSize) { // Check created packet - assertEquals(packet.headersType(), HeadersType.SHORT); - assertEquals(packet.packetType(), packetType); - assertEquals(packet.hasLength(), false); - assertEquals(packet.numberSpace(), packetNumberSpace); - assertEquals(getBuffers(packet.frames()), getBuffers(payload, minSize)); - assertEquals(packet.packetNumber(), packetNumber); - assertEquals(packet.destinationId(), destConnectionId); + assertEquals(HeadersType.SHORT, packet.headersType()); + assertEquals(packetType, packet.packetType()); + assertEquals(false, packet.hasLength()); + assertEquals(packetNumberSpace, packet.numberSpace()); + assertEquals(getBuffers(payload, minSize), getBuffers(packet.frames())); + assertEquals(packetNumber, packet.packetNumber()); + assertEquals(destConnectionId, packet.destinationId()); } private void checkShortHeaderPacketAt(ByteBuffer datagram, int offset, PacketType packetType, QuicConnectionId destConnectionId, CodingContext context) { - assertEquals(QuicPacketDecoder.peekHeaderType(datagram, offset), HeadersType.SHORT); - assertEquals(QuicPacketDecoder.of(QuicVersion.QUIC_V1).peekPacketType(datagram, offset), packetType); - assertEquals(QuicPacketDecoder.peekVersion(datagram, offset), 0); + assertEquals(HeadersType.SHORT, QuicPacketDecoder.peekHeaderType(datagram, offset)); + assertEquals(packetType, QuicPacketDecoder.of(QuicVersion.QUIC_V1).peekPacketType(datagram, offset)); + assertEquals(0, QuicPacketDecoder.peekVersion(datagram, offset)); int pos = datagram.position(); if (pos != offset) datagram.position(offset); try { - assertEquals(QuicPacketDecoder.peekShortConnectionId(datagram, destConnectionId.length()) - .mismatch(destConnectionId.asReadOnlyBuffer()), -1); + assertEquals(-1, QuicPacketDecoder.peekShortConnectionId(datagram, destConnectionId.length()) + .mismatch(destConnectionId.asReadOnlyBuffer())); } finally { if (pos != offset) datagram.position(pos); } } - @Test(dataProvider = "longHeaderPacketProvider") + @ParameterizedTest + @MethodSource("longHeaderPacketProvider") public void testInitialPacket(QuicVersion quicVersion, int srcIdLength, int destIdLength, long packetNumber, long largestAcked) throws Exception { System.out.printf("%ntestInitialPacket(qv:%s, scid:%d, dcid:%d, pn:%d, ack:%d)%n", @@ -557,12 +557,12 @@ public class PacketEncodingTest { .newConnectionId(destIdLength, IDS.incrementAndGet()); assert destid.length <= 20; final QuicConnectionId destConnectionId = new PeerConnectionId(destid); - assertEquals(destid.length, destConnectionId.length(), "dcid length"); + assertEquals(destConnectionId.length(), destid.length, "dcid length"); destIdLength = destid.length; byte[] srcid = randomIdBytes(srcIdLength); final QuicConnectionId srcConnectionId = new PeerConnectionId(srcid); - assertEquals(srcid.length, srcConnectionId.length(), "scid length"); + assertEquals(srcConnectionId.length(), srcid.length, "scid length"); int bound = MAX_DATAGRAM_IPV6 - srcIdLength - destid.length - 7 - QuicPacketNumbers.computePacketNumberLength(packetNumber, largestAcked) @@ -603,8 +603,8 @@ public class PacketEncodingTest { byte[] payload = new byte[payloadSize]; List frames = frames(payload, padding != 0); - assertEquals(frames.stream().mapToInt(QuicFrame::size) - .reduce(0, Math::addExact), payloadSize); + assertEquals(payloadSize, frames.stream().mapToInt(QuicFrame::size) + .reduce(0, Math::addExact)); // Create an initial packet @@ -626,7 +626,7 @@ public class PacketEncodingTest { largestAcked, frames2, context); - assertEquals(padding, padding + (1200 - packet2.size())); + assertEquals(padding + (1200 - packet2.size()), padding); } // Check created packet @@ -640,10 +640,10 @@ public class PacketEncodingTest { checkLongHeaderPacket(initialPacket, PacketType.INITIAL, quicVersion.versionNumber(), PacketNumberSpace.INITIAL, packetNumber, srcConnectionId, destConnectionId, frames, padding); - assertEquals(initialPacket.tokenLength(), tokenLength); - assertEquals(initialPacket.token(), token); - assertEquals(initialPacket.hasLength(), true); - assertEquals(initialPacket.length(), packetNumberLength + payloadSize + padding); + assertEquals(tokenLength, initialPacket.tokenLength()); + assertEquals(token, initialPacket.token()); + assertEquals(true, initialPacket.hasLength()); + assertEquals(packetNumberLength + payloadSize + padding, initialPacket.length()); // Check that peeking at the encoded packet returns correct information @@ -682,9 +682,9 @@ public class PacketEncodingTest { datagram.position(0); datagram.limit(datagram.capacity()); decoder.skipPacket(datagram, offset); - assertEquals(datagram.position(), second); + assertEquals(second, datagram.position()); decoder.skipPacket(datagram, second); - assertEquals(datagram.remaining(), offset); + assertEquals(offset, datagram.remaining()); datagram.position(offset); int size = second - offset; @@ -692,23 +692,24 @@ public class PacketEncodingTest { int pos = datagram.position(); System.out.printf("Decoding packet: %d at %d%n", (i+1), pos); var decodedPacket = decoder.decode(datagram, context); - assertEquals(datagram.position(), pos + size); + assertEquals(pos + size, datagram.position()); assertTrue(decodedPacket instanceof InitialPacket, "decoded: " + decodedPacket); InitialPacket initialDecoded = InitialPacket.class.cast(decodedPacket); checkLongHeaderPacket(initialDecoded, PacketType.INITIAL, quicVersion.versionNumber(), PacketNumberSpace.INITIAL, packetNumber, srcConnectionId, destConnectionId, frames, padding); - assertEquals(decodedPacket.size(), packet.size()); - assertEquals(decodedPacket.size(), size); - assertEquals(initialDecoded.tokenLength(), tokenLength); - assertEquals(initialDecoded.token(), token); - assertEquals(initialDecoded.length(), initialPacket.length()); - assertEquals(initialDecoded.length(), packetNumberLength + payloadSize + padding); + assertEquals(packet.size(), decodedPacket.size()); + assertEquals(size, decodedPacket.size()); + assertEquals(tokenLength, initialDecoded.tokenLength()); + assertArrayEquals(token, initialDecoded.token()); + assertEquals(initialPacket.length(), initialDecoded.length()); + assertEquals(packetNumberLength + payloadSize + padding, initialDecoded.length()); } - assertEquals(datagram.position(), second + second - offset); + assertEquals(second + second - offset, datagram.position()); } - @Test(dataProvider = "longHeaderPacketProvider") + @ParameterizedTest + @MethodSource("longHeaderPacketProvider") public void testHandshakePacket(QuicVersion quicVersion, int srcIdLength, int destIdLength, long packetNumber, long largestAcked) throws Exception { System.out.printf("%ntestHandshakePacket(qv:%s, scid:%d, dcid:%d, pn:%d, ack:%d)%n", @@ -757,8 +758,8 @@ public class PacketEncodingTest { checkLongHeaderPacket(handshakePacket, PacketType.HANDSHAKE, quicVersion.versionNumber(), PacketNumberSpace.HANDSHAKE, packetNumber, srcConnectionId, destConnectionId, frames); - assertEquals(handshakePacket.hasLength(), true); - assertEquals(handshakePacket.length(), packetNumberLength + payloadSize); + assertEquals(true, handshakePacket.hasLength()); + assertEquals(packetNumberLength + payloadSize, handshakePacket.length()); // Decode the two packets in the datagram // Check that peeking at the encoded packet returns correct information @@ -797,9 +798,9 @@ public class PacketEncodingTest { datagram.position(0); datagram.limit(datagram.capacity()); decoder.skipPacket(datagram, offset); - assertEquals(datagram.position(), second); + assertEquals(second, datagram.position()); decoder.skipPacket(datagram, second); - assertEquals(datagram.remaining(), offset); + assertEquals(offset, datagram.remaining()); datagram.position(offset); int size = second - offset; @@ -807,21 +808,22 @@ public class PacketEncodingTest { int pos = datagram.position(); System.out.printf("Decoding packet: %d at %d%n", (i+1), pos); var decodedPacket = decoder.decode(datagram, context); - assertEquals(datagram.position(), pos + size); + assertEquals(pos + size, datagram.position()); assertTrue(decodedPacket instanceof HandshakePacket, "decoded: " + decodedPacket); HandshakePacket handshakeDecoded = HandshakePacket.class.cast(decodedPacket); checkLongHeaderPacket(handshakeDecoded, PacketType.HANDSHAKE, quicVersion.versionNumber(), PacketNumberSpace.HANDSHAKE, packetNumber, srcConnectionId, destConnectionId, frames); - assertEquals(decodedPacket.size(), packet.size()); - assertEquals(decodedPacket.size(), size); - assertEquals(handshakeDecoded.length(), handshakePacket.length()); - assertEquals(handshakeDecoded.length(), packetNumberLength + payloadSize); + assertEquals(packet.size(), decodedPacket.size()); + assertEquals(size, decodedPacket.size()); + assertEquals(handshakePacket.length(), handshakeDecoded.length()); + assertEquals(packetNumberLength + payloadSize, handshakeDecoded.length()); } - assertEquals(datagram.position(), second + second - offset); + assertEquals(second + second - offset, datagram.position()); } - @Test(dataProvider = "longHeaderPacketProvider") + @ParameterizedTest + @MethodSource("longHeaderPacketProvider") public void testZeroRTTPacket(QuicVersion quicVersion, int srcIdLength, int destIdLength, long packetNumber, long largestAcked) throws Exception { System.out.printf("%ntestZeroRTTPacket(qv:%s, scid:%d, dcid:%d, pn:%d, ack:%d)%n", @@ -870,8 +872,8 @@ public class PacketEncodingTest { checkLongHeaderPacket(zeroRttPacket, PacketType.ZERORTT, quicVersion.versionNumber(), PacketNumberSpace.APPLICATION, packetNumber, srcConnectionId, destConnectionId, frames); - assertEquals(zeroRttPacket.hasLength(), true); - assertEquals(zeroRttPacket.length(), packetNumberLength + payloadSize); + assertEquals(true, zeroRttPacket.hasLength()); + assertEquals(packetNumberLength + payloadSize, zeroRttPacket.length()); // Check that peeking at the encoded packet returns correct information ByteBuffer encoded = toByteBuffer(encoder, packet, context); @@ -909,9 +911,9 @@ public class PacketEncodingTest { datagram.position(0); datagram.limit(datagram.capacity()); decoder.skipPacket(datagram, offset); - assertEquals(datagram.position(), second); + assertEquals(second, datagram.position()); decoder.skipPacket(datagram, second); - assertEquals(datagram.remaining(), offset); + assertEquals(offset, datagram.remaining()); // Decode the two packets in the datagram datagram.position(offset); @@ -920,21 +922,22 @@ public class PacketEncodingTest { int pos = datagram.position(); System.out.printf("Decoding packet: %d at %d%n", (i+1), pos); var decodedPacket = decoder.decode(datagram, context); - assertEquals(datagram.position(), pos + size); + assertEquals(pos + size, datagram.position()); assertTrue(decodedPacket instanceof ZeroRttPacket, "decoded: " + decodedPacket); ZeroRttPacket zeroRttDecoded = ZeroRttPacket.class.cast(decodedPacket); checkLongHeaderPacket(zeroRttDecoded, PacketType.ZERORTT, quicVersion.versionNumber(), PacketNumberSpace.APPLICATION, packetNumber, srcConnectionId, destConnectionId, frames); - assertEquals(decodedPacket.size(), packet.size()); - assertEquals(decodedPacket.size(), size); - assertEquals(zeroRttDecoded.length(), zeroRttPacket.length()); - assertEquals(zeroRttDecoded.length(), packetNumberLength + payloadSize); + assertEquals(packet.size(), decodedPacket.size()); + assertEquals(size, decodedPacket.size()); + assertEquals(zeroRttPacket.length(), zeroRttDecoded.length()); + assertEquals(packetNumberLength + payloadSize, zeroRttDecoded.length()); } - assertEquals(datagram.position(), second + second - offset); + assertEquals(second + second - offset, datagram.position()); } - @Test(dataProvider = "versionAndRetryProvider") + @ParameterizedTest + @MethodSource("versionAndRetryProvider") public void testVersionNegotiationPacket(QuicVersion quicVersion, int srcIdLength, int destIdLength) throws Exception { System.out.printf("%ntestVersionNegotiationPacket(qv:%s, scid:%d, dcid:%d, pn:%d, ack:%d)%n", @@ -965,9 +968,9 @@ public class PacketEncodingTest { checkLongHeaderPacket(versionPacket, PacketType.VERSIONS, 0, PacketNumberSpace.NONE, -1, srcConnectionId, destConnectionId, null); - assertEquals(versionPacket.hasLength(), false); - assertEquals(versionPacket.supportedVersions(), - versionList.stream().mapToInt(Integer::intValue).toArray()); + assertEquals(false, versionPacket.hasLength()); + assertArrayEquals(versionList.stream().mapToInt(Integer::intValue).toArray(), + versionPacket.supportedVersions()); CodingContext context = new TestCodingContext() { @Override public long largestProcessedPN(PacketNumberSpace packetSpace) { @@ -1009,8 +1012,8 @@ public class PacketEncodingTest { datagram.position(0); datagram.limit(datagram.capacity()); decoder.skipPacket(datagram, offset); - assertEquals(datagram.position(), end); - assertEquals(datagram.remaining(), 0); + assertEquals(end, datagram.position()); + assertEquals(0, datagram.remaining()); // Decode the two packets in the datagram datagram.position(offset); @@ -1019,21 +1022,22 @@ public class PacketEncodingTest { int pos = datagram.position(); System.out.printf("Decoding packet: %d at %d%n", (i+1), pos); var decodedPacket = decoder.decode(datagram, context); - assertEquals(datagram.position(), pos + size); + assertEquals(pos + size, datagram.position()); assertTrue(decodedPacket instanceof VersionNegotiationPacket, "decoded: " + decodedPacket); VersionNegotiationPacket decodedVersion = VersionNegotiationPacket.class.cast(decodedPacket); checkLongHeaderPacket(decodedVersion, PacketType.VERSIONS, 0, PacketNumberSpace.NONE, -1, srcConnectionId, destConnectionId, null); - assertEquals(decodedPacket.size(), packet.size()); - assertEquals(decodedPacket.size(), size); - assertEquals(decodedVersion.supportedVersions(), - versionList.stream().mapToInt(Integer::intValue).toArray()); + assertEquals(packet.size(), decodedPacket.size()); + assertEquals(size, decodedPacket.size()); + assertArrayEquals(versionList.stream().mapToInt(Integer::intValue).toArray(), + decodedVersion.supportedVersions()); } - assertEquals(datagram.position(), end); + assertEquals(end, datagram.position()); } - @Test(dataProvider = "versionAndRetryProvider") + @ParameterizedTest + @MethodSource("versionAndRetryProvider") public void testRetryPacket(QuicVersion quicVersion, int srcIdLength, int destIdLength) throws Exception { System.out.printf("%ntestRetryPacket(qv:%s, scid:%d, dcid:%d, pn:%d, ack:%d)%n", @@ -1067,9 +1071,9 @@ public class PacketEncodingTest { checkLongHeaderPacket(retryPacket, PacketType.RETRY, quicVersion.versionNumber(), PacketNumberSpace.NONE, -1, srcConnectionId, destConnectionId, null); - assertEquals(retryPacket.hasLength(), false); - assertEquals(retryPacket.retryToken(), retryToken); - assertEquals(retryPacket.size(), expectedSize); + assertEquals(false, retryPacket.hasLength()); + assertArrayEquals(retryToken, retryPacket.retryToken()); + assertEquals(expectedSize, retryPacket.size()); CodingContext context = new TestCodingContext() { @Override public long largestProcessedPN(PacketNumberSpace packetSpace) { @@ -1112,8 +1116,8 @@ public class PacketEncodingTest { datagram.position(0); datagram.limit(datagram.capacity()); decoder.skipPacket(datagram, offset); - assertEquals(datagram.position(), end); - assertEquals(datagram.remaining(), 0); + assertEquals(end, datagram.position()); + assertEquals(0, datagram.remaining()); // Decode the two packets in the datagram datagram.position(offset); @@ -1122,21 +1126,22 @@ public class PacketEncodingTest { int pos = datagram.position(); System.out.printf("Decoding packet: %d at %d%n", (i+1), pos); var decodedPacket = decoder.decode(datagram, context); - assertEquals(datagram.position(), pos + size); + assertEquals(pos + size, datagram.position()); assertTrue(decodedPacket instanceof RetryPacket, "decoded: " + decodedPacket); RetryPacket decodedRetry = RetryPacket.class.cast(decodedPacket); checkLongHeaderPacket(decodedRetry, PacketType.RETRY, quicVersion.versionNumber(), PacketNumberSpace.NONE, -1, srcConnectionId, destConnectionId, null); - assertEquals(decodedPacket.size(), packet.size()); - assertEquals(decodedPacket.size(), size); - assertEquals(decodedPacket.size(), expectedSize); - assertEquals(decodedRetry.retryToken(), retryToken); + assertEquals(packet.size(), decodedPacket.size()); + assertEquals(size, decodedPacket.size()); + assertEquals(expectedSize, decodedPacket.size()); + assertArrayEquals(retryToken, decodedRetry.retryToken()); } - assertEquals(datagram.position(), end); + assertEquals(end, datagram.position()); } - @Test(dataProvider = "shortHeaderPacketProvider") + @ParameterizedTest + @MethodSource("shortHeaderPacketProvider") public void testOneRTTPacket(QuicVersion quicVersion, int destIdLength, long packetNumber, long largestAcked) throws Exception { System.out.printf("%ntestOneRTTPacket(qv:%s, dcid:%d, pn:%d, ack:%d)%n", @@ -1186,8 +1191,8 @@ public class PacketEncodingTest { checkShortHeaderPacket(packet, PacketType.ONERTT, PacketNumberSpace.APPLICATION, packetNumber, destConnectionId, frames, minPayloadSize); - assertEquals(packet.hasLength(), false); - assertEquals(packet.size(), expectedSize); + assertEquals(false, packet.hasLength()); + assertEquals(expectedSize, packet.size()); // Check that peeking at the encoded packet returns correct information ByteBuffer encoded = toByteBuffer(encoder, packet, context); @@ -1218,9 +1223,9 @@ public class PacketEncodingTest { datagram.position(0); datagram.limit(end); decoder.skipPacket(datagram, offset); - assertEquals(datagram.position(), offset + expectedSize); - assertEquals(datagram.position(), datagram.limit()); - assertEquals(datagram.position(), datagram.capacity() - offset); + assertEquals(offset + expectedSize, datagram.position()); + assertEquals(datagram.limit(), datagram.position()); + assertEquals(datagram.capacity() - offset, datagram.position()); // Decode the packet in the datagram @@ -1230,7 +1235,7 @@ public class PacketEncodingTest { int pos = datagram.position(); System.out.printf("Decoding packet: %d at %d%n", (i+1), pos); var decodedPacket = decoder.decode(datagram, context); - assertEquals(datagram.position(), pos + size); + assertEquals(pos + size, datagram.position()); assertTrue(decodedPacket instanceof OneRttPacket, "decoded: " + decodedPacket); OneRttPacket oneRttDecoded = OneRttPacket.class.cast(decodedPacket); List expectedFrames = frames; @@ -1258,12 +1263,12 @@ public class PacketEncodingTest { checkShortHeaderPacket(oneRttDecoded, PacketType.ONERTT, PacketNumberSpace.APPLICATION, packetNumber, destConnectionId, expectedFrames, minPayloadSize); - assertEquals(decodedPacket.size(), packet.size()); - assertEquals(decodedPacket.size(), size); + assertEquals(packet.size(), decodedPacket.size()); + assertEquals(size, decodedPacket.size()); } - assertEquals(datagram.position(), offset + size); - assertEquals(datagram.remaining(), 0); - assertEquals(datagram.limit(), end); + assertEquals(offset + size, datagram.position()); + assertEquals(0, datagram.remaining()); + assertEquals(end, datagram.limit()); } @@ -1299,15 +1304,15 @@ public class PacketEncodingTest { ByteBuffer.wrap(new byte[] {16, 17}), ByteBuffer.wrap(new byte[] {18, 19, 20}) ); - assertEquals(Utils.mismatch(match1, match1), -1); - assertEquals(Utils.mismatch(match2, match2), -1); - assertEquals(Utils.mismatch(match3, match3), -1); - assertEquals(Utils.mismatch(match1, match2), -1); - assertEquals(Utils.mismatch(match2, match1), -1); - assertEquals(Utils.mismatch(match1, match3), -1); - assertEquals(Utils.mismatch(match3, match1), -1); - assertEquals(Utils.mismatch(match2, match3), -1); - assertEquals(Utils.mismatch(match3, match2), -1); + assertEquals(-1, Utils.mismatch(match1, match1)); + assertEquals(-1, Utils.mismatch(match2, match2)); + assertEquals(-1, Utils.mismatch(match3, match3)); + assertEquals(-1, Utils.mismatch(match1, match2)); + assertEquals(-1, Utils.mismatch(match2, match1)); + assertEquals(-1, Utils.mismatch(match1, match3)); + assertEquals(-1, Utils.mismatch(match3, match1)); + assertEquals(-1, Utils.mismatch(match2, match3)); + assertEquals(-1, Utils.mismatch(match3, match2)); } @Test @@ -1413,25 +1418,25 @@ public class PacketEncodingTest { ByteBuffer.wrap(new byte[] {18, 19, 20, 41, 42, 43}) ); - assertEquals(Utils.mismatch(nomatch0, nomatch0), -1L); - assertEquals(Utils.mismatch(nomatch10, nomatch10), -1L); - assertEquals(Utils.mismatch(nomatch19, nomatch19), -1L); - assertEquals(Utils.mismatch(morematch1, morematch1), -1L); - assertEquals(Utils.mismatch(morematch2, morematch2), -1L); - assertEquals(Utils.mismatch(morematch3, morematch3), -1L); - assertEquals(Utils.mismatch(morematch2, morematch3), -1L); - assertEquals(Utils.mismatch(morematch3, morematch2), -1L); + assertEquals(-1L, Utils.mismatch(nomatch0, nomatch0)); + assertEquals(-1L, Utils.mismatch(nomatch10, nomatch10)); + assertEquals(-1L, Utils.mismatch(nomatch19, nomatch19)); + assertEquals(-1L, Utils.mismatch(morematch1, morematch1)); + assertEquals(-1L, Utils.mismatch(morematch2, morematch2)); + assertEquals(-1L, Utils.mismatch(morematch3, morematch3)); + assertEquals(-1L, Utils.mismatch(morematch2, morematch3)); + assertEquals(-1L, Utils.mismatch(morematch3, morematch2)); for (var match : List.of(match1, match2, match3)) { - assertEquals(Utils.mismatch(match, nomatch0), 0L); - assertEquals(Utils.mismatch(match, nomatch10), 10L); - assertEquals(Utils.mismatch(match, nomatch19), 19L); - assertEquals(Utils.mismatch(nomatch0, match), 0L); - assertEquals(Utils.mismatch(nomatch10, match), 10L); - assertEquals(Utils.mismatch(nomatch19, match), 19L); + assertEquals(0L, Utils.mismatch(match, nomatch0)); + assertEquals(10L, Utils.mismatch(match, nomatch10)); + assertEquals(19L, Utils.mismatch(match, nomatch19)); + assertEquals(0L, Utils.mismatch(nomatch0, match)); + assertEquals(10L, Utils.mismatch(nomatch10, match)); + assertEquals(19L, Utils.mismatch(nomatch19, match)); for (var morematch : List.of(morematch1, morematch2, morematch3)) { - assertEquals(Utils.mismatch(match, morematch), 20L); - assertEquals(Utils.mismatch(morematch, match), 20L); + assertEquals(20L, Utils.mismatch(match, morematch)); + assertEquals(20L, Utils.mismatch(morematch, match)); } } diff --git a/test/jdk/java/net/httpclient/quic/PacketNumbersTest.java b/test/jdk/java/net/httpclient/quic/PacketNumbersTest.java index 3a4237d0847..c018079ea4e 100644 --- a/test/jdk/java/net/httpclient/quic/PacketNumbersTest.java +++ b/test/jdk/java/net/httpclient/quic/PacketNumbersTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -27,16 +27,17 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Stream; import jdk.internal.net.http.quic.packets.QuicPacketNumbers; -import org.testng.SkipException; -import org.testng.annotations.Test; -import org.testng.annotations.DataProvider; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.expectThrows; +import org.junit.jupiter.api.Assertions; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -/** +/* * @test - * @run testng PacketNumbersTest + * @run junit PacketNumbersTest */ public class PacketNumbersTest { @@ -85,8 +86,7 @@ public class PacketNumbersTest { } } - @DataProvider - public Object[][] encode() { + public static Object[][] encode() { return List.of( // these first three test cases are extracted from RFC 9000, appendix A.2 and A.3 new TestCase("success", 0xa82f9b32L, 0xa82f30eaL, EncodeResult.success(0x9b32)), @@ -127,19 +127,18 @@ public class PacketNumbersTest { .toArray(Object[][]::new); } - @Test(dataProvider = "encode") + @ParameterizedTest + @MethodSource("encode") public void testEncodePacketNumber(TestCase test) { System.out.println(test); if (test.result().assertion()) { - if (!QuicPacketNumbers.class.desiredAssertionStatus()) { - throw new SkipException("needs assertion enabled (-esa)"); - } - Throwable t = expectThrows(test.result().failure(), test::encode); + Assumptions.assumeFalse(!QuicPacketNumbers.class.desiredAssertionStatus(), "needs assertion enabled (-esa)"); + Throwable t = Assertions.assertThrows(test.result().failure(), test::encode); System.out.println("Got expected assertion: " + t); return; } if (test.result().fail()) { - Throwable t = expectThrows(test.result().failure(), test::encode); + Throwable t = Assertions.assertThrows(test.result().failure(), test::encode); System.out.println("Got expected exception: " + t); return; @@ -152,8 +151,8 @@ public class PacketNumbersTest { } // encode the full PN - check that the truncated PN == expected - assertEquals(truncated, test.result().expected()); + assertEquals(test.result().expected(), truncated); // check that decode(encoded) == fullPN - assertEquals(test.decode(), test.fullPN()); + assertEquals(test.fullPN(), test.decode()); } } diff --git a/test/jdk/java/net/httpclient/quic/PacketSpaceManagerTest.java b/test/jdk/java/net/httpclient/quic/PacketSpaceManagerTest.java index 40497ec13da..fe3b748a2fa 100644 --- a/test/jdk/java/net/httpclient/quic/PacketSpaceManagerTest.java +++ b/test/jdk/java/net/httpclient/quic/PacketSpaceManagerTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -73,34 +73,35 @@ import jdk.internal.net.quic.QuicVersion; import jdk.internal.net.quic.QuicTransportException; import jdk.internal.net.quic.QuicTransportParametersConsumer; import jdk.test.lib.RandomFactory; -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import javax.crypto.AEADBadTagException; import javax.net.ssl.SSLParameters; import javax.net.ssl.SSLSession; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertNotNull; -import static org.testng.Assert.assertNull; -import static org.testng.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; -/** +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +/* * @test * @summary tests the logic to build an AckFrame * @library /test/lib * @library ../debug * @build java.net.http/jdk.internal.net.http.common.TestLoggerUtil - * @run testng/othervm PacketSpaceManagerTest - * @run testng/othervm -Dseed=-7947549564260911920 PacketSpaceManagerTest - * @run testng/othervm -Dseed=-5413111674202728207 PacketSpaceManagerTest - * @run testng/othervm -Dseed=-176652423987357212 PacketSpaceManagerTest - * @run testng/othervm -Dseed=6550551791799910315 PacketSpaceManagerTest - * @run testng/othervm -Dseed=-4159871071396382784 PacketSpaceManagerTest - * @run testng/othervm -Dseed=2252276218459363615 PacketSpaceManagerTest - * @run testng/othervm -Dseed=-5130588140709404919 PacketSpaceManagerTest + * @run junit/othervm PacketSpaceManagerTest + * @run junit/othervm -Dseed=-7947549564260911920 PacketSpaceManagerTest + * @run junit/othervm -Dseed=-5413111674202728207 PacketSpaceManagerTest + * @run junit/othervm -Dseed=-176652423987357212 PacketSpaceManagerTest + * @run junit/othervm -Dseed=6550551791799910315 PacketSpaceManagerTest + * @run junit/othervm -Dseed=-4159871071396382784 PacketSpaceManagerTest + * @run junit/othervm -Dseed=2252276218459363615 PacketSpaceManagerTest + * @run junit/othervm -Dseed=-5130588140709404919 PacketSpaceManagerTest */ // -Djdk.internal.httpclient.debug=true public class PacketSpaceManagerTest { @@ -337,7 +338,7 @@ public class PacketSpaceManagerTest { * @param first the first packet acknowledged, inclusive * @param last the last packet acknowledged, inclusive */ - public static record Acknowledged(long first, long last) { + public record Acknowledged(long first, long last) { public Acknowledged { assert first >= 0 && first <= last; } @@ -360,7 +361,7 @@ public class PacketSpaceManagerTest { * @param packetNumber the packet number of the packet to send * @param delay a delay before the next packet should be emitted */ - public static record Packet(long packetNumber, long delay) { + public record Packet(long packetNumber, long delay) { Packet(long packetNumber) { this(packetNumber, RANDOM.nextLong(1, 255)); } @@ -391,7 +392,7 @@ public class PacketSpaceManagerTest { * before it's been emitted). * @param shuffled whether the list of packets is shuffled. */ - public static record TestCase(List acks, + public record TestCase(List acks, List packets, List ackframes, boolean shuffled) { @@ -440,7 +441,7 @@ public class PacketSpaceManagerTest { * a list of special testcases, and a list of random testcases. * @return A list of TestCases to test. */ - List generateTests() { + static List generateTests() { List tests = new ArrayList<>(); List simples = List.of( new TestCase(List.of(new Acknowledged(5,5))), @@ -485,7 +486,7 @@ public class PacketSpaceManagerTest { * A packet should only be present once. * @return a random list of increasing acknowledgement ranges. */ - List generateAcks() { + static List generateAcks() { int count = RANDOM.nextInt(3, 10); List acks = new ArrayList<>(count); long prev = -1; @@ -516,8 +517,7 @@ public class PacketSpaceManagerTest { return res; } - @DataProvider(name = "tests") - public Object[][] tests() { + public static Object[][] tests() { return generateTests().stream() .map(List::of) .map(List::toArray) @@ -757,7 +757,7 @@ public class PacketSpaceManagerTest { final CopyOnWriteArrayList retransmissions = new CopyOnWriteArrayList<>(); final CopyOnWriteArrayList successfulExpectations = new CopyOnWriteArrayList<>(); - static record Retransmission(long packetNumber, Deadline atOrAfter, long largestAckSent) { + record Retransmission(long packetNumber, Deadline atOrAfter, long largestAckSent) { boolean isFor(long number) { return number == packetNumber; } @@ -774,7 +774,7 @@ public class PacketSpaceManagerTest { * the test. * This method checks that the retransmission logic works as * expected. - * @throws Exception + * @throws Exception if the call fails */ // TODO: in the end we need to check that everything that was // expected to happen happened. What is missing is to @@ -890,7 +890,7 @@ public class PacketSpaceManagerTest { .stream().filter(AckFrame.class::isInstance) .map(AckFrame.class::cast) .toList(); - assertEquals(frames.size(), 1, + assertEquals(1, frames.size(), "unexpected ack frames: " + frames); AckFrame ackFrame = ackFrames.get(0); LongStream.range(firstAckPaket, lastAckPacket + 1) @@ -1029,10 +1029,11 @@ public class PacketSpaceManagerTest { void check() { assertFalse(now().isBefore(timeSource.first.plusMillis(timeline))); assertTrue(expectedRetransmissions.isEmpty()); - assertEquals(retransmissions.stream() + assertEquals(successfulExpectations.stream() .map(Retransmission::packetNumber) .filter(pn -> pn <= maxPacketNumber).toList(), - successfulExpectations.stream().map(Retransmission::packetNumber) + retransmissions.stream() + .map(Retransmission::packetNumber) .filter(pn -> pn <= maxPacketNumber).toList()); for (Retransmission r : retransmissions) { if (r.packetNumber > maxPacketNumber || @@ -1040,14 +1041,14 @@ public class PacketSpaceManagerTest { List succesful = successfulExpectations.stream() .filter(s -> s.isFor(r.packetNumber)) .toList(); - assertEquals(succesful.size(), 1); + assertEquals(1, succesful.size()); succesful.forEach(s -> assertFalse(s.atOrAfter.isAfter(r.atOrAfter))); } List acknowledged = new ArrayList<>(acknowledgePackets(allAcks.build())); Collections.sort(acknowledged); - assertEquals(acknowledged, test.packets.stream() - .map(Packet::packetNumber).sorted().toList()); + assertEquals(test.packets.stream() + .map(Packet::packetNumber).sorted().toList(), acknowledged); } // TODO: add a LongStream acknowledged() to AckFrame - write a spliterator @@ -1073,8 +1074,8 @@ public class PacketSpaceManagerTest { default String negation() { return (this == FALSE) ? "doesn't " : ""; } - Assertion TRUE = Assert::assertTrue; - Assertion FALSE = Assert::assertFalse; + Assertion TRUE = Assertions::assertTrue; + Assertion FALSE = Assertions::assertFalse; } static void assertContains(Assertion assertion, List list, long number, String desc) { assertion.check(list.contains(number), @@ -1115,7 +1116,8 @@ public class PacketSpaceManagerTest { } } - @Test(dataProvider = "tests") + @ParameterizedTest + @MethodSource("tests") public void testPacketSpaceManager(TestCase testCase) throws Exception { System.out.printf("%n ------- testPacketSpaceManager ------- %n"); SynchronousTestDriver driver = new SynchronousTestDriver(testCase); diff --git a/test/jdk/java/net/httpclient/quic/QuicFramesDecoderTest.java b/test/jdk/java/net/httpclient/quic/QuicFramesDecoderTest.java index f0d4b316e46..ef0801e6c18 100644 --- a/test/jdk/java/net/httpclient/quic/QuicFramesDecoderTest.java +++ b/test/jdk/java/net/httpclient/quic/QuicFramesDecoderTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 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 @@ -24,20 +24,20 @@ import jdk.internal.net.http.quic.frames.QuicFrame; import jdk.internal.net.quic.QuicTransportErrors; import jdk.internal.net.quic.QuicTransportException; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.nio.ByteBuffer; import java.util.HexFormat; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; /* * @test * @library /test/lib * @summary Tests to check QUIC frame decoding errors are handled correctly - * @run testng/othervm QuicFramesDecoderTest + * @run junit/othervm QuicFramesDecoderTest */ public class QuicFramesDecoderTest { @@ -181,7 +181,6 @@ public class QuicFramesDecoderTest { private static final byte[] NEW_CONNECTION_ID_ZERO = HexFormat.of().parseHex("181716"+ "00"+"0f0e0d0c0b0a09080706050403020100"); - @DataProvider public static Object[][] goodFrames() { return new Object[][]{ new Object[]{"ack without ecn", ACK_BASE, false}, @@ -226,7 +225,6 @@ public class QuicFramesDecoderTest { }; } - @DataProvider public static Object[][] badFrames() { return new Object[][]{ new Object[]{"ack without ecn, negative pn", ACK_NEG_BASE}, @@ -242,7 +240,8 @@ public class QuicFramesDecoderTest { }; } - @Test(dataProvider = "goodFrames") + @ParameterizedTest + @MethodSource("goodFrames") public void testReencode(String desc, byte[] frame, boolean bloated) throws Exception { // check if the goodFrames provider indeed contains good frames ByteBuffer buf = ByteBuffer.wrap(frame); @@ -250,16 +249,17 @@ public class QuicFramesDecoderTest { assertFalse(buf.hasRemaining(), buf.remaining() + " bytes left in buffer after parsing"); // some frames deliberately use suboptimal encoding, skip them if (bloated) return; - assertEquals(qf.size(), frame.length, "Frame size mismatch"); + assertEquals(frame.length, qf.size(), "Frame size mismatch"); buf.clear(); ByteBuffer encoded = ByteBuffer.allocate(frame.length); qf.encode(encoded); assertFalse(encoded.hasRemaining(), "Actual frame length mismatch"); encoded.flip(); - assertEquals(buf, encoded, "Encoded buffer is different from the original one"); + assertEquals(encoded, buf, "Encoded buffer is different from the original one"); } - @Test(dataProvider = "goodFrames") + @ParameterizedTest + @MethodSource("goodFrames") public void testToString(String desc, byte[] frame, boolean bloated) throws Exception { // check if the goodFrames provider indeed contains good frames ByteBuffer buf = ByteBuffer.wrap(frame); @@ -268,7 +268,8 @@ public class QuicFramesDecoderTest { System.out.println(qf); // should not throw } - @Test(dataProvider = "goodFrames") + @ParameterizedTest + @MethodSource("goodFrames") public void testTruncatedFrame(String desc, byte[] frame, boolean bloated) throws Exception { // check if parsing a truncated frame throws the right error ByteBuffer buf = ByteBuffer.wrap(frame); @@ -279,12 +280,13 @@ public class QuicFramesDecoderTest { var qf = QuicFrame.decode(buf); fail("Expected the decoder to throw on length " + i + ", got: " + qf); } catch (QuicTransportException e) { - assertEquals(e.getErrorCode(), QuicTransportErrors.FRAME_ENCODING_ERROR.code()); + assertEquals(QuicTransportErrors.FRAME_ENCODING_ERROR.code(), e.getErrorCode()); } } } - @Test(dataProvider = "badFrames") + @ParameterizedTest + @MethodSource("badFrames") public void testBadFrame(String desc, byte[] frame) throws Exception { // check if parsing a bad frame throws the right error ByteBuffer buf = ByteBuffer.wrap(frame); @@ -292,7 +294,7 @@ public class QuicFramesDecoderTest { var qf = QuicFrame.decode(buf); fail("Expected the decoder to throw, got: "+qf); } catch (QuicTransportException e) { - assertEquals(e.getErrorCode(), QuicTransportErrors.FRAME_ENCODING_ERROR.code()); + assertEquals(QuicTransportErrors.FRAME_ENCODING_ERROR.code(), e.getErrorCode()); } } } diff --git a/test/jdk/java/net/httpclient/quic/QuicRequestResponseTest.java b/test/jdk/java/net/httpclient/quic/QuicRequestResponseTest.java index 9d5c35f5414..208e284cefd 100644 --- a/test/jdk/java/net/httpclient/quic/QuicRequestResponseTest.java +++ b/test/jdk/java/net/httpclient/quic/QuicRequestResponseTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 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 @@ -43,9 +43,10 @@ import jdk.internal.net.http.quic.QuicClient; import jdk.internal.net.quic.QuicTLSContext; import jdk.internal.net.quic.QuicVersion; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.annotations.AfterClass; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; /* * @test @@ -54,18 +55,18 @@ import org.testng.annotations.Test; * jdk.httpclient.test.lib.quic.ClientConnection * jdk.httpclient.test.lib.common.TestUtil * jdk.test.lib.net.SimpleSSLContext - * @run testng/othervm -Djdk.internal.httpclient.debug=true QuicRequestResponseTest + * @run junit/othervm -Djdk.internal.httpclient.debug=true QuicRequestResponseTest */ public class QuicRequestResponseTest { - private QuicStandaloneServer server; + private static QuicStandaloneServer server; private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); - private ExecutorService executor; + private static ExecutorService executor; private static final byte[] HELLO_MSG = "Hello Quic".getBytes(StandardCharsets.UTF_8); - @BeforeClass - public void beforeClass() throws Exception { + @BeforeAll + public static void beforeClass() throws Exception { executor = Executors.newCachedThreadPool(); server = QuicStandaloneServer.newBuilder() .availableVersions(new QuicVersion[]{QuicVersion.QUIC_V1}) @@ -77,8 +78,8 @@ public class QuicRequestResponseTest { System.out.println("Server started at " + server.getAddress()); } - @AfterClass - public void afterClass() throws Exception { + @AfterAll + public static void afterClass() throws Exception { if (server != null) { System.out.println("Stopping server " + server.getAddress()); server.close(); diff --git a/test/jdk/java/net/httpclient/quic/VariableLengthTest.java b/test/jdk/java/net/httpclient/quic/VariableLengthTest.java index aec3e999812..cf05b91b18f 100644 --- a/test/jdk/java/net/httpclient/quic/VariableLengthTest.java +++ b/test/jdk/java/net/httpclient/quic/VariableLengthTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -22,32 +22,31 @@ */ import jdk.internal.net.http.quic.VariableLengthEncoder; import jtreg.SkippedException; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.io.IOException; import java.nio.ByteBuffer; import java.util.List; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertThrows; -import static org.testng.Assert.assertTrue; -import static org.testng.Assert.expectThrows; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertThrows; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; /* * @test * @library /test/lib * @modules java.net.http/jdk.internal.net.http.quic - * @run testng/othervm VariableLengthTest + * @run junit/othervm VariableLengthTest * @summary Tests to check quic/util methods encode/decodeVariableLength methods * work as expected. */ public class VariableLengthTest { static final Class IAE = IllegalArgumentException.class; - @DataProvider(name = "decode invariants") - public Object[][] decodeInvariants() { + public static Object[][] decodeInvariants() { return new Object[][] { { new byte[]{7}, 7, 1 }, // 00 @@ -59,8 +58,7 @@ public class VariableLengthTest { { new byte[]{-65}, -1, 0 }, }; } - @DataProvider(name = "encode invariants") - public Object[][] encodeInvariants() { + public static Object[][] encodeInvariants() { return new Object[][] { { 7, 1, null }, // 00 @@ -71,8 +69,7 @@ public class VariableLengthTest { { -1, 0, IAE }, }; } - @DataProvider(name = "prefix invariants") - public Object[][] prefixInvariants() { + public static Object[][] prefixInvariants() { return new Object[][] { { Long.MAX_VALUE, 0, IAE }, @@ -111,27 +108,30 @@ public class VariableLengthTest { }; } - @Test(dataProvider = "decode invariants") + @ParameterizedTest + @MethodSource("decodeInvariants") public void testDecode(byte[] values, long expectedLength, int expectedPosition) { ByteBuffer bb = ByteBuffer.wrap(values); var actualLength = VariableLengthEncoder.decode(bb); - assertEquals(actualLength, expectedLength); + assertEquals(expectedLength, actualLength); var actualPosition = bb.position(); - assertEquals(actualPosition, expectedPosition); + assertEquals(expectedPosition, actualPosition); } - @Test(dataProvider = "decode invariants") + @ParameterizedTest + @MethodSource("decodeInvariants") public void testPeek(byte[] values, long expectedLength, int expectedPosition) { ByteBuffer bb = ByteBuffer.wrap(values); var actualLength = VariableLengthEncoder.peekEncodedValue(bb, 0); - assertEquals(actualLength, expectedLength); + assertEquals(expectedLength, actualLength); var actualPosition = bb.position(); - assertEquals(actualPosition, 0); + assertEquals(0, actualPosition); } - @Test(dataProvider = "encode invariants") + @ParameterizedTest + @MethodSource("encodeInvariants") public void testEncode(long length, int capacity, Class exception) throws IOException { var actualBuffer = ByteBuffer.allocate(capacity); var expectedBuffer = getTestBuffer(length, capacity); @@ -140,46 +140,48 @@ public class VariableLengthTest { assertThrows(exception, () -> VariableLengthEncoder.encode(actualBuffer, length)); // if method fails ensure that position hasn't changed var actualPosition = actualBuffer.position(); - assertEquals(actualPosition, capacity); + assertEquals(capacity, actualPosition); } else { VariableLengthEncoder.encode(actualBuffer, length); var actualPosition = actualBuffer.position(); - assertEquals(actualPosition, capacity); + assertEquals(capacity, actualPosition); // check length prefix int firstByte = actualBuffer.get(0) & 0xFF; int lengthPrefix = firstByte & 0xC0; lengthPrefix >>= 6; int expectedValue = (int)(Math.log(capacity) / Math.log(2)); - assertEquals(lengthPrefix, expectedValue); + assertEquals(expectedValue, lengthPrefix); // check length encoded in buffer correctly int b = firstByte & 0x3F; actualBuffer.put(0, (byte) b); - assertEquals(actualBuffer.compareTo(expectedBuffer), 0); + assertEquals(0, actualBuffer.compareTo(expectedBuffer)); } } - @Test(dataProvider = "prefix invariants") + @ParameterizedTest + @MethodSource("prefixInvariants") public void testLengthPrefix(long length, int expectedPrefix, Class exception) { if (exception != null) { assertThrows(exception, () -> VariableLengthEncoder.getVariableLengthPrefix(length)); } else { var actualValue = VariableLengthEncoder.getVariableLengthPrefix(length); - assertEquals(actualValue, expectedPrefix); + assertEquals(expectedPrefix, actualValue); } } // Encode the given length and then decodes it and compares // the results, asserting various invariants along the way. - @Test(dataProvider = "prefix invariants") + @ParameterizedTest + @MethodSource("prefixInvariants") public void testEncodeDecode(long length, int expectedPrefix, Class exception) { if (exception != null) { assertThrows(exception, () -> VariableLengthEncoder.getEncodedSize(length)); assertThrows(exception, () -> VariableLengthEncoder.encode(ByteBuffer.allocate(16), length)); } else { var actualSize = VariableLengthEncoder.getEncodedSize(length); - assertEquals(actualSize, 1 << expectedPrefix); + assertEquals(1 << expectedPrefix, actualSize); assertTrue(actualSize > 0, "length is negative or zero: " + actualSize); assertTrue(actualSize < 9, "length is too big: " + actualSize); @@ -199,33 +201,33 @@ public class VariableLengthTest { longer.position(offset); // attempt to encode with a buffer too short - expectThrows(IAE, () -> VariableLengthEncoder.encode(shorter, length)); - assertEquals(shorter.position(), offset); - assertEquals(shorter.limit(), shorter.capacity()); + assertThrows(IAE, () -> VariableLengthEncoder.encode(shorter, length)); + assertEquals(offset, shorter.position()); + assertEquals(shorter.capacity(), shorter.limit()); - assertEquals(shorter.mismatch(shorterref), -1); - assertEquals(shorterref.mismatch(shorter), -1); + assertEquals(-1, shorter.mismatch(shorterref)); + assertEquals(-1, shorterref.mismatch(shorter)); // attempt to encode with a buffer that has the exact size var exactres = VariableLengthEncoder.encode(exact, length); - assertEquals(exactres, actualSize); - assertEquals(exact.position(), actualSize + offset); + assertEquals(actualSize, exactres); + assertEquals(actualSize + offset, exact.position()); assertFalse(exact.hasRemaining()); // attempt to encode with a buffer that has more bytes var longres = VariableLengthEncoder.encode(longer, length); - assertEquals(longres, actualSize); - assertEquals(longer.position(), offset + actualSize); - assertEquals(longer.limit(), longer.capacity()); - assertEquals(longer.remaining(), 10); + assertEquals(actualSize, longres); + assertEquals(offset + actualSize, longer.position()); + assertEquals(longer.capacity(), longer.limit()); + assertEquals(10, longer.remaining()); // compare encodings // first reset buffer positions for reading. exact.position(offset); longer.position(offset); - assertEquals(longer.mismatch(exact), actualSize); - assertEquals(exact.mismatch(longer), actualSize); + assertEquals(actualSize, longer.mismatch(exact)); + assertEquals(actualSize, exact.mismatch(longer)); // decode with a buffer that is missing the last // byte... @@ -233,21 +235,21 @@ public class VariableLengthTest { shortSlice.position(offset); shortSlice.limit(offset + actualSize -1); var actualLength = VariableLengthEncoder.decode(shortSlice); - assertEquals(actualLength, -1L); - assertEquals(shortSlice.position(), offset); - assertEquals(shortSlice.limit(), offset + actualSize - 1); + assertEquals(-1L, actualLength); + assertEquals(offset, shortSlice.position()); + assertEquals(offset + actualSize - 1, shortSlice.limit()); // decode with the exact buffer actualLength = VariableLengthEncoder.decode(exact); - assertEquals(actualLength, length); - assertEquals(exact.position(), offset + actualSize); + assertEquals(length, actualLength); + assertEquals(offset + actualSize, exact.position()); assertFalse(exact.hasRemaining()); // decode with the longer buffer actualLength = VariableLengthEncoder.decode(longer); - assertEquals(actualLength, length); - assertEquals(longer.position(), offset + actualSize); - assertEquals(longer.remaining(), 10); + assertEquals(length, actualLength); + assertEquals(offset + actualSize, longer.position()); + assertEquals(10, longer.remaining()); } } @@ -255,7 +257,8 @@ public class VariableLengthTest { // Encode the given length and then peeks it and compares // the results, asserting various invariants along the way. - @Test(dataProvider = "prefix invariants") + @ParameterizedTest + @MethodSource("prefixInvariants") public void testEncodePeek(long length, int expectedPrefix, Class exception) { if (exception != null) { assertThrows(exception, () -> VariableLengthEncoder.getEncodedSize(length)); @@ -264,7 +267,7 @@ public class VariableLengthTest { } var actualSize = VariableLengthEncoder.getEncodedSize(length); - assertEquals(actualSize, 1 << expectedPrefix); + assertEquals(1 << expectedPrefix, actualSize); assertTrue(actualSize > 0, "length is negative or zero: " + actualSize); assertTrue(actualSize < 9, "length is too big: " + actualSize); @@ -281,24 +284,24 @@ public class VariableLengthTest { // attempt to encode with a buffer that has the exact size var exactres = VariableLengthEncoder.encode(exact, length); - assertEquals(exactres, actualSize); - assertEquals(exact.position(), actualSize + offset); + assertEquals(actualSize, exactres); + assertEquals(actualSize + offset, exact.position()); assertFalse(exact.hasRemaining()); // attempt to encode with a buffer that has more bytes var longres = VariableLengthEncoder.encode(longer, length); - assertEquals(longres, actualSize); - assertEquals(longer.position(), offset + actualSize); - assertEquals(longer.limit(), longer.capacity()); - assertEquals(longer.remaining(), 10); + assertEquals(actualSize, longres); + assertEquals(offset + actualSize, longer.position()); + assertEquals(longer.capacity(), longer.limit()); + assertEquals(10, longer.remaining()); // compare encodings // first reset buffer positions for reading. exact.position(offset); longer.position(offset); - assertEquals(longer.mismatch(exact), actualSize); - assertEquals(exact.mismatch(longer), actualSize); + assertEquals(actualSize, longer.mismatch(exact)); + assertEquals(actualSize, exact.mismatch(longer)); exact.position(0); longer.position(0); exact.limit(exact.capacity()); @@ -311,25 +314,25 @@ public class VariableLengthTest { shortSlice.limit(offset + actualSize - 1); // need at least one byte to decode the size len... var expectedSize = shortSlice.limit() <= offset ? -1 : actualSize; - assertEquals(VariableLengthEncoder.peekEncodedValueSize(shortSlice, offset), expectedSize); + assertEquals(expectedSize, VariableLengthEncoder.peekEncodedValueSize(shortSlice, offset)); var actualLength = VariableLengthEncoder.peekEncodedValue(shortSlice, offset); - assertEquals(actualLength, -1L); - assertEquals(shortSlice.position(), 0); - assertEquals(shortSlice.limit(), offset + actualSize - 1); + assertEquals(-1L, actualLength); + assertEquals(0, shortSlice.position()); + assertEquals(offset + actualSize - 1, shortSlice.limit()); // decode with the exact buffer - assertEquals(VariableLengthEncoder.peekEncodedValueSize(exact, offset), actualSize); + assertEquals(actualSize, VariableLengthEncoder.peekEncodedValueSize(exact, offset)); actualLength = VariableLengthEncoder.peekEncodedValue(exact, offset); - assertEquals(actualLength, length); - assertEquals(exact.position(), 0); - assertEquals(exact.limit(), exact.capacity()); + assertEquals(length, actualLength); + assertEquals(0, exact.position()); + assertEquals(exact.capacity(), exact.limit()); // decode with the longer buffer - assertEquals(VariableLengthEncoder.peekEncodedValueSize(longer, offset), actualSize); + assertEquals(actualSize, VariableLengthEncoder.peekEncodedValueSize(longer, offset)); actualLength = VariableLengthEncoder.peekEncodedValue(longer, offset); - assertEquals(actualLength, length); - assertEquals(longer.position(), 0); - assertEquals(longer.limit(), longer.capacity()); + assertEquals(length, actualLength); + assertEquals(0, longer.position()); + assertEquals(longer.capacity(), longer.limit()); } } diff --git a/test/jdk/java/net/httpclient/quic/VersionNegotiationTest.java b/test/jdk/java/net/httpclient/quic/VersionNegotiationTest.java index 973477a63dc..bd5bbae0170 100644 --- a/test/jdk/java/net/httpclient/quic/VersionNegotiationTest.java +++ b/test/jdk/java/net/httpclient/quic/VersionNegotiationTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 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 @@ -41,13 +41,15 @@ import jdk.internal.net.http.quic.QuicClient; import jdk.internal.net.quic.QuicTLSContext; import jdk.internal.net.quic.QuicVersion; import jdk.test.lib.net.SimpleSSLContext; -import org.testng.annotations.AfterClass; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertNotNull; -import static org.testng.Assert.assertTrue; -import static org.testng.Assert.expectThrows; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Assertions; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertThrows; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; /* * @test @@ -57,19 +59,19 @@ import static org.testng.Assert.expectThrows; * jdk.httpclient.test.lib.common.TestUtil * jdk.httpclient.test.lib.quic.ClientConnection * jdk.test.lib.net.SimpleSSLContext - * @run testng/othervm -Djdk.internal.httpclient.debug=true VersionNegotiationTest + * @run junit/othervm -Djdk.internal.httpclient.debug=true VersionNegotiationTest */ public class VersionNegotiationTest { private static final SSLContext sslContext = SimpleSSLContext.findSSLContext(); private static ExecutorService executor; - @BeforeClass + @BeforeAll public static void beforeClass() throws Exception { executor = Executors.newCachedThreadPool(); } - @AfterClass + @AfterAll public static void afterClass() throws Exception { if (executor != null) executor.shutdown(); } @@ -96,7 +98,7 @@ public class VersionNegotiationTest { try (final QuicServer server = createAndStartServer(serverVersion)) { System.out.println("Attempting to connect " + client.getAvailableVersions() + " client to a " + server.getAvailableVersions() + " server"); - final IOException thrown = expectThrows(IOException.class, + final IOException thrown = Assertions.assertThrows(IOException.class, () -> ClientConnection.establishConnection(client, server.getAddress())); // a version negotiation failure (since it happens during a QUIC connection // handshake) gets thrown as a SSLHandshakeException @@ -105,7 +107,7 @@ public class VersionNegotiationTest { } System.out.println("Received (potentially expected) exception: " + sslhe); // additional check to make sure it was thrown for the right reason - assertEquals(sslhe.getMessage(), "QUIC connection establishment failed"); + assertEquals("QUIC connection establishment failed", sslhe.getMessage()); // underlying cause of SSLHandshakeException should be version negotiation failure final Throwable underlyingCause = sslhe.getCause(); assertNotNull(underlyingCause, "missing cause in SSLHandshakeException"); diff --git a/test/jdk/java/net/httpclient/quic/tls/PacketEncryptionTest.java b/test/jdk/java/net/httpclient/quic/tls/PacketEncryptionTest.java index ed1cbc08de0..d80e473696a 100644 --- a/test/jdk/java/net/httpclient/quic/tls/PacketEncryptionTest.java +++ b/test/jdk/java/net/httpclient/quic/tls/PacketEncryptionTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -25,7 +25,6 @@ import jdk.internal.net.quic.QuicKeyUnavailableException; import jdk.internal.net.quic.QuicTLSContext; import jdk.internal.net.quic.QuicTLSEngine; import jdk.internal.net.quic.QuicTransportException; -import org.testng.annotations.Test; import sun.security.ssl.QuicTLSEngineImpl; import sun.security.ssl.QuicTLSEngineImplAccessor; @@ -40,8 +39,11 @@ import java.util.HexFormat; import java.util.function.IntFunction; import static jdk.internal.net.quic.QuicVersion.QUIC_V1; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.fail; + +import org.junit.jupiter.api.Assertions; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; +import org.junit.jupiter.api.Test; /** * @test @@ -50,7 +52,7 @@ import static org.testng.Assert.fail; * java.base/jdk.internal.net.quic * @build java.base/sun.security.ssl.QuicTLSEngineImplAccessor * @summary known-answer test for packet encryption and decryption - * @run testng/othervm PacketEncryptionTest + * @run junit/othervm PacketEncryptionTest */ public class PacketEncryptionTest { @@ -183,7 +185,7 @@ public class PacketEncryptionTest { clientEngine.encryptPacket(QuicTLSEngine.KeySpace.INITIAL, INITIAL_C_PN, new FixedHeaderContent(header), payload, packet); protect(QuicTLSEngine.KeySpace.INITIAL, packet, INITIAL_C_PN_OFFSET, INITIAL_C_PAYLOAD_OFFSET - INITIAL_C_PN_OFFSET, clientEngine, 0x0f); - assertEquals(HexFormat.of().formatHex(packet.array()), ENCRYPTED_C_PAYLOAD); + assertEquals(ENCRYPTED_C_PAYLOAD, HexFormat.of().formatHex(packet.array())); } @Test @@ -202,26 +204,25 @@ public class PacketEncryptionTest { String expectedContents = INITIAL_C_HEADER + INITIAL_C_PAYLOAD; - assertEquals(HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length()), expectedContents); + assertEquals(expectedContents, HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length())); } - @Test(expectedExceptions = AEADBadTagException.class) - public void testDecryptClientInitialPacketBadTag() throws Exception { - QuicTLSEngine serverEngine = getQuicV1Engine(SSLContext.getDefault(), false); - ByteBuffer dcid = ByteBuffer.wrap(HexFormat.of().parseHex(INITIAL_DCID)); - serverEngine.deriveInitialKeys(QUIC_V1, dcid); - - ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(ENCRYPTED_C_PAYLOAD)); - unprotect(QuicTLSEngine.KeySpace.INITIAL, packet, INITIAL_C_PN_OFFSET, INITIAL_C_PAYLOAD_OFFSET - INITIAL_C_PN_OFFSET, serverEngine, 0x0f); - ByteBuffer src = packet.asReadOnlyBuffer(); - packet.position(INITIAL_C_PAYLOAD_OFFSET); - - // change one byte of AEAD tag - packet.put(packet.limit() - 1, (byte)0); - - serverEngine.decryptPacket(QuicTLSEngine.KeySpace.INITIAL, INITIAL_C_PN, -1, - src, INITIAL_C_PAYLOAD_OFFSET, packet); - fail("Decryption should have failed"); + @Test + public void testDecryptClientInitialPacketBadTag() { + Assertions.assertThrows(AEADBadTagException.class, () -> { + QuicTLSEngine serverEngine = getQuicV1Engine(SSLContext.getDefault(), false); + ByteBuffer dcid = ByteBuffer.wrap(HexFormat.of().parseHex(INITIAL_DCID)); + serverEngine.deriveInitialKeys(QUIC_V1, dcid); + ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(ENCRYPTED_C_PAYLOAD)); + unprotect(QuicTLSEngine.KeySpace.INITIAL, packet, INITIAL_C_PN_OFFSET, INITIAL_C_PAYLOAD_OFFSET - INITIAL_C_PN_OFFSET, serverEngine, 0x0f); + ByteBuffer src = packet.asReadOnlyBuffer(); + packet.position(INITIAL_C_PAYLOAD_OFFSET); + // change one byte of AEAD tag + packet.put(packet.limit() - 1, (byte)0); + serverEngine.decryptPacket(QuicTLSEngine.KeySpace.INITIAL, INITIAL_C_PN, -1, + src, INITIAL_C_PAYLOAD_OFFSET, packet); + fail("Decryption should have failed"); + }); } @Test @@ -242,7 +243,7 @@ public class PacketEncryptionTest { serverEngine.encryptPacket(QuicTLSEngine.KeySpace.INITIAL, INITIAL_S_PN, new FixedHeaderContent(header), payload, packet); protect(QuicTLSEngine.KeySpace.INITIAL, packet, INITIAL_S_PN_OFFSET, INITIAL_S_PAYLOAD_OFFSET - INITIAL_S_PN_OFFSET, serverEngine, 0x0f); - assertEquals(HexFormat.of().formatHex(packet.array()), ENCRYPTED_S_PAYLOAD); + assertEquals(ENCRYPTED_S_PAYLOAD, HexFormat.of().formatHex(packet.array())); } @Test @@ -261,7 +262,7 @@ public class PacketEncryptionTest { String expectedContents = INITIAL_S_HEADER + INITIAL_S_PAYLOAD; - assertEquals(HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length()), expectedContents); + assertEquals(expectedContents, HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length())); } @Test @@ -302,7 +303,7 @@ public class PacketEncryptionTest { clientEngine.signRetryPacket(QUIC_V1, dcid, src, packet); - assertEquals(HexFormat.of().formatHex(packet.array()), SIGNED_RETRY); + assertEquals(SIGNED_RETRY, HexFormat.of().formatHex(packet.array())); } @Test @@ -315,17 +316,17 @@ public class PacketEncryptionTest { clientEngine.verifyRetryPacket(QUIC_V1, dcid, packet); } - @Test(expectedExceptions = AEADBadTagException.class) - public void testVerifyBadRetry() throws NoSuchAlgorithmException, AEADBadTagException, QuicTransportException { - QuicTLSEngine clientEngine = getQuicV1Engine(SSLContext.getDefault(), true); - ByteBuffer dcid = ByteBuffer.wrap(HexFormat.of().parseHex(INITIAL_DCID)); - - ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(SIGNED_RETRY)); - - // change one byte of AEAD tag - packet.put(packet.limit() - 1, (byte)0); - clientEngine.verifyRetryPacket(QUIC_V1, dcid, packet); - fail("Verification should have failed"); + @Test + public void testVerifyBadRetry() { + Assertions.assertThrows(AEADBadTagException.class, () -> { + QuicTLSEngine clientEngine = getQuicV1Engine(SSLContext.getDefault(), true); + ByteBuffer dcid = ByteBuffer.wrap(HexFormat.of().parseHex(INITIAL_DCID)); + ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(SIGNED_RETRY)); + // change one byte of AEAD tag + packet.put(packet.limit() - 1, (byte)0); + clientEngine.verifyRetryPacket(QUIC_V1, dcid, packet); + fail("Verification should have failed"); + }); } @Test @@ -346,7 +347,7 @@ public class PacketEncryptionTest { clientEngine.encryptPacket(QuicTLSEngine.KeySpace.ONE_RTT, ONERTT_PN , new FixedHeaderContent(header), payload, packet); protect(QuicTLSEngine.KeySpace.ONE_RTT, packet, ONERTT_PN_OFFSET, ONERTT_PAYLOAD_OFFSET - ONERTT_PN_OFFSET, clientEngine, 0x1f); - assertEquals(HexFormat.of().formatHex(packet.array()), ENCRYPTED_ONERTT_PAYLOAD); + assertEquals(ENCRYPTED_ONERTT_PAYLOAD, HexFormat.of().formatHex(packet.array())); } @Test @@ -367,7 +368,7 @@ public class PacketEncryptionTest { String expectedContents = ONERTT_HEADER + ONERTT_PAYLOAD; - assertEquals(HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length()), expectedContents); + assertEquals(expectedContents, HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length())); } @Test @@ -397,25 +398,24 @@ public class PacketEncryptionTest { serverEngine.decryptPacket(QuicTLSEngine.KeySpace.ONE_RTT, ONERTT_PN, keyPhase, src, ONERTT_PAYLOAD_OFFSET, packet); } - @Test(expectedExceptions = AEADBadTagException.class) - public void testDecryptChaChaBadTag() throws Exception { - QuicTLSEngineImpl serverEngine = (QuicTLSEngineImpl) getQuicV1Engine(SSLContext.getDefault(), false); - // mark the TLS handshake as FINISHED - QuicTLSEngineImplAccessor.completeHandshake(serverEngine); - SecretKey key = new SecretKeySpec(HexFormat.of().parseHex(ONERTT_SECRET), 0, 32, "ChaCha20-Poly1305"); - QuicTLSEngineImplAccessor.testDeriveOneRTTKeys(QUIC_V1, serverEngine, key, key, "TLS_CHACHA20_POLY1305_SHA256", false); - - ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(ENCRYPTED_ONERTT_PAYLOAD)); - unprotect(QuicTLSEngine.KeySpace.ONE_RTT, packet, ONERTT_PN_OFFSET, ONERTT_PAYLOAD_OFFSET - ONERTT_PN_OFFSET, serverEngine, 0x1f); - ByteBuffer src = packet.asReadOnlyBuffer(); - packet.position(ONERTT_PAYLOAD_OFFSET); - - // change one byte of AEAD tag - packet.put(packet.limit() - 1, (byte)0); - - serverEngine.decryptPacket(QuicTLSEngine.KeySpace.ONE_RTT, ONERTT_PN, (byte) 0, - src, ONERTT_PAYLOAD_OFFSET, packet); - fail("Decryption should have failed"); + @Test + public void testDecryptChaChaBadTag() { + Assertions.assertThrows(AEADBadTagException.class, () -> { + QuicTLSEngineImpl serverEngine = (QuicTLSEngineImpl) getQuicV1Engine(SSLContext.getDefault(), false); + // mark the TLS handshake as FINISHED + QuicTLSEngineImplAccessor.completeHandshake(serverEngine); + SecretKey key = new SecretKeySpec(HexFormat.of().parseHex(ONERTT_SECRET), 0, 32, "ChaCha20-Poly1305"); + QuicTLSEngineImplAccessor.testDeriveOneRTTKeys(QUIC_V1, serverEngine, key, key, "TLS_CHACHA20_POLY1305_SHA256", false); + ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(ENCRYPTED_ONERTT_PAYLOAD)); + unprotect(QuicTLSEngine.KeySpace.ONE_RTT, packet, ONERTT_PN_OFFSET, ONERTT_PAYLOAD_OFFSET - ONERTT_PN_OFFSET, serverEngine, 0x1f); + ByteBuffer src = packet.asReadOnlyBuffer(); + packet.position(ONERTT_PAYLOAD_OFFSET); + // change one byte of AEAD tag + packet.put(packet.limit() - 1, (byte)0); + serverEngine.decryptPacket(QuicTLSEngine.KeySpace.ONE_RTT, ONERTT_PN, (byte) 0, + src, ONERTT_PAYLOAD_OFFSET, packet); + fail("Decryption should have failed"); + }); } diff --git a/test/jdk/java/net/httpclient/quic/tls/Quicv2PacketEncryptionTest.java b/test/jdk/java/net/httpclient/quic/tls/Quicv2PacketEncryptionTest.java index a506495ed5e..285fa2e4cd4 100644 --- a/test/jdk/java/net/httpclient/quic/tls/Quicv2PacketEncryptionTest.java +++ b/test/jdk/java/net/httpclient/quic/tls/Quicv2PacketEncryptionTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -25,7 +25,6 @@ import jdk.internal.net.quic.QuicKeyUnavailableException; import jdk.internal.net.quic.QuicTLSContext; import jdk.internal.net.quic.QuicTLSEngine; import jdk.internal.net.quic.QuicTransportException; -import org.testng.annotations.Test; import sun.security.ssl.QuicTLSEngineImpl; import sun.security.ssl.QuicTLSEngineImplAccessor; @@ -40,8 +39,11 @@ import java.util.HexFormat; import java.util.function.IntFunction; import static jdk.internal.net.quic.QuicVersion.QUIC_V2; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.fail; + +import org.junit.jupiter.api.Assertions; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; +import org.junit.jupiter.api.Test; /** * @test @@ -50,7 +52,7 @@ import static org.testng.Assert.fail; * java.base/jdk.internal.net.quic * @build java.base/sun.security.ssl.QuicTLSEngineImplAccessor * @summary known-answer test for packet encryption and decryption with Quic v2 - * @run testng/othervm Quicv2PacketEncryptionTest + * @run junit/othervm Quicv2PacketEncryptionTest */ public class Quicv2PacketEncryptionTest { @@ -182,7 +184,7 @@ public class Quicv2PacketEncryptionTest { clientEngine.encryptPacket(QuicTLSEngine.KeySpace.INITIAL, INITIAL_C_PN, new FixedHeaderContent(header), payload, packet); protect(QuicTLSEngine.KeySpace.INITIAL, packet, INITIAL_C_PN_OFFSET, INITIAL_C_PAYLOAD_OFFSET - INITIAL_C_PN_OFFSET, clientEngine, 0x0f); - assertEquals(HexFormat.of().formatHex(packet.array()), ENCRYPTED_C_PAYLOAD); + assertEquals(ENCRYPTED_C_PAYLOAD, HexFormat.of().formatHex(packet.array())); } @Test @@ -200,25 +202,24 @@ public class Quicv2PacketEncryptionTest { String expectedContents = INITIAL_C_HEADER + INITIAL_C_PAYLOAD; - assertEquals(HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length()), expectedContents); + assertEquals(expectedContents, HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length())); } - @Test(expectedExceptions = AEADBadTagException.class) + @Test public void testDecryptClientInitialPacketBadTag() throws Exception { - QuicTLSEngine serverEngine = getQuicV2Engine(SSLContext.getDefault(), false); - ByteBuffer dcid = ByteBuffer.wrap(HexFormat.of().parseHex(INITIAL_DCID)); - serverEngine.deriveInitialKeys(QUIC_V2, dcid); - - ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(ENCRYPTED_C_PAYLOAD)); - unprotect(QuicTLSEngine.KeySpace.INITIAL, packet, INITIAL_C_PN_OFFSET, INITIAL_C_PAYLOAD_OFFSET - INITIAL_C_PN_OFFSET, serverEngine, 0x0f); - ByteBuffer src = packet.asReadOnlyBuffer(); - packet.position(INITIAL_C_PAYLOAD_OFFSET); - - // change one byte of AEAD tag - packet.put(packet.limit() - 1, (byte)0); - - serverEngine.decryptPacket(QuicTLSEngine.KeySpace.INITIAL, INITIAL_C_PN, -1, src, INITIAL_C_PAYLOAD_OFFSET, packet); - fail("Decryption should have failed"); + Assertions.assertThrows(AEADBadTagException.class, () -> { + QuicTLSEngine serverEngine = getQuicV2Engine(SSLContext.getDefault(), false); + ByteBuffer dcid = ByteBuffer.wrap(HexFormat.of().parseHex(INITIAL_DCID)); + serverEngine.deriveInitialKeys(QUIC_V2, dcid); + ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(ENCRYPTED_C_PAYLOAD)); + unprotect(QuicTLSEngine.KeySpace.INITIAL, packet, INITIAL_C_PN_OFFSET, INITIAL_C_PAYLOAD_OFFSET - INITIAL_C_PN_OFFSET, serverEngine, 0x0f); + ByteBuffer src = packet.asReadOnlyBuffer(); + packet.position(INITIAL_C_PAYLOAD_OFFSET); + // change one byte of AEAD tag + packet.put(packet.limit() - 1, (byte)0); + serverEngine.decryptPacket(QuicTLSEngine.KeySpace.INITIAL, INITIAL_C_PN, -1, src, INITIAL_C_PAYLOAD_OFFSET, packet); + fail("Decryption should have failed"); + }); } @Test @@ -239,7 +240,7 @@ public class Quicv2PacketEncryptionTest { serverEngine.encryptPacket(QuicTLSEngine.KeySpace.INITIAL, INITIAL_S_PN, new FixedHeaderContent(header), payload, packet); protect(QuicTLSEngine.KeySpace.INITIAL, packet, INITIAL_S_PN_OFFSET, INITIAL_S_PAYLOAD_OFFSET - INITIAL_S_PN_OFFSET, serverEngine, 0x0f); - assertEquals(HexFormat.of().formatHex(packet.array()), ENCRYPTED_S_PAYLOAD); + assertEquals(ENCRYPTED_S_PAYLOAD, HexFormat.of().formatHex(packet.array())); } @Test @@ -257,7 +258,7 @@ public class Quicv2PacketEncryptionTest { String expectedContents = INITIAL_S_HEADER + INITIAL_S_PAYLOAD; - assertEquals(HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length()), expectedContents); + assertEquals(expectedContents, HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length())); } @Test @@ -298,7 +299,7 @@ public class Quicv2PacketEncryptionTest { clientEngine.signRetryPacket(QUIC_V2, dcid, src, packet); - assertEquals(HexFormat.of().formatHex(packet.array()), SIGNED_RETRY); + assertEquals(SIGNED_RETRY, HexFormat.of().formatHex(packet.array())); } @Test @@ -311,17 +312,17 @@ public class Quicv2PacketEncryptionTest { clientEngine.verifyRetryPacket(QUIC_V2, dcid, packet); } - @Test(expectedExceptions = AEADBadTagException.class) + @Test public void testVerifyBadRetry() throws NoSuchAlgorithmException, AEADBadTagException, QuicTransportException { - QuicTLSEngine clientEngine = getQuicV2Engine(SSLContext.getDefault(), true); - ByteBuffer dcid = ByteBuffer.wrap(HexFormat.of().parseHex(INITIAL_DCID)); - - ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(SIGNED_RETRY)); - - // change one byte of AEAD tag - packet.put(packet.limit() - 1, (byte)0); - clientEngine.verifyRetryPacket(QUIC_V2, dcid, packet); - fail("Verification should have failed"); + Assertions.assertThrows(AEADBadTagException.class, () -> { + QuicTLSEngine clientEngine = getQuicV2Engine(SSLContext.getDefault(), true); + ByteBuffer dcid = ByteBuffer.wrap(HexFormat.of().parseHex(INITIAL_DCID)); + ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(SIGNED_RETRY)); + // change one byte of AEAD tag + packet.put(packet.limit() - 1, (byte)0); + clientEngine.verifyRetryPacket(QUIC_V2, dcid, packet); + fail("Verification should have failed"); + }); } @Test @@ -342,7 +343,7 @@ public class Quicv2PacketEncryptionTest { clientEngine.encryptPacket(QuicTLSEngine.KeySpace.ONE_RTT, ONERTT_PN , new FixedHeaderContent(header), payload, packet); protect(QuicTLSEngine.KeySpace.ONE_RTT, packet, ONERTT_PN_OFFSET, ONERTT_PAYLOAD_OFFSET - ONERTT_PN_OFFSET, clientEngine, 0x1f); - assertEquals(HexFormat.of().formatHex(packet.array()), ENCRYPTED_ONERTT_PAYLOAD); + assertEquals(ENCRYPTED_ONERTT_PAYLOAD, HexFormat.of().formatHex(packet.array())); } @Test @@ -362,7 +363,7 @@ public class Quicv2PacketEncryptionTest { String expectedContents = ONERTT_HEADER + ONERTT_PAYLOAD; - assertEquals(HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length()), expectedContents); + assertEquals(expectedContents, HexFormat.of().formatHex(packet.array()).substring(0, expectedContents.length())); } @Test @@ -392,24 +393,23 @@ public class Quicv2PacketEncryptionTest { serverEngine.decryptPacket(QuicTLSEngine.KeySpace.ONE_RTT, ONERTT_PN, keyphase, src, ONERTT_PAYLOAD_OFFSET, packet); } - @Test(expectedExceptions = AEADBadTagException.class) + @Test public void testDecryptChaChaBadTag() throws Exception { - QuicTLSEngineImpl serverEngine = (QuicTLSEngineImpl) getQuicV2Engine(SSLContext.getDefault(), false); - // mark the TLS handshake as FINISHED - QuicTLSEngineImplAccessor.completeHandshake(serverEngine); - SecretKey key = new SecretKeySpec(HexFormat.of().parseHex(ONERTT_SECRET), 0, 32, "ChaCha20-Poly1305"); - QuicTLSEngineImplAccessor.testDeriveOneRTTKeys(QUIC_V2, serverEngine, key, key, "TLS_CHACHA20_POLY1305_SHA256", false); - - ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(ENCRYPTED_ONERTT_PAYLOAD)); - unprotect(QuicTLSEngine.KeySpace.ONE_RTT, packet, ONERTT_PN_OFFSET, ONERTT_PAYLOAD_OFFSET - ONERTT_PN_OFFSET, serverEngine, 0x1f); - ByteBuffer src = packet.asReadOnlyBuffer(); - packet.position(ONERTT_PAYLOAD_OFFSET); - - // change one byte of AEAD tag - packet.put(packet.limit() - 1, (byte)0); - - serverEngine.decryptPacket(QuicTLSEngine.KeySpace.ONE_RTT, ONERTT_PN, 0, src, ONERTT_PAYLOAD_OFFSET, packet); - fail("Decryption should have failed"); + Assertions.assertThrows(AEADBadTagException.class, () -> { + QuicTLSEngineImpl serverEngine = (QuicTLSEngineImpl) getQuicV2Engine(SSLContext.getDefault(), false); + // mark the TLS handshake as FINISHED + QuicTLSEngineImplAccessor.completeHandshake(serverEngine); + SecretKey key = new SecretKeySpec(HexFormat.of().parseHex(ONERTT_SECRET), 0, 32, "ChaCha20-Poly1305"); + QuicTLSEngineImplAccessor.testDeriveOneRTTKeys(QUIC_V2, serverEngine, key, key, "TLS_CHACHA20_POLY1305_SHA256", false); + ByteBuffer packet = ByteBuffer.wrap(HexFormat.of().parseHex(ENCRYPTED_ONERTT_PAYLOAD)); + unprotect(QuicTLSEngine.KeySpace.ONE_RTT, packet, ONERTT_PN_OFFSET, ONERTT_PAYLOAD_OFFSET - ONERTT_PN_OFFSET, serverEngine, 0x1f); + ByteBuffer src = packet.asReadOnlyBuffer(); + packet.position(ONERTT_PAYLOAD_OFFSET); + // change one byte of AEAD tag + packet.put(packet.limit() - 1, (byte)0); + serverEngine.decryptPacket(QuicTLSEngine.KeySpace.ONE_RTT, ONERTT_PN, 0, src, ONERTT_PAYLOAD_OFFSET, packet); + fail("Decryption should have failed"); + }); } From bc971b51b9a27b8b026f6fbbe1b0d49e7b702a6c Mon Sep 17 00:00:00 2001 From: Markus KARG Date: Sat, 21 Feb 2026 02:16:01 +0000 Subject: [PATCH 32/63] 8377388: Replacing "new StringReader(String)" by "Reader.of(CharSequence);" in Scanner Reviewed-by: jpai, rriggs, bpb --- src/java.base/share/classes/java/util/Scanner.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/java.base/share/classes/java/util/Scanner.java b/src/java.base/share/classes/java/util/Scanner.java index 3e27325aa0d..948fa595114 100644 --- a/src/java.base/share/classes/java/util/Scanner.java +++ b/src/java.base/share/classes/java/util/Scanner.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 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 @@ -32,7 +32,7 @@ import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; -import java.io.StringReader; +import java.io.Reader; import java.math.BigDecimal; import java.math.BigInteger; import java.nio.CharBuffer; @@ -800,7 +800,7 @@ public final class Scanner implements Iterator, Closeable { * @param source A string to scan */ public Scanner(String source) { - this(new StringReader(source), WHITESPACE_PATTERN); + this(Reader.of(source), WHITESPACE_PATTERN); } /** From 103a08378d423ce7345159a010fc79ed7ca8fbeb Mon Sep 17 00:00:00 2001 From: Ioi Lam Date: Sat, 21 Feb 2026 02:52:17 +0000 Subject: [PATCH 33/63] 8378298: Remove obsolete CDS string tests Reviewed-by: matsaave, kvn --- src/hotspot/share/prims/whitebox.cpp | 17 ---- .../runtime/cds/DumpSymbolAndStringTable.java | 60 ++----------- .../jtreg/runtime/cds/SharedStrings.java | 70 --------------- .../jtreg/runtime/cds/SharedStringsWb.java | 54 ----------- .../MirrorWithReferenceFieldsApp.java | 89 ------------------- .../MirrorWithReferenceFieldsTest.java | 63 ------------- .../appcds/cacheObject/RedefineClassApp.java | 7 +- .../cds/appcds/sharedStrings/ExerciseGC.java | 47 ---------- .../appcds/sharedStrings/HelloStringGC.java | 69 -------------- .../appcds/sharedStrings/HelloStringPlus.java | 76 ---------------- .../sharedStrings/InternSharedString.java | 59 ------------ .../sharedStrings/InternStringTest.java | 85 ------------------ .../sharedStrings/SharedStringsBasicPlus.java | 52 ----------- .../sharedStrings/SharedStringsUtils.java | 4 +- .../appcds/sharedStrings/SharedStringsWb.java | 42 --------- .../sharedStrings/SharedStringsWbTest.java | 55 ------------ test/lib/jdk/test/whitebox/WhiteBox.java | 4 +- 17 files changed, 12 insertions(+), 841 deletions(-) delete mode 100644 test/hotspot/jtreg/runtime/cds/SharedStrings.java delete mode 100644 test/hotspot/jtreg/runtime/cds/SharedStringsWb.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsApp.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsTest.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/ExerciseGC.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/HelloStringGC.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/HelloStringPlus.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/InternSharedString.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/InternStringTest.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsBasicPlus.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsWb.java delete mode 100644 test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsWbTest.java diff --git a/src/hotspot/share/prims/whitebox.cpp b/src/hotspot/share/prims/whitebox.cpp index 35e0b83d25f..1a440584fe1 100644 --- a/src/hotspot/share/prims/whitebox.cpp +++ b/src/hotspot/share/prims/whitebox.cpp @@ -2215,25 +2215,10 @@ WB_ENTRY(jboolean, WB_CDSMemoryMappingFailed(JNIEnv* env, jobject wb)) return FileMapInfo::memory_mapping_failed(); WB_END -WB_ENTRY(jboolean, WB_IsSharedInternedString(JNIEnv* env, jobject wb, jobject str)) - if (!HeapShared::is_loading_mapping_mode()) { - return false; - } - ResourceMark rm(THREAD); - oop str_oop = JNIHandles::resolve(str); - int length; - jchar* chars = java_lang_String::as_unicode_string(str_oop, length, CHECK_(false)); - return StringTable::lookup_shared(chars, length) == str_oop; -WB_END - WB_ENTRY(jboolean, WB_IsSharedClass(JNIEnv* env, jobject wb, jclass clazz)) return (jboolean)AOTMetaspace::in_aot_cache(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); WB_END -WB_ENTRY(jboolean, WB_AreSharedStringsMapped(JNIEnv* env)) - return AOTMappedHeapLoader::is_mapped(); -WB_END - WB_ENTRY(void, WB_LinkClass(JNIEnv* env, jobject wb, jclass clazz)) Klass *k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)); if (!k->is_instance_klass()) { @@ -3058,9 +3043,7 @@ static JNINativeMethod methods[] = { {CC"getCDSGenericHeaderMinVersion", CC"()I", (void*)&WB_GetCDSGenericHeaderMinVersion}, {CC"getCurrentCDSVersion", CC"()I", (void*)&WB_GetCDSCurrentVersion}, {CC"isSharingEnabled", CC"()Z", (void*)&WB_IsSharingEnabled}, - {CC"isSharedInternedString", CC"(Ljava/lang/String;)Z", (void*)&WB_IsSharedInternedString }, {CC"isSharedClass", CC"(Ljava/lang/Class;)Z", (void*)&WB_IsSharedClass }, - {CC"areSharedStringsMapped", CC"()Z", (void*)&WB_AreSharedStringsMapped }, {CC"linkClass", CC"(Ljava/lang/Class;)V", (void*)&WB_LinkClass}, {CC"areOpenArchiveHeapObjectsMapped", CC"()Z", (void*)&WB_AreOpenArchiveHeapObjectsMapped}, {CC"isCDSIncluded", CC"()Z", (void*)&WB_IsCDSIncluded }, diff --git a/test/hotspot/jtreg/runtime/cds/DumpSymbolAndStringTable.java b/test/hotspot/jtreg/runtime/cds/DumpSymbolAndStringTable.java index 735d5a3070b..f606f242cf6 100644 --- a/test/hotspot/jtreg/runtime/cds/DumpSymbolAndStringTable.java +++ b/test/hotspot/jtreg/runtime/cds/DumpSymbolAndStringTable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 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 @@ -24,70 +24,26 @@ /* * @test * @bug 8059510 8213445 - * @summary Test jcmd VM.symboltable, VM.stringtable and VM.systemdictionary options + * @summary Test jcmd VM.symboltable and VM.stringtable * @library /test/lib - * @build jdk.test.whitebox.WhiteBox - * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions - * -XX:+WhiteBoxAPI DumpSymbolAndStringTable + * @run main/othervm DumpSymbolAndStringTable */ import jdk.test.lib.cds.CDSTestUtils; import jdk.test.lib.dcmd.PidJcmdExecutor; import jdk.test.lib.process.OutputAnalyzer; -import jdk.test.whitebox.WhiteBox; public class DumpSymbolAndStringTable { - public static void main(String[] args) throws Exception { - WhiteBox wb = WhiteBox.getWhiteBox(); - boolean sharingEnabled = wb.isSharingEnabled(); + public static final String s = "MY_INTERNED_STRING"; + public static void main(String[] args) throws Exception { ProcessBuilder pb = new ProcessBuilder(); + pb.command(new PidJcmdExecutor().getCommandLine("VM.symboltable", "-verbose")); OutputAnalyzer output = CDSTestUtils.executeAndLog(pb, "jcmd-symboltable"); - final String sharedSymbolsHeader = "Shared symbols:\n"; - try { - output.shouldContain("24 2: DumpSymbolAndStringTable\n"); - if (sharingEnabled) { - output.shouldContain(sharedSymbolsHeader); - output.shouldContain("17 65535: java.lang.runtime\n"); - } - } catch (RuntimeException e) { - output.shouldContain("Unknown diagnostic command"); - } + output.shouldContain("18 1: MY_INTERNED_STRING\n"); // This symbol should have been interned pb.command(new PidJcmdExecutor().getCommandLine("VM.stringtable", "-verbose")); output = CDSTestUtils.executeAndLog(pb, "jcmd-stringtable"); - final String sharedStringsHeader = "Shared strings:\n"; - try { - output.shouldContain("24: DumpSymbolAndStringTable\n"); - if (sharingEnabled && wb.canWriteJavaHeapArchive()) { - output.shouldContain(sharedStringsHeader); - if (!wb.isSharedInternedString("MILLI_OF_SECOND")) { - throw new RuntimeException("'MILLI_OF_SECOND' should be a shared string"); - } - } - } catch (RuntimeException e) { - output.shouldContain("Unknown diagnostic command"); - } - - pb.command(new PidJcmdExecutor().getCommandLine("VM.systemdictionary")); - output = CDSTestUtils.executeAndLog(pb, "jcmd-systemdictionary"); - try { - output.shouldContain("System Dictionary for 'app' class loader statistics:"); - output.shouldContain("Number of buckets"); - output.shouldContain("Number of entries"); - output.shouldContain("Maximum bucket size"); - } catch (RuntimeException e) { - output.shouldContain("Unknown diagnostic command"); - } - - pb.command(new PidJcmdExecutor().getCommandLine("VM.systemdictionary", "-verbose")); - output = CDSTestUtils.executeAndLog(pb, "jcmd-systemdictionary"); - try { - output.shouldContain("Dictionary for loader data: 0x"); - output.shouldContain("^java.lang.String"); - } catch (RuntimeException e) { - output.shouldContain("Unknown diagnostic command"); - } + output.shouldContain("18: MY_INTERNED_STRING\n"); // This string should have been interned } } diff --git a/test/hotspot/jtreg/runtime/cds/SharedStrings.java b/test/hotspot/jtreg/runtime/cds/SharedStrings.java deleted file mode 100644 index db0bc3264b2..00000000000 --- a/test/hotspot/jtreg/runtime/cds/SharedStrings.java +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2015, 2025, 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 - * @summary Check to make sure that shared strings in the bootstrap CDS archive - * are actually shared - * @requires vm.cds.write.mapped.java.heap - * @requires vm.flagless - * @library /test/lib - * @build SharedStringsWb jdk.test.whitebox.WhiteBox - * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar whitebox.jar jdk.test.whitebox.WhiteBox - * @run driver SharedStrings - */ - -import jdk.test.lib.cds.CDSTestUtils; -import jdk.test.lib.process.ProcessTools; -import jdk.test.lib.process.OutputAnalyzer; -import jdk.test.lib.helpers.ClassFileInstaller; - -public class SharedStrings { - public static void main(String[] args) throws Exception { - // Note: This is a basic sanity test for Shared Strings feature. - // This also serves as a reference on how to use this feature, - // hence the command lines are spelled out instead of using the - // test utils methods. - ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder( - "-XX:+UnlockDiagnosticVMOptions", - "-XX:SharedArchiveFile=./SharedStrings.jsa", - "-Xlog:cds,aot+hashtables", - // Needed for bootclasspath match, for CDS to work with WhiteBox API - "-Xbootclasspath/a:" + ClassFileInstaller.getJarPath("whitebox.jar"), - "-Xshare:dump"); - - OutputAnalyzer out = CDSTestUtils.executeAndLog(pb, "dump"); - CDSTestUtils.checkDump(out, "Shared string table stats"); - - - pb = ProcessTools.createLimitedTestJavaProcessBuilder( - "-XX:+UnlockDiagnosticVMOptions", - "-XX:SharedArchiveFile=./SharedStrings.jsa", - // needed for access to white box test API - "-Xbootclasspath/a:" + ClassFileInstaller.getJarPath("whitebox.jar"), - "-XX:+UnlockDiagnosticVMOptions", "-XX:+WhiteBoxAPI", - "-Xshare:on", "-showversion", "SharedStringsWb"); - - out = CDSTestUtils.executeAndLog(pb, "exec"); - CDSTestUtils.checkExec(out); - } -} diff --git a/test/hotspot/jtreg/runtime/cds/SharedStringsWb.java b/test/hotspot/jtreg/runtime/cds/SharedStringsWb.java deleted file mode 100644 index 5a4d24e4fdf..00000000000 --- a/test/hotspot/jtreg/runtime/cds/SharedStringsWb.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) 2013, 2022, 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.whitebox.WhiteBox; - -// This class is used by the test SharedStrings.java -// It should be launched in CDS mode -public class SharedStringsWb { - public static void main(String[] args) throws Exception { - WhiteBox wb = WhiteBox.getWhiteBox(); - - if (!wb.areSharedStringsMapped()) { - System.out.println("Shared strings are not mapped, assuming PASS"); - return; - } - - // The string below is known to be added to CDS archive - String s = ""; - String internedS = s.intern(); - - // Check that it's a valid string - if (s.getClass() != String.class || !(s instanceof String)) { - throw new RuntimeException("Shared string is not a valid String: FAIL"); - } - - if (wb.isSharedInternedString(internedS)) { - System.out.println("Found shared string, result: PASS"); - } else { - throw new RuntimeException("String is not shared, result: FAIL"); - } - } -} - - diff --git a/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsApp.java b/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsApp.java deleted file mode 100644 index 9e4558002cc..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsApp.java +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright (c) 2018, 2023, 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 java.io.File; -import java.net.URL; -import jdk.test.whitebox.WhiteBox; - -// -// - Test static final String field with initial value in cached mirror should be also archived. -// - GC should not crash when reference fields in cached mirror are updated at runtime -// - Reference fields are updated to point to runtime created objects -// - Reference fields are nullified -// -public class MirrorWithReferenceFieldsApp { - - // Static String field with initial value - static final String archived_field = "abc"; - - // Static object field - static Object non_archived_field_1; - - // Instance field - Integer non_archived_field_2; - - public MirrorWithReferenceFieldsApp() { - non_archived_field_1 = new Object(); - non_archived_field_2 = Integer.valueOf(1); - } - - public static void main(String args[]) throws Exception { - WhiteBox wb = WhiteBox.getWhiteBox(); - - if (!wb.areOpenArchiveHeapObjectsMapped()) { - System.out.println("Archived open_archive_heap objects are not mapped."); - System.out.println("This may happen during normal operation. Test Skipped."); - return; - } - - MirrorWithReferenceFieldsApp m = new MirrorWithReferenceFieldsApp(); - m.test(wb); - } - - public void test(WhiteBox wb) { - Class c = MirrorWithReferenceFieldsApp.class; - if (wb.isSharedClass(c)) { - if (wb.isSharedInternedString(archived_field)) { - System.out.println("archived_field is archived as excepted"); - } else { - throw new RuntimeException( - "FAILED. archived_field is not archived."); - } - - // GC should not crash - System.gc(); - System.gc(); - System.gc(); - - non_archived_field_1 = null; - non_archived_field_2 = null; - - System.gc(); - System.gc(); - System.gc(); - - System.out.println("Done."); - } - } -} diff --git a/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsTest.java b/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsTest.java deleted file mode 100644 index 4c670ccba9b..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsTest.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (c) 2018, 2022, 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 - * @summary Test archived mirror with reference fields - * @requires vm.cds.write.archived.java.heap - * @library /test/lib /test/hotspot/jtreg/runtime/cds/appcds - * @build jdk.test.whitebox.WhiteBox - * @compile MirrorWithReferenceFieldsApp.java - * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar app.jar MirrorWithReferenceFieldsApp - * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar WhiteBox.jar jdk.test.whitebox.WhiteBox - * @run driver MirrorWithReferenceFieldsTest - */ - -import jdk.test.lib.process.OutputAnalyzer; -import jdk.test.lib.helpers.ClassFileInstaller; -import jdk.test.whitebox.WhiteBox; - -public class MirrorWithReferenceFieldsTest { - public static void main(String[] args) throws Exception { - String wbJar = ClassFileInstaller.getJarPath("WhiteBox.jar"); - String use_whitebox_jar = "-Xbootclasspath/a:" + wbJar; - String appJar = ClassFileInstaller.getJarPath("app.jar"); - - String classlist[] = new String[] { - "MirrorWithReferenceFieldsApp", - }; - - TestCommon.testDump(appJar, classlist, use_whitebox_jar); - OutputAnalyzer output = TestCommon.exec(appJar, use_whitebox_jar, - "-XX:+UnlockDiagnosticVMOptions", - "-XX:+WhiteBoxAPI", - "-XX:+VerifyAfterGC", - "MirrorWithReferenceFieldsApp"); - try { - TestCommon.checkExec(output, "Done"); - } catch (Exception e) { - output.shouldContain("Archived open_archive_heap objects are not mapped"); - } - } -} diff --git a/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/RedefineClassApp.java b/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/RedefineClassApp.java index e247a8158f7..0bac9f4e77d 100644 --- a/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/RedefineClassApp.java +++ b/test/hotspot/jtreg/runtime/cds/appcds/cacheObject/RedefineClassApp.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 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 @@ -55,11 +55,6 @@ public class RedefineClassApp { static Instrumentation instrumentation; public static void main(String args[]) throws Throwable { - if (!wb.areSharedStringsMapped()) { - System.out.println("Shared strings are ignored."); - return; - } - File bootJar = new File(args[0]); File appJar = new File(args[1]); diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/ExerciseGC.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/ExerciseGC.java deleted file mode 100644 index 7cad887a5d9..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/ExerciseGC.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright (c) 2015, 2025, 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 - * @summary Exercise GC with shared strings - * @requires vm.cds.write.mapped.java.heap - * @library /test/hotspot/jtreg/runtime/cds/appcds /test/lib - * @build HelloStringGC jdk.test.whitebox.WhiteBox - * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox - * @run driver ExerciseGC - */ -public class ExerciseGC { - public static void main(String[] args) throws Exception { - SharedStringsUtils.run(args, ExerciseGC::test); - } - public static void test(String[] args) throws Exception { - SharedStringsUtils.buildJarAndWhiteBox("HelloStringGC"); - - SharedStringsUtils.dumpWithWhiteBox(TestCommon.list("HelloStringGC"), - "SharedStringsBasic.txt", "-Xlog:cds,aot+hashtables"); - - SharedStringsUtils.runWithArchiveAndWhiteBox("HelloStringGC", - "-XX:+UnlockDiagnosticVMOptions", "-XX:+VerifyBeforeGC"); - } -} diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/HelloStringGC.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/HelloStringGC.java deleted file mode 100644 index 0f8dbf7e753..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/HelloStringGC.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright (c) 2015, 2022, 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.whitebox.WhiteBox; - -public class HelloStringGC { - public static String[] array01 = new String[1000]; - public static String[] array02 = new String[1000]; - - public static void main(String args[]) throws RuntimeException { - String testString1 = "shared_test_string_unique_14325"; - String testString2 = "test123"; - - WhiteBox wb = WhiteBox.getWhiteBox(); - if (wb.areSharedStringsMapped() && !wb.isSharedInternedString(testString1)) { - throw new RuntimeException("testString1 is not shared"); - } - - for (int i=0; i<5; i++) { - allocSomeStrings(testString1, testString2); - array01 = null; - array02 = null; - System.gc(); - sleep(300); - array01 = new String[1000]; - array02 = new String[1000]; - } - - wb.fullGC(); - - System.out.println("HelloStringGC: PASS"); - } - - private static void allocSomeStrings(String s1, String s2) { - for (int i = 0; i < 1000; i ++) { - array01[i] = new String(s1); - array02[i] = new String(s2); - } - } - - private static void sleep(int ms) { - try { - Thread.sleep(ms); - } catch (InterruptedException e) { - } - } - -} diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/HelloStringPlus.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/HelloStringPlus.java deleted file mode 100644 index da111ced43a..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/HelloStringPlus.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (c) 2015, 2022, 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. - * - */ - -// A test class to be launched in AppCDS mode, has basic+ -// coverage of string operations - -import jdk.test.whitebox.WhiteBox; - -public class HelloStringPlus { - public static void main(String args[]) { - // Let's reference the string that is in archive - String testString1 = "shared_test_string_unique_14325"; - System.out.println("Hello String: " + testString1); - - WhiteBox wb = WhiteBox.getWhiteBox(); - if (wb.areSharedStringsMapped() && !wb.isSharedInternedString(testString1)) { - throw new RuntimeException("testString1 is not shared"); - } - - // Check other basic string operations - // Interning and equality - String[] testArray = new String[] {"shared_", "test_", "string_", "intern_", "12345"}; - String toBeInterned = ""; - - StringBuilder sb = new StringBuilder(); - for (String s : testArray) { - sb.append(s); - } - toBeInterned = sb.toString(); - - System.out.println("About to intern a string: " + toBeInterned); - toBeInterned.intern(); - - // check equality - if (testString1.equals(toBeInterned)) - throw new RuntimeException("Equality test 1 failed"); - - if (!testString1.equals("shared_test_string" + '_' + "unique_14325")) - throw new RuntimeException("Equality test 2 failed"); - - // Chech the hash code functionality; no special assertions, just make sure - // no crashe or exception occurs - System.out.println("testString1.hashCode() = " + testString1.hashCode()); - - // Check intern() method for "" string - String empty = ""; - String empty_interned = empty.intern(); - if (wb.areSharedStringsMapped() && !wb.isSharedInternedString(empty)) { - throw new RuntimeException("Empty string should be shared"); - } - if (empty_interned != empty) { - throw new RuntimeException("Different string is returned from intern() for empty string"); - } - } -} diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/InternSharedString.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/InternSharedString.java deleted file mode 100644 index 89136ebdc4d..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/InternSharedString.java +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) 2015, 2025, 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 - * @summary Test shared strings together with string intern operation - * @requires vm.gc == null - * @requires vm.cds.write.mapped.java.heap - * @library /test/hotspot/jtreg/runtime/cds/appcds /test/lib - * @compile InternStringTest.java - * @build jdk.test.whitebox.WhiteBox - * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox - * @run driver InternSharedString - */ - -// This test requires the vm.cds.write.mapped.java.heap specifically as it has expectations -// about using the mechanism for dumping the entire string table, which the streaming solution -// does not do. - -public class InternSharedString { - public static void main(String[] args) throws Exception { - SharedStringsUtils.run(args, InternSharedString::test); - } - - public static void test(String[] args) throws Exception { - SharedStringsUtils.buildJarAndWhiteBox("InternStringTest"); - - SharedStringsUtils.dumpWithWhiteBox(TestCommon.list("InternStringTest"), - "ExtraSharedInput.txt", "-Xlog:cds,aot+hashtables"); - - String[] extraMatches = new String[] { - InternStringTest.passed_output1, - InternStringTest.passed_output2, - InternStringTest.passed_output3 }; - - SharedStringsUtils.runWithArchiveAndWhiteBox(extraMatches, "InternStringTest"); - } -} diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/InternStringTest.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/InternStringTest.java deleted file mode 100644 index bea24c87888..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/InternStringTest.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright (c) 2015, 2022, 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.whitebox.WhiteBox; - -public class InternStringTest { - public static String passed_output1 = "Found shared string."; - public static String passed_output2 = "Shared strings are equal."; - public static String passed_output3 = "Found shared string containing latin1 supplement chars."; - public static String passed_output4 = "Found shared string containing non-western chars."; - public static final String latin1Sup = "XXXX \u00a3 YYYY"; // \u00a3 = The pound sign - public static final String nonWestern = "XXXX \u5678 YYYY"; // \u5678 = Unicode Han Character 'ton (metric or English)' - - public static void main(String[] args) throws Exception { - WhiteBox wb = WhiteBox.getWhiteBox(); - - // All string literals are shared. - String shared1 = "LiveOak"; - String interned1 = shared1.intern(); - if (wb.areSharedStringsMapped()) { - if (wb.isSharedInternedString(interned1)) { - System.out.println(passed_output1); - } else { - throw new RuntimeException("Failed: String is not shared."); - } - } - - // Test 2: shared_string1.intern() == shared_string2.intern() - String shared2 = "LiveOak"; - String interned2 = shared2.intern(); - if (interned1 == interned2) { - System.out.println(passed_output2); - } else { - throw new RuntimeException("Not equal!"); - } - - // Test 3: interned strings with a char in latin1 supplement block [\u0080-\u00ff] - { - String a = "X" + latin1Sup.substring(1); - String b = a.intern(); - - if (wb.areSharedStringsMapped()) { - if (wb.isSharedInternedString(b)) { - System.out.println(passed_output3); - } else { - throw new RuntimeException("Failed: expected shared string with latin1-supplement chars."); - } - } - } - - // Test 5: interned strings with non-western characters - { - String a = "X" + nonWestern.substring(1); - String b = a.intern(); - if (wb.areSharedStringsMapped()) { - if (wb.isSharedInternedString(b)) { - System.out.println(passed_output4); - } else { - throw new RuntimeException("Failed: expected shared string with non-western chars."); - } - } - } - } -} diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsBasicPlus.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsBasicPlus.java deleted file mode 100644 index 6145ea7719b..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsBasicPlus.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright (c) 2015, 2025, 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 - * @summary Basic plus test for shared strings - * @requires vm.cds.write.mapped.java.heap - * @library /test/hotspot/jtreg/runtime/cds/appcds /test/lib - * @build HelloStringPlus jdk.test.whitebox.WhiteBox - * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox - * @run driver SharedStringsBasicPlus - */ - -// This test requires the vm.cds.write.mapped.java.heap specifically as it has expectations -// about using the mechanism for dumping the entire string table, which the streaming solution -// does not do. - -public class SharedStringsBasicPlus { - public static void main(String[] args) throws Exception { - SharedStringsUtils.run(args, SharedStringsBasicPlus::test); - } - - public static void test(String[] args) throws Exception { - SharedStringsUtils.buildJarAndWhiteBox("HelloStringPlus"); - - SharedStringsUtils.dumpWithWhiteBox( TestCommon.list("HelloStringPlus"), - "SharedStringsBasic.txt", "-Xlog:cds,aot+hashtables"); - - SharedStringsUtils.runWithArchiveAndWhiteBox("HelloStringPlus"); - } -} diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsUtils.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsUtils.java index e15cfafa3cb..15686d76ab3 100644 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsUtils.java +++ b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsUtils.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 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 @@ -47,7 +47,7 @@ public class SharedStringsUtils { // SharedStringsUtils.run() is for running the main test body multiple times, each with a different // set of extra VM options that are passed to the child processes. // - // See ./ExerciseGC.java for an example. + // See ./LargePages.java for an example. public static void run(String args[], Test t) throws Exception { int numSetOfChildVMOptions = vmOptionCombos.length; for (int i=0; i< numSetOfChildVMOptions; i++) { diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsWb.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsWb.java deleted file mode 100644 index 755d64bf51b..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsWb.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (c) 2015, 2022, 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.whitebox.WhiteBox; - -public class SharedStringsWb { - public static void main(String[] args) throws Exception { - WhiteBox wb = WhiteBox.getWhiteBox(); - String s = "shared_test_string_unique_14325"; - s = s.intern(); - if (wb.areSharedStringsMapped()) { - if (wb.isSharedInternedString(s)) { - System.out.println("Found shared string."); - } else { - throw new RuntimeException("String is not shared."); - } - } - } -} - - diff --git a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsWbTest.java b/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsWbTest.java deleted file mode 100644 index 20dbad30441..00000000000 --- a/test/hotspot/jtreg/runtime/cds/appcds/sharedStrings/SharedStringsWbTest.java +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (c) 2016, 2025, 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 - * @summary White box test for shared strings - * @requires vm.cds.write.mapped.java.heap - * @library /test/lib /test/hotspot/jtreg/runtime/cds/appcds - * @build jdk.test.whitebox.WhiteBox SharedStringsWb - * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox - * @run driver SharedStringsWbTest - */ - -// This test requires the vm.cds.write.mapped.java.heap specifically as it has expectations -// about using the mechanism for dumping the entire string table, which the streaming solution -// does not do. - -import java.io.*; -import jdk.test.whitebox.WhiteBox; - -public class SharedStringsWbTest { - public static void main(String[] args) throws Exception { - SharedStringsUtils.run(args, SharedStringsWbTest::test); - } - - public static void test(String[] args) throws Exception { - SharedStringsUtils.buildJarAndWhiteBox("SharedStringsWb"); - - SharedStringsUtils.dumpWithWhiteBox(TestCommon.list("SharedStringsWb"), - "SharedStringsBasic.txt", "-Xlog:cds,aot+hashtables"); - - SharedStringsUtils.runWithArchiveAndWhiteBox("SharedStringsWb"); - } -} diff --git a/test/lib/jdk/test/whitebox/WhiteBox.java b/test/lib/jdk/test/whitebox/WhiteBox.java index cc570caef7c..c915cee41b0 100644 --- a/test/lib/jdk/test/whitebox/WhiteBox.java +++ b/test/lib/jdk/test/whitebox/WhiteBox.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 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 @@ -799,8 +799,6 @@ public class WhiteBox { public native boolean cdsMemoryMappingFailed(); public native boolean isSharingEnabled(); public native boolean isSharedClass(Class c); - public native boolean areSharedStringsMapped(); - public native boolean isSharedInternedString(String s); public native boolean isCDSIncluded(); public native boolean isJFRIncluded(); public native boolean isDTraceIncluded(); From facbcaf06af2c94d319b32da99d2cc4ff69408f1 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Sat, 21 Feb 2026 04:13:08 +0000 Subject: [PATCH 34/63] 8378205: Remove AppContext from Swing MenuComponent Reviewed-by: kizune, serb --- .../share/classes/java/awt/MenuComponent.java | 21 +------------------ .../share/classes/sun/awt/AWTAccessor.java | 10 --------- .../share/classes/sun/awt/SunToolkit.java | 6 +----- 3 files changed, 2 insertions(+), 35 deletions(-) diff --git a/src/java.desktop/share/classes/java/awt/MenuComponent.java b/src/java.desktop/share/classes/java/awt/MenuComponent.java index 1391a397f82..88ebbed96da 100644 --- a/src/java.desktop/share/classes/java/awt/MenuComponent.java +++ b/src/java.desktop/share/classes/java/awt/MenuComponent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1995, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1995, 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 @@ -40,7 +40,6 @@ import javax.accessibility.AccessibleState; import javax.accessibility.AccessibleStateSet; import sun.awt.AWTAccessor; -import sun.awt.AppContext; import sun.awt.ComponentFactory; /** @@ -60,12 +59,6 @@ public abstract class MenuComponent implements java.io.Serializable { transient volatile MenuComponentPeer peer; transient volatile MenuContainer parent; - /** - * The {@code AppContext} of the {@code MenuComponent}. - * This is set in the constructor and never changes. - */ - private transient volatile AppContext appContext; - /** * The menu component's font. This value can be * {@code null} at which point a default will be used. @@ -116,15 +109,6 @@ public abstract class MenuComponent implements java.io.Serializable { static { AWTAccessor.setMenuComponentAccessor( new AWTAccessor.MenuComponentAccessor() { - @Override - public AppContext getAppContext(MenuComponent menuComp) { - return menuComp.appContext; - } - @Override - public void setAppContext(MenuComponent menuComp, - AppContext appContext) { - menuComp.appContext = appContext; - } @Override @SuppressWarnings("unchecked") public T getPeer(MenuComponent menuComp) { @@ -154,7 +138,6 @@ public abstract class MenuComponent implements java.io.Serializable { */ public MenuComponent() throws HeadlessException { GraphicsEnvironment.checkHeadless(); - appContext = AppContext.getAppContext(); } /** @@ -428,8 +411,6 @@ public abstract class MenuComponent implements java.io.Serializable { GraphicsEnvironment.checkHeadless(); s.defaultReadObject(); - - appContext = AppContext.getAppContext(); } /* diff --git a/src/java.desktop/share/classes/sun/awt/AWTAccessor.java b/src/java.desktop/share/classes/sun/awt/AWTAccessor.java index 3c63a390a81..c74219f7efa 100644 --- a/src/java.desktop/share/classes/sun/awt/AWTAccessor.java +++ b/src/java.desktop/share/classes/sun/awt/AWTAccessor.java @@ -451,16 +451,6 @@ public final class AWTAccessor { * An accessor for the MenuComponent class. */ public interface MenuComponentAccessor { - /** - * Returns the appContext of the menu component. - */ - AppContext getAppContext(MenuComponent menuComp); - - /** - * Sets the appContext of the menu component. - */ - void setAppContext(MenuComponent menuComp, AppContext appContext); - /** * Returns the peer of the menu component. */ diff --git a/src/java.desktop/share/classes/sun/awt/SunToolkit.java b/src/java.desktop/share/classes/sun/awt/SunToolkit.java index 7429656eb30..10fb62e2fdc 100644 --- a/src/java.desktop/share/classes/sun/awt/SunToolkit.java +++ b/src/java.desktop/share/classes/sun/awt/SunToolkit.java @@ -333,9 +333,6 @@ public abstract class SunToolkit extends Toolkit if (target instanceof Component) { AWTAccessor.getComponentAccessor(). setAppContext((Component)target, context); - } else if (target instanceof MenuComponent) { - AWTAccessor.getMenuComponentAccessor(). - setAppContext((MenuComponent)target, context); } else { return false; } @@ -351,8 +348,7 @@ public abstract class SunToolkit extends Toolkit return AWTAccessor.getComponentAccessor(). getAppContext((Component)target); } else if (target instanceof MenuComponent) { - return AWTAccessor.getMenuComponentAccessor(). - getAppContext((MenuComponent)target); + return AppContext.getAppContext(); } else { return null; } From 3bd4a111802f82afec1af1a732be2eab150255c5 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Sat, 21 Feb 2026 04:13:24 +0000 Subject: [PATCH 35/63] 8378296: Remove AppContext from java.awt.event.FocusEvent Reviewed-by: kizune, serb --- .../share/classes/java/awt/event/FocusEvent.java | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/src/java.desktop/share/classes/java/awt/event/FocusEvent.java b/src/java.desktop/share/classes/java/awt/event/FocusEvent.java index 27da2e8b4bb..e39e9c317b0 100644 --- a/src/java.desktop/share/classes/java/awt/event/FocusEvent.java +++ b/src/java.desktop/share/classes/java/awt/event/FocusEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 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 @@ -30,7 +30,6 @@ import java.io.ObjectStreamException; import java.io.Serial; import sun.awt.AWTAccessor; -import sun.awt.AppContext; import sun.awt.SunToolkit; /** @@ -326,21 +325,14 @@ public class FocusEvent extends ComponentEvent { * FOCUS_GAINED event, this is the Component that lost focus. For a * FOCUS_LOST event, this is the Component that gained focus. If this * focus change occurs with a native application, with a Java application - * in a different VM or context, or with no other Component, then null is + * in a different VM, or with no other Component, then null is * returned. * * @return the other Component involved in the focus change, or null * @since 1.4 */ public Component getOppositeComponent() { - if (opposite == null) { - return null; - } - - return (SunToolkit.targetToAppContext(opposite) == - AppContext.getAppContext()) - ? opposite - : null; + return opposite; } /** @@ -407,4 +399,4 @@ public class FocusEvent extends ComponentEvent { } -} \ No newline at end of file +} From fac338b03e057aa7f9df3a39bf48b41d23d0a612 Mon Sep 17 00:00:00 2001 From: Jaikiran Pai Date: Sat, 21 Feb 2026 04:34:19 +0000 Subject: [PATCH 36/63] 8377425: Test runtime/os/TestWXHealing.java fails on macosx-aarch64 product build Reviewed-by: aph, dholmes --- .../jtreg/runtime/os/TestWXHealing.java | 62 ++++++++++++++++--- 1 file changed, 52 insertions(+), 10 deletions(-) diff --git a/test/hotspot/jtreg/runtime/os/TestWXHealing.java b/test/hotspot/jtreg/runtime/os/TestWXHealing.java index 46875848a89..1ed2caf2433 100644 --- a/test/hotspot/jtreg/runtime/os/TestWXHealing.java +++ b/test/hotspot/jtreg/runtime/os/TestWXHealing.java @@ -1,5 +1,6 @@ /* * Copyright (c) 2025 IBM Corporation. All rights reserved. + * Copyright (c) 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 @@ -22,31 +23,72 @@ */ /* - * @test + * @test id=TraceWXHealing + * @summary Run shell with -XX:+StressWXHealing and -XX:+TraceWXHealing. This tests most of + * the triggers for WX mode. * @requires os.family == "mac" * @requires os.arch == "aarch64" - * @summary Run shell with -XX:+StressWXHealing. This tests most of - * the triggers for WX mode. + * @requires vm.debug == true * @library /test/lib * @compile WXHealing.java - * @run main TestWXHealing + * @build jtreg.SkippedException + * @run main TestWXHealing traceWXHealing */ +/* + * @test id=No-TraceWXHealing + * @summary Run shell with -XX:+StressWXHealing. This tests most of + * the triggers for WX mode. + * @requires os.family == "mac" + * @requires os.arch == "aarch64" + * @library /test/lib + * @compile WXHealing.java + * @build jtreg.SkippedException + * @run main TestWXHealing + */ import java.util.regex.*; import jdk.test.lib.process.*; +import jtreg.SkippedException; -import static java.nio.charset.StandardCharsets.*; +import static java.nio.charset.StandardCharsets.UTF_8; public class TestWXHealing { public static void main(String[] args) throws Throwable { - String[] opts = {"-XX:+UnlockDiagnosticVMOptions", - "-XX:+TraceWXHealing", "-XX:+StressWXHealing", "WXHealing"}; + String[] opts; + boolean traceWXHealing = args.length > 0 && args[0].equals("traceWXHealing"); + // pass -XX:+TraceWXHealing only when instructed to do so + if (traceWXHealing) { + opts = new String[]{ + "-XX:+UnlockDiagnosticVMOptions", + "-XX:+TraceWXHealing", + "-XX:+StressWXHealing", + "WXHealing" + }; + } else { + opts = new String[]{ + "-XX:+UnlockDiagnosticVMOptions", + "-XX:+StressWXHealing", + "WXHealing" + }; + } var process = ProcessTools.createTestJavaProcessBuilder(opts).start(); - String output = new String(process.getInputStream().readAllBytes(), UTF_8); - System.out.println(output); + OutputAnalyzer oa = new OutputAnalyzer(process, UTF_8); + oa.shouldHaveExitValue(0); + String output = oa.getStdout(); + System.out.println("output from WXHealing application: " + output); + if (output.isEmpty()) { + throw new RuntimeException("no output generated by WXHealing application"); + } + if (!traceWXHealing) { + // if -XX:+TraceWXHealing wasn't enabled, then this test merely + // verifies that the java application launched with -XX:+StressWXHealing + // exited normally. + return; + } + // verify the output generated by -XX:+TraceWXHealing if (output.contains("MAP_JIT write protection does not work on this system")) { - System.out.println("Test was not run because MAP_JIT write protection does not work on this system"); + throw new SkippedException("Test was not run because MAP_JIT write protection does not work on this system"); } else { var pattern = Pattern.compile("Healing WXMode WXArmedForWrite at 0x[0-9a-f]* to WXWrite "); var matches = pattern.matcher(output).results().count(); From d4dc5e49c153555e59dd5b1c2f806d2eb4caff80 Mon Sep 17 00:00:00 2001 From: Yasumasa Suenaga Date: Sat, 21 Feb 2026 11:39:52 +0000 Subject: [PATCH 37/63] 8378369: TestJhsdbJstackMixedWithVDSOCallCore.java fails if missing vdso64.so Reviewed-by: cjplummer, ayang --- test/lib/jdk/test/lib/SA/SATestUtils.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/lib/jdk/test/lib/SA/SATestUtils.java b/test/lib/jdk/test/lib/SA/SATestUtils.java index 63f522b3d62..50f5d71f1f1 100644 --- a/test/lib/jdk/test/lib/SA/SATestUtils.java +++ b/test/lib/jdk/test/lib/SA/SATestUtils.java @@ -40,6 +40,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.concurrent.TimeUnit; import java.util.List; +import java.util.NoSuchElementException; public class SATestUtils { /** @@ -334,6 +335,9 @@ public class SATestUtils { String file = buildID.substring(2); debuginfoPath = Path.of("/usr/lib/debug/.build_id", dir, file + ".debug"); exists = Files.exists(debuginfoPath); + } catch (NoSuchElementException _) { + // return null if vDSO not found. + return null; } } return exists ? debuginfoPath.toString() : null; From a35945ae067ffd60d5f374060086650636ebd9de Mon Sep 17 00:00:00 2001 From: Quan Anh Mai Date: Sat, 21 Feb 2026 11:52:50 +0000 Subject: [PATCH 38/63] 8376220: C2: Refactor the logic to in MemNode::find_previous_store Reviewed-by: rcastanedalo, bmaillard --- src/hotspot/share/opto/memnode.cpp | 113 +++++++++--- .../jtreg/compiler/c2/gvn/TestFindStore.java | 173 ++++++++++++++++++ 2 files changed, 256 insertions(+), 30 deletions(-) create mode 100644 test/hotspot/jtreg/compiler/c2/gvn/TestFindStore.java diff --git a/src/hotspot/share/opto/memnode.cpp b/src/hotspot/share/opto/memnode.cpp index f296b153f4b..5af0794f29c 100644 --- a/src/hotspot/share/opto/memnode.cpp +++ b/src/hotspot/share/opto/memnode.cpp @@ -44,6 +44,7 @@ #include "opto/mempointer.hpp" #include "opto/mulnode.hpp" #include "opto/narrowptrnode.hpp" +#include "opto/opcodes.hpp" #include "opto/phaseX.hpp" #include "opto/regalloc.hpp" #include "opto/regmask.hpp" @@ -552,6 +553,18 @@ Node::DomResult MemNode::maybe_all_controls_dominate(Node* dom, Node* sub) { bool MemNode::detect_ptr_independence(Node* p1, AllocateNode* a1, Node* p2, AllocateNode* a2, PhaseTransform* phase) { + // Trivial case: Non-overlapping values. Be careful, we can cast a raw pointer to an oop (e.g. in + // the allocation pattern) so joining the types only works if both are oops. join may also give + // an incorrect result when both pointers are nullable and the result is supposed to be + // TypePtr::NULL_PTR, so we exclude that case. + const Type* p1_type = p1->bottom_type(); + const Type* p2_type = p2->bottom_type(); + if (p1_type->isa_oopptr() && p2_type->isa_oopptr() && + (!p1_type->maybe_null() || !p2_type->maybe_null()) && + p1_type->join(p2_type)->empty()) { + return true; + } + // Attempt to prove that these two pointers cannot be aliased. // They may both manifestly be allocations, and they should differ. // Or, if they are not both allocations, they can be distinct constants. @@ -690,6 +703,20 @@ Node* MemNode::find_previous_store(PhaseValues* phase) { Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset); AllocateNode* alloc = AllocateNode::Ideal_allocation(base); + const TypePtr* adr_type = this->adr_type(); + if (adr_type == nullptr) { + // This means the access is dead + return phase->C->top(); + } else if (adr_type->base() == TypePtr::AnyPtr) { + assert(adr_type->ptr() == TypePtr::Null, "MemNode should never access a wide memory"); + // Give up, this will upset Compile::get_alias_index + return nullptr; + } + + int alias_idx = phase->C->get_alias_index(adr_type); + assert(alias_idx != Compile::AliasIdxTop, "must not be a dead node"); + assert(alias_idx != Compile::AliasIdxBot || !phase->C->do_aliasing(), "must not be a very wide access"); + if (offset == Type::OffsetBot) return nullptr; // cannot unalias unless there are precise offsets @@ -709,15 +736,32 @@ Node* MemNode::find_previous_store(PhaseValues* phase) { Node* st_adr = mem->in(MemNode::Address); intptr_t st_offset = 0; Node* st_base = AddPNode::Ideal_base_and_offset(st_adr, phase, st_offset); - if (st_base == nullptr) - break; // inscrutable pointer - - // For raw accesses it's not enough to prove that constant offsets don't intersect. - // We need the bases to be the equal in order for the offset check to make sense. - if ((adr_maybe_raw || check_if_adr_maybe_raw(st_adr)) && st_base != base) { + if (st_base == nullptr) { + // inscrutable pointer break; } + // If the bases are the same and the offsets are the same, it seems that this is the exact + // store we are looking for, the caller will check if the type of the store matches using + // MemNode::can_see_stored_value + if (st_base == base && st_offset == offset) { + return mem; // (b) found the store that this access observes + } + + // If it is provable that the memory accessed by mem does not overlap the memory accessed by + // this, we may walk past mem. + // For raw accesses, 2 accesses are independent if they have the same base and the offsets + // say that they do not overlap. + // For heap accesses, 2 accesses are independent if either the bases are provably different + // at runtime or the offsets say that the accesses do not overlap. + if ((adr_maybe_raw || check_if_adr_maybe_raw(st_adr)) && st_base != base) { + // Raw accesses can only be provably independent if they have the same base + break; + } + + // If the offsets say that the accesses do not overlap, then it is provable that mem and this + // do not overlap. For example, a LoadI from Object+8 is independent from a StoreL into + // Object+12, no matter what the bases are. if (st_offset != offset && st_offset != Type::OffsetBot) { const int MAX_STORE = MAX2(BytesPerLong, (int)MaxVectorSize); assert(mem->as_Store()->memory_size() <= MAX_STORE, ""); @@ -730,25 +774,25 @@ Node* MemNode::find_previous_store(PhaseValues* phase) { // in the same sequence of RawMem effects. We sometimes initialize // a whole 'tile' of array elements with a single jint or jlong.) mem = mem->in(MemNode::Memory); - continue; // (a) advance through independent store memory + continue; // (a) advance through the independent store } } - if (st_base != base && - detect_ptr_independence(base, alloc, - st_base, - AllocateNode::Ideal_allocation(st_base), - phase)) { - // Success: The bases are provably independent. + + // Same base and overlapping offsets, it seems provable that the accesses overlap, give up + if (st_base == base) { + break; + } + + // Try to prove that 2 different base nodes at compile time are different values at runtime + bool known_independent = false; + if (detect_ptr_independence(base, alloc, st_base, AllocateNode::Ideal_allocation(st_base), phase)) { + known_independent = true; + } + + if (known_independent) { mem = mem->in(MemNode::Memory); - continue; // (a) advance through independent store memory + continue; // (a) advance through the independent store } - - // (b) At this point, if the bases or offsets do not agree, we lose, - // since we have not managed to prove 'this' and 'mem' independent. - if (st_base == base && st_offset == offset) { - return mem; // let caller handle steps (c), (d) - } - } else if (mem->is_Proj() && mem->in(0)->is_Initialize()) { InitializeNode* st_init = mem->in(0)->as_Initialize(); AllocateNode* st_alloc = st_init->allocation(); @@ -769,7 +813,6 @@ Node* MemNode::find_previous_store(PhaseValues* phase) { // The bases are provably independent: Either they are // manifestly distinct allocations, or else the control // of this load dominates the store's allocation. - int alias_idx = phase->C->get_alias_index(adr_type()); if (alias_idx == Compile::AliasIdxRaw) { mem = st_alloc->in(TypeFunc::Memory); } else { @@ -792,6 +835,9 @@ Node* MemNode::find_previous_store(PhaseValues* phase) { } // Found an arraycopy that may affect that load return mem; + } else if (mem->is_MergeMem()) { + mem = mem->as_MergeMem()->memory_at(alias_idx); + continue; } else if (addr_t != nullptr && addr_t->is_known_instance_field()) { // Can't use optimize_simple_memory_chain() since it needs PhaseGVN. if (mem->is_Proj() && mem->in(0)->is_Call()) { @@ -817,10 +863,6 @@ Node* MemNode::find_previous_store(PhaseValues* phase) { // we are looking for. return mem; } - } else if (mem->is_MergeMem()) { - int alias_idx = phase->C->get_alias_index(adr_type()); - mem = mem->as_MergeMem()->memory_at(alias_idx); - continue; // (a) advance through independent MergeMem memory } } @@ -1843,7 +1885,6 @@ Node *LoadNode::Ideal(PhaseGVN *phase, bool can_reshape) { Node* ctrl = in(MemNode::Control); Node* address = in(MemNode::Address); - bool progress = false; bool addr_mark = ((phase->type(address)->isa_oopptr() || phase->type(address)->isa_narrowoop()) && phase->type(address)->is_ptr()->offset() == oopDesc::mark_offset_in_bytes()); @@ -1856,7 +1897,7 @@ Node *LoadNode::Ideal(PhaseGVN *phase, bool can_reshape) { (depends_only_on_test() || has_unknown_control_dependency())) { ctrl = ctrl->in(0); set_req(MemNode::Control,ctrl); - progress = true; + return this; } intptr_t ignore = 0; @@ -1870,7 +1911,7 @@ Node *LoadNode::Ideal(PhaseGVN *phase, bool can_reshape) { && all_controls_dominate(base, phase->C->start())) { // A method-invariant, non-null address (constant or 'this' argument). set_req(MemNode::Control, nullptr); - progress = true; + return this; } } @@ -1943,6 +1984,10 @@ Node *LoadNode::Ideal(PhaseGVN *phase, bool can_reshape) { // the alias index stuff. So instead, peek through Stores and IFF we can // fold up, do so. Node* prev_mem = find_previous_store(phase); + if (prev_mem != nullptr && prev_mem->is_top()) { + // find_previous_store returns top when the access is dead + return prev_mem; + } if (prev_mem != nullptr) { Node* value = can_see_arraycopy_value(prev_mem, phase); if (value != nullptr) { @@ -1961,7 +2006,11 @@ Node *LoadNode::Ideal(PhaseGVN *phase, bool can_reshape) { } } - return progress ? this : nullptr; + if (!can_reshape) { + phase->record_for_igvn(this); + } + + return nullptr; } // Helper to recognize certain Klass fields which are invariant across @@ -3565,6 +3614,10 @@ Node* StoreNode::Identity(PhaseGVN* phase) { Node* prev_mem = find_previous_store(phase); // Steps (a), (b): Walk past independent stores to find an exact match. if (prev_mem != nullptr) { + if (prev_mem->is_top()) { + // find_previous_store returns top when the access is dead + return prev_mem; + } Node* prev_val = can_see_stored_value(prev_mem, phase); if (prev_val != nullptr && prev_val == val) { // prev_val and val might differ by a cast; it would be good diff --git a/test/hotspot/jtreg/compiler/c2/gvn/TestFindStore.java b/test/hotspot/jtreg/compiler/c2/gvn/TestFindStore.java new file mode 100644 index 00000000000..aac3e0cf980 --- /dev/null +++ b/test/hotspot/jtreg/compiler/c2/gvn/TestFindStore.java @@ -0,0 +1,173 @@ +/* + * Copyright (c) 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. + */ +package compiler.c2.gvn; + +import compiler.lib.ir_framework.*; +import jdk.internal.misc.Unsafe; +import jdk.test.lib.Asserts; + +/* + * @test + * @bug 8376220 + * @summary Tests that memory accesses can be elided when the compiler can see the value at the + * accessed memory location by walking the memory graph. + * @modules java.base/jdk.internal.misc + * @library /test/lib / + * @run driver ${test.main.class} + */ +public class TestFindStore { + private static final Unsafe U = Unsafe.getUnsafe(); + + static class P { + int v; + int u; + } + + static final long V_OFFSET = U.objectFieldOffset(P.class, "v"); + static final long U_OFFSET = U.objectFieldOffset(P.class, "u"); + + static class C1 extends P {} + static class C2 extends P {} + + public static void main(String[] args) { + TestFramework.runWithFlags("--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED"); + } + + @Run(test = {"testLoad", "testStore", "testLoadDependent1", "testLoadDependent2", "testLoadArray", + "testLoadArrayOverlap", "testLoadIndependentAliasClasses", "testLoadMismatched", + "testLoadArrayCopy", "testLoadArrayCopyUnknownLength"}) + public void run() { + C1 c1 = new C1(); + C2 c2 = new C2(); + int[] a1 = new int[1000]; + int[] a2 = new int[1000]; + + Asserts.assertEQ(0, testLoad(c1, c2, 0, 1)); + Asserts.assertEQ(0, testStore(c2, 0).v); + Asserts.assertEQ(0, testLoadDependent1(c1, c1, 0, 1)); + Asserts.assertEQ(1, testLoadDependent1(c2, c1, 0, 1)); + Asserts.assertEQ(1, testLoadDependent2(c1, c1, 0, 1)); + Asserts.assertEQ(0, testLoadDependent2(c2, c1, 0, 1)); + + Asserts.assertEQ(0, testLoadArray(a1, a2, 0, 1)); + Asserts.assertEQ(0, testLoadArrayOverlap(a1, a2, 2, 0, 1)); + Asserts.assertEQ(0, testLoadArrayOverlap(a1, a1, 0, 0, 1)); + Asserts.assertEQ(1, testLoadArrayOverlap(a1, a1, 2, 0, 1)); + Asserts.assertEQ(0, testLoadIndependentAliasClasses(c1, 0, 1)); + Asserts.assertNE(0, testLoadMismatched(c1, 0, -1)); + Asserts.assertEQ(1, testLoadArrayCopy(a1, a2, 1)); + + a1[2] = 0; + Asserts.assertEQ(1, testLoadArrayCopyUnknownLength(a1, a2, 100, 1)); + a1[2] = 0; + Asserts.assertEQ(0, testLoadArrayCopyUnknownLength(a1, a2, 2, 1)); + } + + @Test + @IR(failOn = IRNode.LOAD) + static int testLoad(C1 c1, C2 c2, int v1, int v2) { + // c1 and c2 are provably independent + c1.v = v1; + c2.v = v2; + return c1.v; + } + + @Test + @IR(counts = {IRNode.STORE, "1"}, phase = CompilePhase.BEFORE_MACRO_EXPANSION) + static C1 testStore(C2 c2, int v2) { + C1 c1 = new C1(); + c2.v = v2; + c1.v = 0; + return c1; + } + + @Test + @IR(counts = {IRNode.LOAD, "1"}) + static int testLoadDependent1(P p, C1 c1, int v, int v1) { + // It cannot be proved that p and c1 are independent + c1.v = v1; + p.v = v; + return c1.v; + } + + @Test + @IR(counts = {IRNode.LOAD, "1"}) + static int testLoadDependent2(P p, C1 c1, int v, int v1) { + // It cannot be proved that p and c1 are independent + p.v = v; + c1.v = v1; + return p.v; + } + + @Test + @IR(failOn = IRNode.LOAD) + static int testLoadArray(int[] a1, int[] a2, int v1, int v2) { + // a1[2] and a2[1] are provably independent + a1[2] = v1; + a2[1] = v2; + return a1[2]; + } + + @Test + @IR(counts = {IRNode.LOAD, "1"}) + static int testLoadArrayOverlap(int[] a1, int[] a2, int idx, int v1, int v2) { + // Cannot prove that a1[2] and a2[idx] are independent + a1[2] = v1; + a2[idx] = v2; + return a1[2]; + } + + @Test + @IR(failOn = IRNode.LOAD) + static int testLoadIndependentAliasClasses(P p, int v, int u) { + p.v = v; + p.u = u; + return p.v; + } + + @Test + @IR(counts = {IRNode.LOAD, "1"}) + static int testLoadMismatched(P p, int v1, int v2) { + p.v = v1; + U.putIntUnaligned(p, (V_OFFSET + U_OFFSET) / 2, v2); + return p.v; + } + + @Test + @IR(failOn = IRNode.LOAD, applyIf = {"ArrayCopyLoadStoreMaxElem", "<100"}) + static int testLoadArrayCopy(int[] a1, int[] a2, int v) { + a2[2] = v; + // Should be large so the compiler does not just transform it into a couple of loads and stores + System.arraycopy(a2, 0, a1, 0, 100); + return a1[2]; + } + + @Test + @IR(counts = {IRNode.LOAD, "1"}) + static int testLoadArrayCopyUnknownLength(int[] a1, int[] a2, int len, int v) { + a2[2] = v; + // Cannot determine if this overwrites a1[2] + System.arraycopy(a2, 0, a1, 0, len); + return a1[2]; + } +} From 497dca2549a9829530670576115bf4b8fab386b3 Mon Sep 17 00:00:00 2001 From: Sergey Bylokhov Date: Sun, 22 Feb 2026 00:12:19 +0000 Subject: [PATCH 39/63] 8378153: Robot.getPixelColor() may return stale pixels due to missing Toolkit.sync() Reviewed-by: prr, azvegint --- src/java.desktop/share/classes/java/awt/Robot.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/java.desktop/share/classes/java/awt/Robot.java b/src/java.desktop/share/classes/java/awt/Robot.java index d887cad4f77..2a489a4cbf5 100644 --- a/src/java.desktop/share/classes/java/awt/Robot.java +++ b/src/java.desktop/share/classes/java/awt/Robot.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 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 @@ -459,6 +459,9 @@ public class Robot { * @return Color of the pixel */ public synchronized Color getPixelColor(int x, int y) { + // need to sync the toolkit prior to grabbing the pixels since in some + // cases rendering to the screen may be delayed + Toolkit.getDefaultToolkit().sync(); Point point = peer.useAbsoluteCoordinates() ? toDeviceSpaceAbs(x, y) : toDeviceSpace(x, y); return new Color(peer.getRGBPixel(point.x, point.y)); From c3f713a9c94497871ed83e6ae1815c326d12f47b Mon Sep 17 00:00:00 2001 From: Matthias Baesken Date: Mon, 23 Feb 2026 08:10:41 +0000 Subject: [PATCH 40/63] 8377798: Hotspot build on macOS aarch64 with unused-functions warning reports some unused functions Reviewed-by: jbechberger, dholmes --- .../cpu/aarch64/templateTable_aarch64.cpp | 4 --- src/hotspot/os/posix/perfMemory_posix.cpp | 2 ++ .../periodic/sampling/jfrSampleRequest.cpp | 30 ++----------------- .../periodic/sampling/jfrThreadSampling.cpp | 4 --- .../checkpoint/jfrCheckpointManager.cpp | 2 ++ .../jfr/support/jfrDeprecationManager.cpp | 2 ++ 6 files changed, 8 insertions(+), 36 deletions(-) diff --git a/src/hotspot/cpu/aarch64/templateTable_aarch64.cpp b/src/hotspot/cpu/aarch64/templateTable_aarch64.cpp index 5d4f7103a84..69769fb8441 100644 --- a/src/hotspot/cpu/aarch64/templateTable_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/templateTable_aarch64.cpp @@ -96,10 +96,6 @@ static inline Address aaddress(Register r) { return iaddress(r); } -static inline Address at_rsp() { - return Address(esp, 0); -} - // At top of Java expression stack which may be different than esp(). It // isn't for category 1 objects. static inline Address at_tos () { diff --git a/src/hotspot/os/posix/perfMemory_posix.cpp b/src/hotspot/os/posix/perfMemory_posix.cpp index ce9c2a4f031..d9bde6fa825 100644 --- a/src/hotspot/os/posix/perfMemory_posix.cpp +++ b/src/hotspot/os/posix/perfMemory_posix.cpp @@ -494,6 +494,7 @@ static char* get_user_name(uid_t uid) { return user_name; } +#ifndef __APPLE__ // return the name of the user that owns the process identified by vmid. // // This method uses a slow directory search algorithm to find the backing @@ -657,6 +658,7 @@ static char* get_user_name(int vmid, int *nspid, TRAPS) { #endif return result; } +#endif // return the file name of the backing store file for the named // shared memory region for the given user name and vmid. diff --git a/src/hotspot/share/jfr/periodic/sampling/jfrSampleRequest.cpp b/src/hotspot/share/jfr/periodic/sampling/jfrSampleRequest.cpp index 7049df0198b..68a47193e55 100644 --- a/src/hotspot/share/jfr/periodic/sampling/jfrSampleRequest.cpp +++ b/src/hotspot/share/jfr/periodic/sampling/jfrSampleRequest.cpp @@ -58,29 +58,22 @@ static inline bool in_stack(intptr_t* ptr, JavaThread* jt) { return jt->is_in_full_stack_checked(reinterpret_cast

    (ptr)); } +#ifdef ASSERT static inline bool sp_in_stack(const JfrSampleRequest& request, JavaThread* jt) { return in_stack(static_cast(request._sample_sp), jt); } +#endif // ASSERT static inline bool fp_in_stack(const JfrSampleRequest& request, JavaThread* jt) { return in_stack(static_cast(request._sample_bcp), jt); } -static inline void update_interpreter_frame_sender_pc(JfrSampleRequest& request, intptr_t* fp) { - request._sample_pc = frame::interpreter_return_address(fp); -} - static inline void update_interpreter_frame_pc(JfrSampleRequest& request, JavaThread* jt) { assert(fp_in_stack(request, jt), "invariant"); assert(is_interpreter(request), "invariant"); request._sample_pc = frame::interpreter_return_address(static_cast(request._sample_bcp)); } -static inline address interpreter_frame_return_address(const JfrSampleRequest& request) { - assert(is_interpreter(request), "invariant"); - return frame::interpreter_return_address(static_cast(request._sample_bcp)); -} - static inline intptr_t* frame_sender_sp(const JfrSampleRequest& request, JavaThread* jt) { assert(fp_in_stack(request, jt), "invariant"); return frame::sender_sp(static_cast(request._sample_bcp)); @@ -90,29 +83,10 @@ static inline void update_frame_sender_sp(JfrSampleRequest& request, JavaThread* request._sample_sp = frame_sender_sp(request, jt); } -static inline void update_frame_sender_sp(JfrSampleRequest& request, intptr_t* fp) { - request._sample_sp = frame::sender_sp(fp); -} - static inline intptr_t* frame_link(const JfrSampleRequest& request) { return frame::link(static_cast(request._sample_bcp)); } -static inline void update_sp(JfrSampleRequest& request, int frame_size) { - assert(frame_size >= 0, "invariant"); - request._sample_sp = static_cast(request._sample_sp) + frame_size; -} - -static inline void update_pc(JfrSampleRequest& request) { - assert(request._sample_sp != nullptr, "invariant"); - request._sample_pc = frame::return_address(static_cast(request._sample_sp)); -} - -static inline void update_fp(JfrSampleRequest& request) { - assert(request._sample_sp != nullptr, "invariant"); - request._sample_bcp = is_interpreter(request) ? frame::fp(static_cast(request._sample_sp)) : nullptr; -} - // Less extensive sanity checks for an interpreter frame. static bool is_valid_interpreter_frame(const JfrSampleRequest& request, JavaThread* jt) { assert(sp_in_stack(request, jt), "invariant"); diff --git a/src/hotspot/share/jfr/periodic/sampling/jfrThreadSampling.cpp b/src/hotspot/share/jfr/periodic/sampling/jfrThreadSampling.cpp index 534c9996cfe..7c0f8c02e69 100644 --- a/src/hotspot/share/jfr/periodic/sampling/jfrThreadSampling.cpp +++ b/src/hotspot/share/jfr/periodic/sampling/jfrThreadSampling.cpp @@ -66,10 +66,6 @@ static inline void send_safepoint_latency_event(const JfrSampleRequest& request, } } -static inline bool is_interpreter(address pc) { - return Interpreter::contains(pc); -} - static inline bool is_interpreter(const JfrSampleRequest& request) { return request._sample_bcp != nullptr; } diff --git a/src/hotspot/share/jfr/recorder/checkpoint/jfrCheckpointManager.cpp b/src/hotspot/share/jfr/recorder/checkpoint/jfrCheckpointManager.cpp index ff688a297ed..c6c1b4cad60 100644 --- a/src/hotspot/share/jfr/recorder/checkpoint/jfrCheckpointManager.cpp +++ b/src/hotspot/share/jfr/recorder/checkpoint/jfrCheckpointManager.cpp @@ -176,6 +176,7 @@ static inline bool is_global(ConstBufferPtr buffer) { return buffer->context() == JFR_GLOBAL; } +#ifdef ASSERT static inline bool is_thread_local(ConstBufferPtr buffer) { assert(buffer != nullptr, "invariant"); return buffer->context() == JFR_THREADLOCAL; @@ -185,6 +186,7 @@ static inline bool is_virtual_thread_local(ConstBufferPtr buffer) { assert(buffer != nullptr, "invariant"); return buffer->context() == JFR_VIRTUAL_THREADLOCAL; } +#endif // ASSERT BufferPtr JfrCheckpointManager::lease_global(Thread* thread, bool previous_epoch /* false */, size_t size /* 0 */) { JfrCheckpointMspace* const mspace = instance()._global_mspace; diff --git a/src/hotspot/share/jfr/support/jfrDeprecationManager.cpp b/src/hotspot/share/jfr/support/jfrDeprecationManager.cpp index 8886f412bb2..23e4cf839bd 100644 --- a/src/hotspot/share/jfr/support/jfrDeprecationManager.cpp +++ b/src/hotspot/share/jfr/support/jfrDeprecationManager.cpp @@ -194,9 +194,11 @@ static inline bool is_not_jdk_module(const ModuleEntry* module, JavaThread* jt) return !is_jdk_module(module, jt); } +#ifdef ASSERT static inline bool jfr_is_started_on_command_line() { return JfrRecorder::is_started_on_commandline(); } +#endif // ASSERT static bool should_record(const Method* method, const Method* sender, JavaThread* jt) { assert(method != nullptr, "invariant"); From 30f9b1b90c061a05c996b7569c78d3cc563a7aff Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 23 Feb 2026 08:41:00 +0000 Subject: [PATCH 41/63] 8377224: Initialization cleanups after Atomic conversion Reviewed-by: ayang, jsjolen --- src/hotspot/share/gc/g1/g1ConcurrentMark.cpp | 11 +++++------ src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp | 12 ------------ src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp | 2 -- src/hotspot/share/gc/g1/g1FullCollector.cpp | 6 ++++-- src/hotspot/share/gc/g1/g1RegionMarkStatsCache.hpp | 2 -- .../share/gc/g1/g1YoungGCPostEvacuateTasks.cpp | 5 ++--- .../share/gc/g1/g1YoungGCPreEvacuateTasks.cpp | 8 +++----- .../share/gc/shared/referenceProcessorPhaseTimes.cpp | 10 +++++++++- 8 files changed, 23 insertions(+), 33 deletions(-) diff --git a/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp b/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp index c739907e2b4..ec5649f4fe2 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp @@ -565,11 +565,10 @@ void G1ConcurrentMark::fully_initialize() { _tasks[i] = new G1CMTask(i, this, task_queue, _region_mark_stats); } - for (uint i = 0; i < _g1h->max_num_regions(); i++) { - ::new (&_region_mark_stats[i]) G1RegionMarkStats{}; - ::new (&_top_at_mark_starts[i]) Atomic{}; - ::new (&_top_at_rebuild_starts[i]) Atomic{}; - } + uint max_num_regions = _g1h->max_num_regions(); + ::new (_region_mark_stats) G1RegionMarkStats[max_num_regions]{}; + ::new (_top_at_mark_starts) Atomic[max_num_regions]{}; + ::new (_top_at_rebuild_starts) Atomic[max_num_regions]{}; reset_at_marking_complete(); } @@ -594,8 +593,8 @@ void G1ConcurrentMark::reset() { } uint max_num_regions = _g1h->max_num_regions(); + ::new (_top_at_rebuild_starts) Atomic[max_num_regions]{}; for (uint i = 0; i < max_num_regions; i++) { - _top_at_rebuild_starts[i].store_relaxed(nullptr); _region_mark_stats[i].clear(); } diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp index 5160d5ed036..c14c5658127 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.cpp @@ -26,18 +26,6 @@ #include "runtime/atomicAccess.hpp" #include "runtime/timer.hpp" -G1ConcurrentRefineStats::G1ConcurrentRefineStats() : - _sweep_duration(0), - _yield_during_sweep_duration(0), - _cards_scanned(0), - _cards_clean(0), - _cards_not_parsable(0), - _cards_already_refer_to_cset(0), - _cards_refer_to_cset(0), - _cards_no_cross_region(0), - _refine_duration(0) -{} - void G1ConcurrentRefineStats::add_atomic(G1ConcurrentRefineStats* other) { _sweep_duration.add_then_fetch(other->_sweep_duration.load_relaxed(), memory_order_relaxed); _yield_during_sweep_duration.add_then_fetch(other->yield_during_sweep_duration(), memory_order_relaxed); diff --git a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp index 5f57c56ba6c..a91ad0eb2e4 100644 --- a/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp +++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineStats.hpp @@ -47,8 +47,6 @@ class G1ConcurrentRefineStats : public CHeapObj { Atomic _refine_duration; // Time spent during actual refinement. public: - G1ConcurrentRefineStats(); - // Time spent performing sweeping the refinement table (includes actual refinement, // but not yield time). inline jlong sweep_duration() const; diff --git a/src/hotspot/share/gc/g1/g1FullCollector.cpp b/src/hotspot/share/gc/g1/g1FullCollector.cpp index b6388c2f722..e8498250f85 100644 --- a/src/hotspot/share/gc/g1/g1FullCollector.cpp +++ b/src/hotspot/share/gc/g1/g1FullCollector.cpp @@ -23,6 +23,7 @@ */ #include "classfile/classLoaderDataGraph.hpp" +#include "cppstdlib/new.hpp" #include "gc/g1/g1CollectedHeap.hpp" #include "gc/g1/g1FullCollector.inline.hpp" #include "gc/g1/g1FullGCAdjustTask.hpp" @@ -134,12 +135,13 @@ G1FullCollector::G1FullCollector(G1CollectedHeap* heap, _compaction_points = NEW_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _num_workers, mtGC); _live_stats = NEW_C_HEAP_ARRAY(G1RegionMarkStats, _heap->max_num_regions(), mtGC); - _compaction_tops = NEW_C_HEAP_ARRAY(Atomic, _heap->max_num_regions(), mtGC); for (uint j = 0; j < heap->max_num_regions(); j++) { _live_stats[j].clear(); - ::new (&_compaction_tops[j]) Atomic{}; } + _compaction_tops = NEW_C_HEAP_ARRAY(Atomic, _heap->max_num_regions(), mtGC); + ::new (_compaction_tops) Atomic[heap->max_num_regions()]{}; + _partial_array_state_manager = new PartialArrayStateManager(_num_workers); for (uint i = 0; i < _num_workers; i++) { diff --git a/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.hpp b/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.hpp index b8f13f4553d..4dcdd33846e 100644 --- a/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.hpp +++ b/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.hpp @@ -44,8 +44,6 @@ struct G1RegionMarkStats { Atomic _live_words; Atomic _incoming_refs; - G1RegionMarkStats() : _live_words(0), _incoming_refs(0) { } - // Clear all members. void clear() { _live_words.store_relaxed(0); diff --git a/src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp b/src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp index 557941981e4..a0013d27172 100644 --- a/src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp +++ b/src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp @@ -24,6 +24,7 @@ #include "compiler/oopMap.hpp" +#include "cppstdlib/new.hpp" #include "gc/g1/g1CardSetMemory.hpp" #include "gc/g1/g1CardTableEntryClosure.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" @@ -814,9 +815,7 @@ public: void set_max_workers(uint max_workers) override { _active_workers = max_workers; _worker_stats = NEW_C_HEAP_ARRAY(FreeCSetStats, max_workers, mtGC); - for (uint worker = 0; worker < _active_workers; worker++) { - ::new (&_worker_stats[worker]) FreeCSetStats(); - } + ::new (_worker_stats) FreeCSetStats[_active_workers]{}; _claimer.set_n_workers(_active_workers); } diff --git a/src/hotspot/share/gc/g1/g1YoungGCPreEvacuateTasks.cpp b/src/hotspot/share/gc/g1/g1YoungGCPreEvacuateTasks.cpp index c0870b7a726..936457659b6 100644 --- a/src/hotspot/share/gc/g1/g1YoungGCPreEvacuateTasks.cpp +++ b/src/hotspot/share/gc/g1/g1YoungGCPreEvacuateTasks.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 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 @@ -22,6 +22,7 @@ * */ +#include "cppstdlib/new.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1RegionPinCache.inline.hpp" #include "gc/g1/g1ThreadLocalData.hpp" @@ -89,10 +90,7 @@ public: void set_max_workers(uint max_workers) override { _num_workers = max_workers; _local_tlab_stats = NEW_C_HEAP_ARRAY(ThreadLocalAllocStats, _num_workers, mtGC); - - for (uint i = 0; i < _num_workers; i++) { - ::new (&_local_tlab_stats[i]) ThreadLocalAllocStats(); - } + ::new (_local_tlab_stats) ThreadLocalAllocStats[_num_workers]{}; } ThreadLocalAllocStats tlab_stats() const { diff --git a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp index 0371ed2c73b..fc7ef75c1be 100644 --- a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp +++ b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp @@ -152,7 +152,15 @@ RefProcTotalPhaseTimesTracker::~RefProcTotalPhaseTimesTracker() { } ReferenceProcessorPhaseTimes::ReferenceProcessorPhaseTimes(GCTimer* gc_timer, uint max_gc_threads) : - _processing_is_mt(false), _gc_timer(gc_timer) { + _sub_phases_worker_time_sec{}, + _balance_queues_time_ms{}, + _soft_weak_final_refs_phase_worker_time_sec(nullptr), + _total_time_ms(0.0), + _ref_dropped{}, + _ref_discovered{}, + _processing_is_mt(false), + _gc_timer(gc_timer) { + assert(gc_timer != nullptr, "pre-condition"); for (uint i = 0; i < ReferenceProcessor::RefSubPhaseMax; i++) { _sub_phases_worker_time_sec[i] = new WorkerDataArray(nullptr, SubPhasesParWorkTitle[i], max_gc_threads); From a9542746e7289fff6f4d5e7482e68e37c79e41d0 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Mon, 23 Feb 2026 09:27:53 +0000 Subject: [PATCH 42/63] 8375359: Improve GC serviceability init staging Reviewed-by: ayang, tschatzl, stefank --- src/hotspot/share/gc/epsilon/epsilonHeap.cpp | 4 + src/hotspot/share/gc/epsilon/epsilonHeap.hpp | 1 + src/hotspot/share/gc/shared/collectedHeap.cpp | 1 - src/hotspot/share/gc/shared/collectedHeap.hpp | 6 +- src/hotspot/share/memory/universe.cpp | 9 +- src/hotspot/share/services/memoryService.cpp | 8 +- src/hotspot/share/services/memoryService.hpp | 2 +- .../jtreg/gc/epsilon/TestInitAllocs.java | 120 +++++++++++------- 8 files changed, 96 insertions(+), 55 deletions(-) diff --git a/src/hotspot/share/gc/epsilon/epsilonHeap.cpp b/src/hotspot/share/gc/epsilon/epsilonHeap.cpp index 59ab69b2427..004a36147fc 100644 --- a/src/hotspot/share/gc/epsilon/epsilonHeap.cpp +++ b/src/hotspot/share/gc/epsilon/epsilonHeap.cpp @@ -75,6 +75,10 @@ jint EpsilonHeap::initialize() { void EpsilonHeap::initialize_serviceability() { _pool = new EpsilonMemoryPool(this); _memory_manager.add_pool(_pool); +} + +void EpsilonHeap::post_initialize() { + CollectedHeap::post_initialize(); _monitoring_support->mark_ready(); } diff --git a/src/hotspot/share/gc/epsilon/epsilonHeap.hpp b/src/hotspot/share/gc/epsilon/epsilonHeap.hpp index 8d7aa7960fd..ef75f7c1bb9 100644 --- a/src/hotspot/share/gc/epsilon/epsilonHeap.hpp +++ b/src/hotspot/share/gc/epsilon/epsilonHeap.hpp @@ -69,6 +69,7 @@ public: jint initialize() override; void initialize_serviceability() override; + void post_initialize() override; GrowableArray memory_managers() override; GrowableArray memory_pools() override; diff --git a/src/hotspot/share/gc/shared/collectedHeap.cpp b/src/hotspot/share/gc/shared/collectedHeap.cpp index a59ea3745ab..9db23df7ace 100644 --- a/src/hotspot/share/gc/shared/collectedHeap.cpp +++ b/src/hotspot/share/gc/shared/collectedHeap.cpp @@ -598,7 +598,6 @@ void CollectedHeap::initialize_reserved_region(const ReservedHeapSpace& rs) { void CollectedHeap::post_initialize() { StringDedup::initialize(); - initialize_serviceability(); } bool CollectedHeap::is_shutting_down() { diff --git a/src/hotspot/share/gc/shared/collectedHeap.hpp b/src/hotspot/share/gc/shared/collectedHeap.hpp index 363ccf321b2..f13c3ab7b6e 100644 --- a/src/hotspot/share/gc/shared/collectedHeap.hpp +++ b/src/hotspot/share/gc/shared/collectedHeap.hpp @@ -241,6 +241,10 @@ protected: */ virtual jint initialize() = 0; + // Initialize serviceability support. This should prepare the implementation + // for accepting serviceability-related calls, like memory_managers(), memory_pools(). + virtual void initialize_serviceability() = 0; + // In many heaps, there will be a need to perform some initialization activities // after the Universe is fully formed, but before general heap allocation is allowed. // This is the correct place to place such initialization methods. @@ -419,8 +423,6 @@ protected: // Generate any dumps preceding or following a full gc void full_gc_dump(GCTimer* timer, bool before); - virtual void initialize_serviceability() = 0; - void print_relative_to_gc(GCWhen::Type when) const; public: diff --git a/src/hotspot/share/memory/universe.cpp b/src/hotspot/share/memory/universe.cpp index cfbab1b8afb..a78b245cc07 100644 --- a/src/hotspot/share/memory/universe.cpp +++ b/src/hotspot/share/memory/universe.cpp @@ -1182,13 +1182,12 @@ bool universe_post_init() { Universe::heap()->update_capacity_and_used_at_gc(); } - // ("weak") refs processing infrastructure initialization + // Initialize serviceability + MemoryService::initialize(Universe::heap()); + + // Complete initialization Universe::heap()->post_initialize(); - MemoryService::add_metaspace_memory_pools(); - - MemoryService::set_universe_heap(Universe::heap()); - #if INCLUDE_CDS AOTMetaspace::post_initialize(CHECK_false); #endif diff --git a/src/hotspot/share/services/memoryService.cpp b/src/hotspot/share/services/memoryService.cpp index cd53f44e053..f64da3c5477 100644 --- a/src/hotspot/share/services/memoryService.cpp +++ b/src/hotspot/share/services/memoryService.cpp @@ -66,7 +66,13 @@ void GcThreadCountClosure::do_thread(Thread* thread) { _count++; } -void MemoryService::set_universe_heap(CollectedHeap* heap) { +void MemoryService::initialize(CollectedHeap* heap) { + // Prepare metaspace pools + add_metaspace_memory_pools(); + + // Ask heap to initialize its memory pools/managers + heap->initialize_serviceability(); + ResourceMark rm; // For internal allocations in GrowableArray. GrowableArray gc_mem_pools = heap->memory_pools(); diff --git a/src/hotspot/share/services/memoryService.hpp b/src/hotspot/share/services/memoryService.hpp index d10c3d2e9d9..1a947ec1d0c 100644 --- a/src/hotspot/share/services/memoryService.hpp +++ b/src/hotspot/share/services/memoryService.hpp @@ -60,7 +60,7 @@ private: static MemoryPool* _compressed_class_pool; public: - static void set_universe_heap(CollectedHeap* heap); + static void initialize(CollectedHeap* heap); static void add_code_heap_memory_pool(CodeHeap* heap, const char* name); static void add_metaspace_memory_pools(); diff --git a/test/hotspot/jtreg/gc/epsilon/TestInitAllocs.java b/test/hotspot/jtreg/gc/epsilon/TestInitAllocs.java index 353daaef8b6..cdfd29bad61 100644 --- a/test/hotspot/jtreg/gc/epsilon/TestInitAllocs.java +++ b/test/hotspot/jtreg/gc/epsilon/TestInitAllocs.java @@ -23,54 +23,84 @@ package gc.epsilon; -/** - * @test TestInitAllocs +import java.util.Arrays; +import java.util.ArrayList; +import java.util.List; + +import jdk.test.lib.process.OutputAnalyzer; +import jdk.test.lib.process.ProcessTools; + +/* @test id=default * @requires vm.gc.Epsilon - * @summary Test that allocation path taken in early JVM phases works - * - * @run main/othervm -Xmx256m - * -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC - * gc.epsilon.TestInitAllocs - * - * @run main/othervm -Xmx256m - * -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC - * -XX:+UseTLAB - * -XX:+UseCompressedOops - * -XX:EpsilonMinHeapExpand=1024 - * -XX:EpsilonUpdateCountersStep=1 - * -XX:EpsilonPrintHeapSteps=1000000 - * gc.epsilon.TestInitAllocs - * - * @run main/othervm -Xmx256m - * -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC - * -XX:+UseTLAB - * -XX:-UseCompressedOops - * -XX:EpsilonMinHeapExpand=1024 - * -XX:EpsilonUpdateCountersStep=1 - * -XX:EpsilonPrintHeapSteps=1000000 - * gc.epsilon.TestInitAllocs - * - * @run main/othervm -Xmx256m - * -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC - * -XX:-UseTLAB - * -XX:+UseCompressedOops - * -XX:EpsilonMinHeapExpand=1024 - * -XX:EpsilonUpdateCountersStep=1 - * -XX:EpsilonPrintHeapSteps=1000000 - * gc.epsilon.TestInitAllocs - * - * @run main/othervm -Xmx256m - * -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC - * -XX:-UseTLAB - * -XX:-UseCompressedOops - * -XX:EpsilonMinHeapExpand=1024 - * -XX:EpsilonUpdateCountersStep=1 - * -XX:EpsilonPrintHeapSteps=1000000 - * gc.epsilon.TestInitAllocs + * @summary Stress test that allocation path taken in early JVM phases works + * @library /test/lib + * @run driver gc.epsilon.TestInitAllocs + */ + +/* @test id=nocoops + * @requires vm.gc.Epsilon + * @library /test/lib + * @run driver gc.epsilon.TestInitAllocs -XX:-UseCompressedOops + */ + +/* @test id=notlabs + * @requires vm.gc.Epsilon + * @library /test/lib + * @run driver gc.epsilon.TestInitAllocs -XX:-UseTLAB + */ + +/* @test id=notlabs-nocoops + * @requires vm.gc.Epsilon + * @library /test/lib + * @run driver gc.epsilon.TestInitAllocs -XX:-UseCompressedOops -XX:-UseTLAB + */ + +/* @test id=coh + * @requires vm.gc.Epsilon + * @library /test/lib + * @run driver gc.epsilon.TestInitAllocs -XX:+UseCompactObjectHeaders + */ + +/* @test id=coh-nocoops + * @requires vm.gc.Epsilon + * @library /test/lib + * @run driver gc.epsilon.TestInitAllocs -XX:+UseCompactObjectHeaders -XX:-UseCompressedOops + */ + +/* @test id=coh-notlabs + * @requires vm.gc.Epsilon + * @library /test/lib + * @run driver gc.epsilon.TestInitAllocs -XX:+UseCompactObjectHeaders -XX:-UseTLAB + */ + +/* @test id=coh-notlabs-nocoops + * @requires vm.gc.Epsilon + * @library /test/lib + * @run driver gc.epsilon.TestInitAllocs -XX:+UseCompactObjectHeaders -XX:-UseCompressedOops -XX:-UseTLAB */ public class TestInitAllocs { - public static void main(String[] args) throws Exception { - System.out.println("Hello World"); + static final Integer TRIES = Integer.getInteger("tries", 500); + + public static void main(String... args) throws Exception { + List testArgs = new ArrayList<>(); + testArgs.add("-Xmx256m"); + testArgs.add("-XX:+UnlockExperimentalVMOptions"); + testArgs.add("-XX:+UseEpsilonGC"); + testArgs.add("-XX:EpsilonMinHeapExpand=1024"); + testArgs.add("-XX:EpsilonUpdateCountersStep=1"); + testArgs.add("-XX:EpsilonPrintHeapSteps=1000000"); + testArgs.addAll(Arrays.asList(args)); + testArgs.add(TestInitAllocs.Main.class.getName()); + for (int t = 0; t < TRIES; t++) { + OutputAnalyzer oa = ProcessTools.executeLimitedTestJava(testArgs); + oa.shouldHaveExitValue(0); + } + } + + static class Main { + public static void main(String... args) { + // Do nothing + } } } From 0f70a9a92498992ecc863fdd4653ee155b1ac19a Mon Sep 17 00:00:00 2001 From: Kevin Walls Date: Mon, 23 Feb 2026 09:28:10 +0000 Subject: [PATCH 43/63] 8377433: Test com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.java failed Reviewed-by: sspitsyn --- .../remote/NotificationMarshalVersions/Client/Client.java | 7 ++++--- .../TestSerializationMismatch.java | 5 ++++- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/test/jdk/com/sun/jmx/remote/NotificationMarshalVersions/Client/Client.java b/test/jdk/com/sun/jmx/remote/NotificationMarshalVersions/Client/Client.java index 80931ca7440..76acac11506 100644 --- a/test/jdk/com/sun/jmx/remote/NotificationMarshalVersions/Client/Client.java +++ b/test/jdk/com/sun/jmx/remote/NotificationMarshalVersions/Client/Client.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 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 @@ -35,10 +35,11 @@ import javax.management.remote.JMXConnectionNotification; import javax.management.remote.JMXConnector; import javax.management.remote.JMXConnectorFactory; import javax.management.remote.JMXServiceURL; +import jdk.test.lib.Utils; public class Client { - public static final int COUNTER_TIMEOUT_SECONDS = 60; + public static final int COUNTER_TIMEOUT_SECONDS = 30; public static void run(String url) throws Exception { final int notifEmittedCnt = 10; @@ -87,7 +88,7 @@ public class Client { System.out.println(); try { System.out.println("waiting for " + notifEmittedCnt + " notifications to arrive"); - if (!counter.await(COUNTER_TIMEOUT_SECONDS, TimeUnit.SECONDS)) { + if (!counter.await(Utils.adjustTimeout(COUNTER_TIMEOUT_SECONDS), TimeUnit.SECONDS)) { throw new Error("Client: Counter await expired"); } if (duplNotification.get()) { diff --git a/test/jdk/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.java b/test/jdk/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.java index 0e5e5e30d4e..5fac14d76e3 100644 --- a/test/jdk/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.java +++ b/test/jdk/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved. + * 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 @@ -33,6 +33,9 @@ import java.util.Arrays; * @author Jaroslav Bachorik * @bug 6937053 8005472 * + * @library /test/lib + * @build jdk.test.lib.Utils + * * @modules java.management * jdk.compiler * @run clean TestSerializationMismatch From 2a9d144f2659f35e2c54543d36ac0bb049964a99 Mon Sep 17 00:00:00 2001 From: Quan Anh Mai Date: Mon, 23 Feb 2026 09:36:31 +0000 Subject: [PATCH 44/63] 8377652: C2: Simplify Compile::flatten_alias_type for array Reviewed-by: roland, mhaessig --- src/hotspot/share/opto/compile.cpp | 87 +++++++++--------------------- 1 file changed, 26 insertions(+), 61 deletions(-) diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp index 80bb1dcf408..f1ea8231df9 100644 --- a/src/hotspot/share/opto/compile.cpp +++ b/src/hotspot/share/opto/compile.cpp @@ -1369,72 +1369,37 @@ const TypePtr *Compile::flatten_alias_type( const TypePtr *tj ) const { cast_to_ptr_type(ptr)-> with_offset(offset); } - } else if (ta) { - // For arrays indexed by constant indices, we flatten the alias - // space to include all of the array body. Only the header, klass - // and array length can be accessed un-aliased. - if( offset != Type::OffsetBot ) { - if( ta->const_oop() ) { // MethodData* or Method* - offset = Type::OffsetBot; // Flatten constant access into array body - tj = ta = ta-> - remove_speculative()-> - cast_to_ptr_type(ptr)-> - cast_to_exactness(false)-> - with_offset(offset); - } else if( offset == arrayOopDesc::length_offset_in_bytes() ) { - // range is OK as-is. - tj = ta = TypeAryPtr::RANGE; - } else if( offset == oopDesc::klass_offset_in_bytes() ) { - tj = TypeInstPtr::KLASS; // all klass loads look alike - ta = TypeAryPtr::RANGE; // generic ignored junk - ptr = TypePtr::BotPTR; - } else if( offset == oopDesc::mark_offset_in_bytes() ) { - tj = TypeInstPtr::MARK; - ta = TypeAryPtr::RANGE; // generic ignored junk - ptr = TypePtr::BotPTR; - } else { // Random constant offset into array body - offset = Type::OffsetBot; // Flatten constant access into array body - tj = ta = ta-> - remove_speculative()-> - cast_to_ptr_type(ptr)-> - cast_to_exactness(false)-> - with_offset(offset); - } + } else if (ta != nullptr) { + // Common slices + if (offset == arrayOopDesc::length_offset_in_bytes()) { + return TypeAryPtr::RANGE; + } else if (offset == oopDesc::klass_offset_in_bytes()) { + return TypeInstPtr::KLASS; + } else if (offset == oopDesc::mark_offset_in_bytes()) { + return TypeInstPtr::MARK; } - // Arrays of fixed size alias with arrays of unknown size. - if (ta->size() != TypeInt::POS) { - const TypeAry *tary = TypeAry::make(ta->elem(), TypeInt::POS); - tj = ta = ta-> - remove_speculative()-> - cast_to_ptr_type(ptr)-> - with_ary(tary)-> - cast_to_exactness(false); - } - // Arrays of known objects become arrays of unknown objects. - if (ta->elem()->isa_narrowoop() && ta->elem() != TypeNarrowOop::BOTTOM) { - const TypeAry *tary = TypeAry::make(TypeNarrowOop::BOTTOM, ta->size()); - tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,nullptr,false,offset); - } - if (ta->elem()->isa_oopptr() && ta->elem() != TypeInstPtr::BOTTOM) { - const TypeAry *tary = TypeAry::make(TypeInstPtr::BOTTOM, ta->size()); - tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,nullptr,false,offset); + + // Remove size and stability + const TypeAry* normalized_ary = TypeAry::make(ta->elem(), TypeInt::POS, false); + // Remove ptr, const_oop, and offset + if (ta->elem() == Type::BOTTOM) { + // Bottom array (meet of int[] and byte[] for example), accesses to it will be done with + // Unsafe. This should alias with all arrays. For now just leave it as it is (this is + // incorrect, see JDK-8331133). + tj = ta = TypeAryPtr::make(TypePtr::BotPTR, nullptr, normalized_ary, nullptr, false, Type::OffsetBot); + } else if (ta->elem()->make_oopptr() != nullptr) { + // Object arrays, all of them share the same slice + const TypeAry* tary = TypeAry::make(TypeInstPtr::BOTTOM, TypeInt::POS, false); + tj = ta = TypeAryPtr::make(TypePtr::BotPTR, nullptr, tary, nullptr, false, Type::OffsetBot); + } else { + // Primitive arrays + tj = ta = TypeAryPtr::make(TypePtr::BotPTR, nullptr, normalized_ary, ta->exact_klass(), true, Type::OffsetBot); } + // Arrays of bytes and of booleans both use 'bastore' and 'baload' so // cannot be distinguished by bytecode alone. if (ta->elem() == TypeInt::BOOL) { - const TypeAry *tary = TypeAry::make(TypeInt::BYTE, ta->size()); - ciKlass* aklass = ciTypeArrayKlass::make(T_BYTE); - tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,aklass,false,offset); - } - // During the 2nd round of IterGVN, NotNull castings are removed. - // Make sure the Bottom and NotNull variants alias the same. - // Also, make sure exact and non-exact variants alias the same. - if (ptr == TypePtr::NotNull || ta->klass_is_exact() || ta->speculative() != nullptr) { - tj = ta = ta-> - remove_speculative()-> - cast_to_ptr_type(TypePtr::BotPTR)-> - cast_to_exactness(false)-> - with_offset(offset); + tj = ta = TypeAryPtr::BYTES; } } From c065f4119a527789fbe86494b068ab487a59d801 Mon Sep 17 00:00:00 2001 From: Jan Lahoda Date: Mon, 23 Feb 2026 09:43:07 +0000 Subject: [PATCH 45/63] 8308637: AssertionError when using Trees.getScope in plug-in Reviewed-by: vromero --- .../com/sun/tools/javac/comp/Attr.java | 23 ++-- .../tools/javac/api/TestGetScopeResult.java | 109 +++++++++++++++++- 2 files changed, 121 insertions(+), 11 deletions(-) diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java index cdd88b22510..d4bfbce0699 100644 --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java @@ -680,10 +680,7 @@ public class Attr extends JCTree.Visitor { } matchBindings = matchBindingsComputer.finishBindings(tree, matchBindings); - if (tree == breakTree && - resultInfo.checkContext.deferredAttrContext().mode == AttrMode.CHECK) { - breakTreeFound(copyEnv(env)); - } + checkBreakTree(tree, env); return result; } catch (CompletionFailure ex) { tree.type = syms.errType; @@ -694,6 +691,13 @@ public class Attr extends JCTree.Visitor { } } + private void checkBreakTree(JCTree tree, Env env) { + if (tree == breakTree && + resultInfo.checkContext.deferredAttrContext().mode == AttrMode.CHECK) { + breakTreeFound(copyEnv(env)); + } + } + protected void breakTreeFound(Env env) { throw new BreakAttr(env); } @@ -2813,6 +2817,8 @@ public class Attr extends JCTree.Visitor { checkNewInnerClass(tree.pos(), env, clazztype, false); } + checkBreakTree(tree.clazz, localEnv); + // Attribute constructor arguments. ListBuffer argtypesBuf = new ListBuffer<>(); final KindSelector pkind = @@ -3250,10 +3256,8 @@ public class Attr extends JCTree.Visitor { attribTree(that.getBody(), localEnv, bodyResultInfo); } else { JCBlock body = (JCBlock)that.body; - if (body == breakTree && - resultInfo.checkContext.deferredAttrContext().mode == AttrMode.CHECK) { - breakTreeFound(copyEnv(localEnv)); - } + + checkBreakTree(body, localEnv); attribStats(body.stats, localEnv); } @@ -5390,7 +5394,8 @@ public class Attr extends JCTree.Visitor { Type st = types.supertype(c.type); if ((c.flags_field & Flags.COMPOUND) == 0 && - (c.flags_field & Flags.SUPER_OWNER_ATTRIBUTED) == 0) { + (c.flags_field & Flags.SUPER_OWNER_ATTRIBUTED) == 0 && + breakTree == null) { // First, attribute superclass. if (st.hasTag(CLASS)) attribClass((ClassSymbol)st.tsym); diff --git a/test/langtools/tools/javac/api/TestGetScopeResult.java b/test/langtools/tools/javac/api/TestGetScopeResult.java index 533c640096e..adae4ccdb5a 100644 --- a/test/langtools/tools/javac/api/TestGetScopeResult.java +++ b/test/langtools/tools/javac/api/TestGetScopeResult.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 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 @@ -23,7 +23,7 @@ /* * @test - * @bug 8205418 8207229 8207230 8230847 8245786 8247334 8248641 8240658 8246774 8274347 8347989 + * @bug 8205418 8207229 8207230 8230847 8245786 8247334 8248641 8240658 8246774 8274347 8347989 8308637 * @summary Test the outcomes from Trees.getScope * @modules jdk.compiler/com.sun.tools.javac.api * jdk.compiler/com.sun.tools.javac.comp @@ -100,6 +100,7 @@ public class TestGetScopeResult { new TestGetScopeResult().testNestedSwitchExpression(); new TestGetScopeResult().testModuleImportScope(); new TestGetScopeResult().testClassTypeSetInEnterGetScope(); + new TestGetScopeResult().testNotYetAttributedGetScope(); } public void run() throws IOException { @@ -966,6 +967,110 @@ public class TestGetScopeResult { } } + void testNotYetAttributedGetScope() throws IOException { //JDK-8308637 + JavacTool c = JavacTool.create(); + record TestCase(String code, List> expected) {} + TestCase[] cases = new TestCase[] { + new TestCase(""" + class B { + public class Test {} + void m() { + this.new Test() {}; + } + } + """, + List.of(List.of("super:java.lang.Object", + "this:B"))), + new TestCase(""" + class B { + public class Test {} + void m() { + int local1 = 0; + new Test() {}; + this.new Test() {}; + class Inner { + class InnerNested { + void m() { + int local2 = 0; + new Test() {}; + B.this.new Test() {}; + } + } + } + } + } + """, + List.of( + List.of("local1:int", + "super:java.lang.Object", + "this:B"), + List.of(":", + "local1:int", + "super:java.lang.Object", + "this:B"), + List.of("local2:int", + "super:java.lang.Object", + "this:Inner.InnerNested", + "super:java.lang.Object", + "this:Inner", + "Inner:Inner", + ":", + ":", + "local1:int", + "super:java.lang.Object", + "this:B"), + List.of(":", + "local2:int", + "super:java.lang.Object", + "this:Inner.InnerNested", + "super:java.lang.Object", + "this:Inner", + "Inner:Inner", + ":", + ":", + "local1:int", + "super:java.lang.Object", + "this:B") + )), + }; + try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) { + for (TestCase tc : cases) { + JavaFileObject input = + SimpleJavaFileObject.forSource(URI.create("myfo:///Test.java"), tc.code()); + JavacTask t = (JavacTask) c.getTask(null, fm, null, null, null, + List.of(input)); + Trees trees = Trees.instance(t); + List> actual = new ArrayList<>(); + + t.addTaskListener(new TaskListener() { + @Override + public void finished(TaskEvent e) { + if (e.getKind() == TaskEvent.Kind.ENTER) { + new TreePathScanner() { + @Override + public Void visitIdentifier(IdentifierTree node, Void p) { + if (node.getName().contentEquals("Test")) { + Scope scope = trees.getScope(getCurrentPath()); + actual.add(dumpScope(scope)); + } + return super.visitIdentifier(node, p); + } + }.scan(e.getCompilationUnit(), null); + } + } + + }); + + t.analyze(); + + if (!tc.expected().equals(actual)) { + throw new AssertionError("Unexpected Scope content: " + actual + + ", expected: " + tc.expected()); + } + } + } + } + private List dumpScope(Scope scope) { List content = new ArrayList<>(); while (scope.getEnclosingClass() != null) { From c701647b32c43a12428919fcb39cbcec7ccebea3 Mon Sep 17 00:00:00 2001 From: Jaikiran Pai Date: Mon, 23 Feb 2026 10:21:57 +0000 Subject: [PATCH 46/63] 8378397: Disable usage of system level jshell history in test/hotspot/jtreg/runtime/os/TestWXHealing.java Reviewed-by: dholmes, jlahoda --- test/hotspot/jtreg/runtime/os/WXHealing.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/hotspot/jtreg/runtime/os/WXHealing.java b/test/hotspot/jtreg/runtime/os/WXHealing.java index ba790db2c59..eb5c5ad7b4b 100644 --- a/test/hotspot/jtreg/runtime/os/WXHealing.java +++ b/test/hotspot/jtreg/runtime/os/WXHealing.java @@ -22,6 +22,8 @@ */ import java.io.*; +import java.util.HashMap; + import jdk.jshell.tool.*; public class WXHealing { @@ -31,6 +33,8 @@ public class WXHealing { public static void main(String[] args) throws Throwable { JavaShellToolBuilder .builder() + // we don't need system level history/storage for this test + .persistence(new HashMap<>()) .in(new ByteArrayInputStream (""" void main() { From 9ea62c258cc880272206a065d73f69fcd7416939 Mon Sep 17 00:00:00 2001 From: Albert Mingkun Yang Date: Mon, 23 Feb 2026 10:31:44 +0000 Subject: [PATCH 47/63] 8378348: Obsolete ParallelRefProcEnabled Reviewed-by: jsikstro, tschatzl --- src/hotspot/share/gc/g1/g1Arguments.cpp | 4 - src/hotspot/share/gc/g1/g1CollectedHeap.cpp | 3 +- .../share/gc/parallel/parallelArguments.cpp | 4 - src/hotspot/share/gc/shared/gc_globals.hpp | 4 - .../share/gc/shared/referenceProcessor.cpp | 2 +- src/hotspot/share/gc/shared/weakProcessor.cpp | 1 - src/hotspot/share/runtime/arguments.cpp | 2 +- .../gc/arguments/TestParallelRefProc.java | 121 ------------------ .../TestDynamicNumberOfGCThreads.java | 8 -- .../jtreg/gc/logging/TestPrintReferences.java | 40 +++--- 10 files changed, 19 insertions(+), 170 deletions(-) delete mode 100644 test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java diff --git a/src/hotspot/share/gc/g1/g1Arguments.cpp b/src/hotspot/share/gc/g1/g1Arguments.cpp index ffb06a7d822..8bec6e7e86f 100644 --- a/src/hotspot/share/gc/g1/g1Arguments.cpp +++ b/src/hotspot/share/gc/g1/g1Arguments.cpp @@ -242,10 +242,6 @@ void G1Arguments::initialize() { FLAG_SET_DEFAULT(GCPauseIntervalMillis, MaxGCPauseMillis + 1); } - if (FLAG_IS_DEFAULT(ParallelRefProcEnabled) && ParallelGCThreads > 1) { - FLAG_SET_DEFAULT(ParallelRefProcEnabled, true); - } - #ifdef COMPILER2 // Enable loop strip mining to offer better pause time guarantees if (FLAG_IS_DEFAULT(UseCountedLoopSafepoints)) { diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp index 8fc2c7c9941..3f5d674c443 100644 --- a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp +++ b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp @@ -1723,8 +1723,7 @@ void G1CollectedHeap::ref_processing_init() { // * Reference discovery is MT (see below). // * Reference discovery requires a barrier (see below). // * Reference processing may or may not be MT - // (depending on the value of ParallelRefProcEnabled - // and ParallelGCThreads). + // (depending on the value of ParallelGCThreads). // * A full GC disables reference discovery by the CM // ref processor and abandons any entries on it's // discovered lists. diff --git a/src/hotspot/share/gc/parallel/parallelArguments.cpp b/src/hotspot/share/gc/parallel/parallelArguments.cpp index be9673224f5..a856078edab 100644 --- a/src/hotspot/share/gc/parallel/parallelArguments.cpp +++ b/src/hotspot/share/gc/parallel/parallelArguments.cpp @@ -128,10 +128,6 @@ void ParallelArguments::initialize() { } } - if (FLAG_IS_DEFAULT(ParallelRefProcEnabled) && ParallelGCThreads > 1) { - FLAG_SET_DEFAULT(ParallelRefProcEnabled, true); - } - FullGCForwarding::initialize_flags(heap_reserved_size_bytes()); } diff --git a/src/hotspot/share/gc/shared/gc_globals.hpp b/src/hotspot/share/gc/shared/gc_globals.hpp index 8e1073db022..9235029f254 100644 --- a/src/hotspot/share/gc/shared/gc_globals.hpp +++ b/src/hotspot/share/gc/shared/gc_globals.hpp @@ -198,10 +198,6 @@ constraint(MarkStackSizeConstraintFunc,AfterErgo) \ range(1, (INT_MAX - 1)) \ \ - product(bool, ParallelRefProcEnabled, false, \ - "(Deprecated) Enable parallel reference processing " \ - "whenever possible") \ - \ product(size_t, ReferencesPerThread, 1000, EXPERIMENTAL, \ "Ergonomically start one thread for this amount of " \ "references for reference processing if " \ diff --git a/src/hotspot/share/gc/shared/referenceProcessor.cpp b/src/hotspot/share/gc/shared/referenceProcessor.cpp index bff097711ca..b82db08ecbd 100644 --- a/src/hotspot/share/gc/shared/referenceProcessor.cpp +++ b/src/hotspot/share/gc/shared/referenceProcessor.cpp @@ -122,7 +122,7 @@ void ReferenceProcessor::verify_no_references_recorded() { #endif bool ReferenceProcessor::processing_is_mt() const { - return ParallelRefProcEnabled && _num_queues > 1; + return _num_queues > 1; } void ReferenceProcessor::weak_oops_do(OopClosure* f) { diff --git a/src/hotspot/share/gc/shared/weakProcessor.cpp b/src/hotspot/share/gc/shared/weakProcessor.cpp index bc7e9ad6375..071a004454a 100644 --- a/src/hotspot/share/gc/shared/weakProcessor.cpp +++ b/src/hotspot/share/gc/shared/weakProcessor.cpp @@ -72,7 +72,6 @@ void WeakProcessor::oops_do(OopClosure* closure) { } uint WeakProcessor::ergo_workers(uint max_workers) { - // Ignore ParallelRefProcEnabled; that's for j.l.r.Reference processing. if (ReferencesPerThread == 0) { // Configuration says always use all the threads. return max_workers; diff --git a/src/hotspot/share/runtime/arguments.cpp b/src/hotspot/share/runtime/arguments.cpp index c87be03ad0c..ca8ca0e9b8f 100644 --- a/src/hotspot/share/runtime/arguments.cpp +++ b/src/hotspot/share/runtime/arguments.cpp @@ -536,7 +536,6 @@ static SpecialFlag const special_jvm_flags[] = { #ifdef _LP64 { "UseCompressedClassPointers", JDK_Version::jdk(25), JDK_Version::jdk(27), JDK_Version::undefined() }, #endif - { "ParallelRefProcEnabled", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, { "MaxRAM", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, { "AggressiveHeap", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, { "NeverActAsServerClassMachine", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, @@ -552,6 +551,7 @@ static SpecialFlag const special_jvm_flags[] = { #endif { "PSChunkLargeArrays", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, + { "ParallelRefProcEnabled", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, { "ParallelRefProcBalancingEnabled", JDK_Version::jdk(26), JDK_Version::jdk(27), JDK_Version::jdk(28) }, #ifdef ASSERT diff --git a/test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java b/test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java deleted file mode 100644 index 2cd9e9cd60b..00000000000 --- a/test/hotspot/jtreg/gc/arguments/TestParallelRefProc.java +++ /dev/null @@ -1,121 +0,0 @@ -/* - * Copyright (c) 2018, 2025, 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. - */ - -package gc.arguments; - -/* - * @test id=Serial - * @summary Test defaults processing for -XX:+ParallelRefProcEnabled with Serial GC. - * @library /test/lib - * @library / - * @requires vm.gc.Serial - * @run driver gc.arguments.TestParallelRefProc Serial - */ - -/* - * @test id=Parallel - * @summary Test defaults processing for -XX:+ParallelRefProcEnabled with Parallel GC. - * @library /test/lib - * @library / - * @requires vm.gc.Parallel - * @run driver gc.arguments.TestParallelRefProc Parallel - */ - -/* - * @test id=G1 - * @summary Test defaults processing for -XX:+ParallelRefProcEnabled with G1 GC. - * @library /test/lib - * @library / - * @requires vm.gc.G1 - * @run driver gc.arguments.TestParallelRefProc G1 - */ - -import java.util.Arrays; -import java.util.ArrayList; - -import jdk.test.lib.process.OutputAnalyzer; - -public class TestParallelRefProc { - - public static void main(String args[]) throws Exception { - if (args.length == 0) { - throw new IllegalArgumentException("Test type must be specified as argument"); - } - - String testType = args[0]; - - switch (testType) { - case "Serial": - testSerial(); - break; - case "Parallel": - testParallel(); - break; - case "G1": - testG1(); - break; - default: - throw new IllegalArgumentException("Unknown test type \"" + testType + "\""); - } - } - - private static void testSerial() throws Exception { - testFlag(new String[] { "-XX:+UseSerialGC" }, false); - } - - private static void testParallel() throws Exception { - testFlag(new String[] { "-XX:+UseParallelGC", "-XX:ParallelGCThreads=1" }, false); - testFlag(new String[] { "-XX:+UseParallelGC", "-XX:ParallelGCThreads=2" }, true); - testFlag(new String[] { "-XX:+UseParallelGC", "-XX:-ParallelRefProcEnabled", "-XX:ParallelGCThreads=2" }, false); - } - - private static void testG1() throws Exception { - testFlag(new String[] { "-XX:+UseG1GC", "-XX:ParallelGCThreads=1" }, false); - testFlag(new String[] { "-XX:+UseG1GC", "-XX:ParallelGCThreads=2" }, true); - testFlag(new String[] { "-XX:+UseG1GC", "-XX:-ParallelRefProcEnabled", "-XX:ParallelGCThreads=2" }, false); - } - - private static final String parallelRefProcEnabledPattern = - " *bool +ParallelRefProcEnabled *= *true +\\{product\\}"; - - private static final String parallelRefProcDisabledPattern = - " *bool +ParallelRefProcEnabled *= *false +\\{product\\}"; - - private static void testFlag(String[] args, boolean expectedTrue) throws Exception { - ArrayList result = new ArrayList(); - result.addAll(Arrays.asList(args)); - result.add("-XX:+PrintFlagsFinal"); - result.add("-version"); - OutputAnalyzer output = GCArguments.executeTestJava(result); - - output.shouldHaveExitValue(0); - - final String expectedPattern = expectedTrue ? parallelRefProcEnabledPattern : parallelRefProcDisabledPattern; - - String value = output.firstMatch(expectedPattern); - if (value == null) { - throw new RuntimeException( - Arrays.toString(args) + " didn't set ParallelRefProcEnabled to " + expectedTrue + " as expected"); - } - } -} diff --git a/test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java b/test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java index cf3445bd656..b0cf8f582b2 100644 --- a/test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java +++ b/test/hotspot/jtreg/gc/ergonomics/TestDynamicNumberOfGCThreads.java @@ -70,14 +70,6 @@ public class TestDynamicNumberOfGCThreads { // Base test with gc and +UseDynamicNumberOfGCThreads: OutputAnalyzer output = ProcessTools.executeLimitedTestJava(baseArgs); verifyDynamicNumberOfGCThreads(output); - - // Turn on parallel reference processing - String[] parRefProcArg = {"-XX:+ParallelRefProcEnabled", "-XX:-ShowMessageBoxOnError"}; - String[] parRefArgs = new String[baseArgs.length + parRefProcArg.length]; - System.arraycopy(parRefProcArg, 0, parRefArgs, 0, parRefProcArg.length); - System.arraycopy(baseArgs, 0, parRefArgs, parRefProcArg.length, baseArgs.length); - output = ProcessTools.executeLimitedTestJava(parRefArgs); - verifyDynamicNumberOfGCThreads(output); } static class GCTest { diff --git a/test/hotspot/jtreg/gc/logging/TestPrintReferences.java b/test/hotspot/jtreg/gc/logging/TestPrintReferences.java index 6f64e6e9b5e..390159e7cd2 100644 --- a/test/hotspot/jtreg/gc/logging/TestPrintReferences.java +++ b/test/hotspot/jtreg/gc/logging/TestPrintReferences.java @@ -57,8 +57,7 @@ public class TestPrintReferences { static final String gcLogTimeRegex = ".* GC\\([0-9]+\\) "; public static void main(String[] args) throws Exception { - testPhases(true); - testPhases(false); + testPhases(); testRefs(); } @@ -93,16 +92,15 @@ public class TestPrintReferences { refRegex("PhantomReference")); } - public static void testPhases(boolean parallelRefProcEnabled) throws Exception { + public static void testPhases() throws Exception { OutputAnalyzer output = ProcessTools.executeLimitedTestJava("-Xlog:gc+phases+ref=debug", "-XX:+UseG1GC", "-Xmx32M", - "-XX:" + (parallelRefProcEnabled ? "+" : "-") + "ParallelRefProcEnabled", "-XX:-UseDynamicNumberOfGCThreads", "-XX:ParallelGCThreads=2", GCTest.class.getName()); - checkLogFormat(output, parallelRefProcEnabled); + checkLogFormat(output); checkLogValue(output); output.shouldHaveExitValue(0); @@ -113,37 +111,31 @@ public class TestPrintReferences { return indent(6) + phaseName + ": " + timeRegex + "\n"; } - private static String subphaseRegex(String subphaseName, boolean parallelRefProcEnabled) { + private static String subphaseRegex(String subphaseName) { final String timeRegex = "\\s+" + doubleRegex; - if (parallelRefProcEnabled) { - final String timeInParRegex = timeRegex +",\\s"; - return gcLogTimeRegex + indent(8) + subphaseName + - " \\(ms\\):\\s+(Min:" + timeInParRegex + "Avg:" + timeInParRegex + "Max:" + timeInParRegex + "Diff:" + timeInParRegex + "Sum:" + timeInParRegex + - "Workers: [0-9]+|skipped)" + "\n"; - } else { - return gcLogTimeRegex + indent(8) + subphaseName + ":(" + timeRegex + "ms|\\s+skipped)\n"; - } + final String timeInParRegex = timeRegex +",\\s"; + return gcLogTimeRegex + indent(8) + subphaseName + + " \\(ms\\):\\s+(Min:" + timeInParRegex + "Avg:" + timeInParRegex + "Max:" + timeInParRegex + "Diff:" + timeInParRegex + "Sum:" + timeInParRegex + + "Workers: [0-9]+|skipped)" + "\n"; } // Find the first Reference Processing log and check its format. - private static void checkLogFormat(OutputAnalyzer output, boolean parallelRefProcEnabled) { + private static void checkLogFormat(OutputAnalyzer output) { String timeRegex = doubleRegex + "ms"; /* Total Reference processing time */ String totalRegex = gcLogTimeRegex + indent(4) + referenceProcessing + ": " + timeRegex + "\n"; - String balanceRegex = parallelRefProcEnabled ? "(" + gcLogTimeRegex + indent(8) + "Balance queues: " + timeRegex + "\n)??" : ""; - - final boolean p = parallelRefProcEnabled; + String balanceRegex = "(" + gcLogTimeRegex + indent(8) + "Balance queues: " + timeRegex + "\n)??"; String phase2Regex = gcLogTimeRegex + phaseRegex(phaseNotifySoftWeakReferences) + balanceRegex + - subphaseRegex("SoftRef", p) + - subphaseRegex("WeakRef", p) + - subphaseRegex("FinalRef", p) + - subphaseRegex("Total", p); - String phase3Regex = gcLogTimeRegex + phaseRegex(phaseNotifyKeepAliveFinalizer) + balanceRegex + subphaseRegex("FinalRef", p); - String phase4Regex = gcLogTimeRegex + phaseRegex(phaseNotifyPhantomReferences) + balanceRegex + subphaseRegex("PhantomRef", p); + subphaseRegex("SoftRef") + + subphaseRegex("WeakRef") + + subphaseRegex("FinalRef") + + subphaseRegex("Total"); + String phase3Regex = gcLogTimeRegex + phaseRegex(phaseNotifyKeepAliveFinalizer) + balanceRegex + subphaseRegex("FinalRef"); + String phase4Regex = gcLogTimeRegex + phaseRegex(phaseNotifyPhantomReferences) + balanceRegex + subphaseRegex("PhantomRef"); output.shouldMatch(totalRegex + phase2Regex + From aee4b02ecdca43d66f4e0e4acc961e6efff56a6f Mon Sep 17 00:00:00 2001 From: Martin Doerr Date: Mon, 23 Feb 2026 13:00:00 +0000 Subject: [PATCH 48/63] 8378353: [PPC64] StringCoding.countPositives causes errors when the length is not a proper 32 bit int Reviewed-by: mbaesken, dbriemann --- src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp b/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp index 73b6b132895..2d5071ce86d 100644 --- a/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp +++ b/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp @@ -600,19 +600,21 @@ void C2_MacroAssembler::count_positives(Register src, Register cnt, Register res orr(tmp0, tmp2, tmp0); and_(tmp0, tmp0, tmp1); - bne(CR0, Lslow); // Found negative byte. + bne(CR0, Lslow); // Found negative byte. addi(result, result, 16); bdnz(Lfastloop); bind(Lslow); // Fallback to slow version. subf(tmp0, src, result); // Bytes known positive. - subf_(tmp0, tmp0, cnt); // Remaining Bytes. + clrldi(tmp1, cnt, 32); // Clear garbage from upper 32 bits. + subf_(tmp0, tmp0, tmp1); // Remaining Bytes. beq(CR0, Ldone); mtctr(tmp0); + bind(Lloop); lbz(tmp0, 0, result); andi_(tmp0, tmp0, 0x80); - bne(CR0, Ldone); // Found negative byte. + bne(CR0, Ldone); // Found negative byte. addi(result, result, 1); bdnz(Lloop); From 4b99aef1cad05057463edbb248a3adc9b45d9a87 Mon Sep 17 00:00:00 2001 From: Patricio Chilano Mateo Date: Mon, 23 Feb 2026 16:01:16 +0000 Subject: [PATCH 49/63] 8373944: ObjectMonitor::ExitOnSuspend can call java_lang_VirtualThread::set_onWaitingList() while in safepoint Reviewed-by: dholmes, fbredberg --- src/hotspot/share/runtime/objectMonitor.cpp | 10 +- .../SuspendResume3/SuspendResume3.java | 152 ++++++++++++++++++ 2 files changed, 160 insertions(+), 2 deletions(-) create mode 100644 test/hotspot/jtreg/serviceability/jvmti/vthread/SuspendResume3/SuspendResume3.java diff --git a/src/hotspot/share/runtime/objectMonitor.cpp b/src/hotspot/share/runtime/objectMonitor.cpp index 144533cd959..8c6994c2152 100644 --- a/src/hotspot/share/runtime/objectMonitor.cpp +++ b/src/hotspot/share/runtime/objectMonitor.cpp @@ -329,13 +329,18 @@ void ObjectMonitor::set_object_strong() { void ObjectMonitor::ExitOnSuspend::operator()(JavaThread* current) { if (current->is_suspended()) { + // There could be an ongoing safepoint/handshake operation. + // Process them, except suspend requests, before exiting the + // monitor, as this may involve touching oops if the successor + // is a virtual thread. Before processing pending operations, + // set the monitor as pending again. + current->set_current_pending_monitor(_om); + SafepointMechanism::process_if_requested(current, false /*allow_suspend*/, false /*check_async_exception*/); _om->_recursions = 0; _om->clear_successor(); // Don't need a full fence after clearing successor here because of the call to exit(). _om->exit(current, false /* not_suspended */); _om_exited = true; - - current->set_current_pending_monitor(_om); } } @@ -1644,6 +1649,7 @@ void ObjectMonitor::exit_epilog(JavaThread* current, ObjectWaiter* Wakee) { Trigger = t->_ParkEvent; set_successor(t); } else { + assert_not_at_safepoint(); vthread = Wakee->vthread(); assert(vthread != nullptr, ""); Trigger = ObjectMonitor::vthread_unparker_ParkEvent(); diff --git a/test/hotspot/jtreg/serviceability/jvmti/vthread/SuspendResume3/SuspendResume3.java b/test/hotspot/jtreg/serviceability/jvmti/vthread/SuspendResume3/SuspendResume3.java new file mode 100644 index 00000000000..fbc9ff2d5b3 --- /dev/null +++ b/test/hotspot/jtreg/serviceability/jvmti/vthread/SuspendResume3/SuspendResume3.java @@ -0,0 +1,152 @@ +/* + * Copyright (c) 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 8373944 + * @summary Suspend thread while it's trying to acquire a monitor when unmounted vthreads are in the queue + * @requires vm.continuations + * @requires vm.jvmti + * @library /test/lib /test/hotspot/jtreg/testlibrary + * @run main/othervm/native SuspendResume3 + */ + +import java.time.Instant; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Phaser; + +import jvmti.JVMTIUtils; + +public class SuspendResume3 { + int iterations; + int dummyCounter; + Object lock = new Object(); + Phaser allSync = new Phaser(3); + + SuspendResume3 (int iterations) { + this.iterations = iterations; + } + + void worker1(Phaser sync1, Phaser sync2) { + for (int i = 0; i < iterations; i++) { + synchronized (lock) { + sync1.arriveAndAwaitAdvance(); + sync2.arriveAndAwaitAdvance(); + } + allSync.arriveAndAwaitAdvance(); + } + }; + + void worker2(Phaser sync1, Phaser sync2) { + for (int i = 0; i < iterations; i++) { + sync1.arriveAndAwaitAdvance(); + synchronized (lock) { + sync2.arriveAndAwaitAdvance(); + } + allSync.arriveAndAwaitAdvance(); + } + }; + + void vthreadWorker(CountDownLatch started) { + started.countDown(); + synchronized (lock) { + dummyCounter++; + } + } + + private void runTest() throws Exception { + final Phaser w1Sync1 = new Phaser(2); + final Phaser w1Sync2 = new Phaser(2); + Thread worker1 = Thread.ofPlatform().start(() -> worker1(w1Sync1, w1Sync2)); + + final Phaser w2Sync1 = new Phaser(2); + final Phaser w2Sync2 = new Phaser(2); + Thread worker2 = Thread.ofPlatform().start(() -> worker2(w2Sync1, w2Sync2)); + + for (int i = 0; i < iterations; i++) { + // Wait until worker1 acquires monitor + w1Sync1.arriveAndAwaitAdvance(); + // Let worker2 block on monitor + w2Sync1.arriveAndAwaitAdvance(); + await(worker2, Thread.State.BLOCKED); + + // Suspend worker2 + JVMTIUtils.suspendThread(worker2); + + // Add umounted vthread to _entry_list + var started = new CountDownLatch(1); + Thread vthread = Thread.ofVirtual().start(() -> vthreadWorker(started)); + started.await(); + await(vthread, Thread.State.BLOCKED); + + // Now let worker1 release the monitor picking worker2 + // as successor. Since worker2 is suspended, it will wake + // up, acquire the monitor and release it, unparking the + // unmounted thread as next successor. + w1Sync2.arriveAndAwaitAdvance(); + + // Force safepoint + System.gc(); + + // Let vthread terminate + vthread.join(); + + // Resume worker2 + JVMTIUtils.resumeThread(worker2); + w2Sync2.arriveAndAwaitAdvance(); + + if ((i % 10) == 0) { + System.out.println(Instant.now() + " => " + i + " of " + iterations); + } + allSync.arriveAndAwaitAdvance(); + } + + worker1.join(); + worker2.join(); + } + + public static void main(String[] args) throws Exception { + int iterations = (args.length > 0) ? Integer.parseInt(args[0]) : 100; + + SuspendResume3 obj = new SuspendResume3(iterations); + obj.runTest(); + } + + /** + * Waits for the given thread to reach a given state. + */ + private void await(Thread thread, Thread.State expectedState) throws InterruptedException { + Thread.State state = thread.getState(); + while (state != expectedState) { + assertTrue(state != Thread.State.TERMINATED, "Thread has terminated"); + Thread.sleep(10); + state = thread.getState(); + } + } + + private static void assertTrue(boolean condition, String msg) { + if (!condition) { + throw new RuntimeException(msg); + } + } +} From 66ba63a4e98bbea0d5a2c9b13c777c611d90a85a Mon Sep 17 00:00:00 2001 From: Jeremy Wood Date: Mon, 23 Feb 2026 16:18:55 +0000 Subject: [PATCH 50/63] 8377745: VoiceOver Identifies Hyperlink as Text Reviewed-by: kizune, dnguyen --- .../awt/a11y/CommonComponentAccessibility.m | 4 +- .../libawt_lwawt/awt/a11y/LinkAccessibility.h | 42 +++++++ .../libawt_lwawt/awt/a11y/LinkAccessibility.m | 60 +++++++++ .../8377745/VoiceOverHyperlinkRole.java | 119 ++++++++++++++++++ 4 files changed, 223 insertions(+), 2 deletions(-) create mode 100644 src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/LinkAccessibility.h create mode 100644 src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/LinkAccessibility.m create mode 100644 test/jdk/javax/accessibility/8377745/VoiceOverHyperlinkRole.java diff --git a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/CommonComponentAccessibility.m b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/CommonComponentAccessibility.m index 4e2c1ace969..0f0a395c597 100644 --- a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/CommonComponentAccessibility.m +++ b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/CommonComponentAccessibility.m @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 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 @@ -132,7 +132,7 @@ static jobject sAccessibilityClass = NULL; [rolesMap setObject:@"ImageAccessibility" forKey:@"icon"]; [rolesMap setObject:@"ImageAccessibility" forKey:@"desktopicon"]; [rolesMap setObject:@"SpinboxAccessibility" forKey:@"spinbox"]; - [rolesMap setObject:@"StaticTextAccessibility" forKey:@"hyperlink"]; + [rolesMap setObject:@"LinkAccessibility" forKey:@"hyperlink"]; [rolesMap setObject:@"StaticTextAccessibility" forKey:@"label"]; [rolesMap setObject:@"RadiobuttonAccessibility" forKey:@"radiobutton"]; [rolesMap setObject:@"CheckboxAccessibility" forKey:@"checkbox"]; diff --git a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/LinkAccessibility.h b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/LinkAccessibility.h new file mode 100644 index 00000000000..968e96cbb2d --- /dev/null +++ b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/LinkAccessibility.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * 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. + */ + +#ifndef LINK_ACCESSIBILITY +#define LINK_ACCESSIBILITY + +#import "CommonTextAccessibility.h" + +#import + + +@interface LinkAccessibility : CommonTextAccessibility { + +}; +- (NSAccessibilityRole _Nonnull)accessibilityRole; +- (NSString * _Nullable)accessibilityAttributedStringForRange:(NSRange)range; +- (NSString * _Nullable)accessibilityValue; +- (NSRange)accessibilityVisibleCharacterRange; +@end +#endif diff --git a/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/LinkAccessibility.m b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/LinkAccessibility.m new file mode 100644 index 00000000000..0de0237d03e --- /dev/null +++ b/src/java.desktop/macosx/native/libawt_lwawt/awt/a11y/LinkAccessibility.m @@ -0,0 +1,60 @@ +/* + * Copyright (c) 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * 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 "LinkAccessibility.h" + +@implementation LinkAccessibility + +- (NSAccessibilityRole _Nonnull)accessibilityRole +{ + return NSAccessibilityLinkRole; +} + +- (NSString * _Nullable)accessibilityAttributedStringForRange:(NSRange)range +{ + return [self accessibilityStringForRangeAttribute:range]; +} + +- (NSString * _Nullable)accessibilityValue +{ + return [self accessibilityValueAttribute]; +} + +- (NSRange)accessibilityVisibleCharacterRange +{ + return [self accessibilityVisibleCharacterRangeAttribute]; +} + +- (NSRect)accessibilityFrame +{ + return [super accessibilityFrame]; +} + +- (id)accessibilityParent +{ + return [super accessibilityParent]; +} + +@end diff --git a/test/jdk/javax/accessibility/8377745/VoiceOverHyperlinkRole.java b/test/jdk/javax/accessibility/8377745/VoiceOverHyperlinkRole.java new file mode 100644 index 00000000000..0d18d320360 --- /dev/null +++ b/test/jdk/javax/accessibility/8377745/VoiceOverHyperlinkRole.java @@ -0,0 +1,119 @@ +/* + * Copyright (c) 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. + */ + +import javax.accessibility.AccessibleContext; +import javax.accessibility.AccessibleRole; +import javax.swing.BoxLayout; +import javax.swing.JButton; +import javax.swing.JFrame; +import javax.swing.JPanel; +import javax.swing.JTextArea; +import javax.swing.border.EmptyBorder; + +/* + * @test + * @key headful + * @bug 8377745 + * @summary manual test for VoiceOver reading links correctly + * @requires os.family == "mac" + * @library /java/awt/regtesthelpers + * @build PassFailJFrame + * @run main/manual VoiceOverHyperlinkRole + */ + +public class VoiceOverHyperlinkRole { + public static void main(String[] args) throws Exception { + String INSTRUCTIONS = "INSTRUCTIONS (Mac-only):\n" + + "1. Open VoiceOver\n" + + "2. Move the VoiceOver cursor over the link.\n" + + "3. Observe how VoiceOver identifies the link.\n\n" + + "Expected behavior: VoiceOver should identify it as a " + + "\"link\". It should not say \"text element\", \"text\" " + + "or \"hyperlink\".\n\n" + + "If you select the link using \"Accessibility " + + "Inspector\": it should identify its role as AXLink."; + + PassFailJFrame.builder() + .title("VoiceOverHyperlinkRole Instruction") + .instructions(INSTRUCTIONS) + .columns(40) + .testUI(VoiceOverHyperlinkRole::createUI) + .build() + .awaitAndCheck(); + } + + private static JFrame createUI() { + JPanel p = new JPanel(); + p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS)); + + p.add(createText("This button uses `AccessibleRole.HYPERLINK:`")); + p.add(createLink(AccessibleRole.HYPERLINK)); + + // for debugging / experimentation: + boolean tryOtherRoles = false; + if (tryOtherRoles) { + p.add(createText( + "This button uses `new AccessibleRole(\"Link\") {}`:")); + p.add(createLink(new AccessibleRole("Link") {})); + p.add(createText( + "This button uses `new AccessibleRole(\"link\") {}`:")); + p.add(createLink(new AccessibleRole("link") {})); + p.add(createText( + "This button uses `new AccessibleRole(\"AXLink\") {}`:")); + p.add(createLink(new AccessibleRole("AXLink") {})); + } + + JFrame frame = new JFrame(); + frame.getContentPane().add(p); + frame.pack(); + return frame; + } + + private static JTextArea createText(String text) { + JTextArea textArea = new JTextArea(text); + textArea.setOpaque(false); + textArea.setEditable(false); + textArea.setBorder(new EmptyBorder(20, 10, 3, 10)); + return textArea; + } + + private static JButton createLink(AccessibleRole role) { + String text = "https://bugs.openjdk.org/"; + JButton button = new JButton(text) { + public AccessibleContext getAccessibleContext() { + if (accessibleContext == null) { + accessibleContext = new AccessibleJButton() { + @Override + public AccessibleRole getAccessibleRole() { + return role; + } + }; + } + return accessibleContext; + } + }; + button.setContentAreaFilled(false); + button.setBorderPainted(false); + return button; + } +} From 1ae2fee007436ef8d842b3d71f228897ce6d2f67 Mon Sep 17 00:00:00 2001 From: Xue-Lei Andrew Fan Date: Mon, 23 Feb 2026 17:02:14 +0000 Subject: [PATCH 51/63] 8376125: Out of memory in the CDS archive error with lot of classes Co-authored-by: Ioi Lam Reviewed-by: iklam, jiangli --- src/hotspot/os/posix/os_posix.cpp | 17 +++++ .../share/cds/aotCompressedPointers.hpp | 18 ++--- src/hotspot/share/cds/archiveBuilder.cpp | 6 +- src/hotspot/share/cds/archiveUtils.cpp | 17 +---- src/hotspot/share/cds/cppVtables.cpp | 2 +- src/hotspot/share/cds/filemap.cpp | 4 +- .../share/classfile/compactHashtable.cpp | 37 ++++++---- .../share/classfile/compactHashtable.hpp | 9 ++- src/hotspot/share/runtime/vmStructs.cpp | 6 ++ .../sun/jvm/hotspot/memory/FileMapInfo.java | 42 ++++++----- test/hotspot/gtest/cds/test_scaledOffsets.cpp | 71 +++++++++++++++++++ 11 files changed, 167 insertions(+), 62 deletions(-) create mode 100644 test/hotspot/gtest/cds/test_scaledOffsets.cpp diff --git a/src/hotspot/os/posix/os_posix.cpp b/src/hotspot/os/posix/os_posix.cpp index 5412e2bc92d..f147ed4be93 100644 --- a/src/hotspot/os/posix/os_posix.cpp +++ b/src/hotspot/os/posix/os_posix.cpp @@ -906,8 +906,25 @@ FILE* os::fdopen(int fd, const char* mode) { ssize_t os::pd_write(int fd, const void *buf, size_t nBytes) { ssize_t res; +#ifdef __APPLE__ + // macOS fails for individual write operations > 2GB. + // See https://gitlab.haskell.org/ghc/ghc/-/issues/17414 + ssize_t total = 0; + while (nBytes > 0) { + size_t bytes_to_write = MIN2(nBytes, (size_t)INT_MAX); + RESTARTABLE(::write(fd, buf, bytes_to_write), res); + if (res == OS_ERR) { + return OS_ERR; + } + buf = (const char*)buf + res; + nBytes -= res; + total += res; + } + return total; +#else RESTARTABLE(::write(fd, buf, nBytes), res); return res; +#endif } ssize_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) { diff --git a/src/hotspot/share/cds/aotCompressedPointers.hpp b/src/hotspot/share/cds/aotCompressedPointers.hpp index ead48ef9948..a3919fb95a9 100644 --- a/src/hotspot/share/cds/aotCompressedPointers.hpp +++ b/src/hotspot/share/cds/aotCompressedPointers.hpp @@ -36,16 +36,17 @@ class AOTCompressedPointers: public AllStatic { public: // For space saving, we can encode the location of metadata objects in the "rw" and "ro" - // regions using a 32-bit offset from the bottom of the mapped AOT metaspace. - // Currently we allow only up to 2GB total size in the rw and ro regions (which are - // contiguous to each other). + // regions using a 32-bit offset from the bottom of the mapped AOT metaspace. Since metadata + // objects are 8-byte aligned, we store scaled offset units (offset_bytes >> 3) to address + // up to ~32GB on 64-bit platforms. We currently limit the MaxMetadataOffsetBytes to about + // 3.5 GB to be compatible with +CompactObjectHeaders. enum class narrowPtr : u4; - static constexpr size_t MaxMetadataOffsetBytes = 0x7FFFFFFF; + static constexpr size_t MetadataOffsetShift = LP64_ONLY(3) NOT_LP64(0); + static constexpr size_t MaxMetadataOffsetBytes = LP64_ONLY(3584ULL * M) NOT_LP64(0x7FFFFFFF); - // In the future, this could return a different numerical value than - // narrowp if the encoding contains shifts. + // Convert the encoded narrowPtr to a byte offset by applying the shift. inline static size_t get_byte_offset(narrowPtr narrowp) { - return checked_cast(narrowp); + return ((size_t)checked_cast(narrowp)) << MetadataOffsetShift; } inline static narrowPtr null() { @@ -122,7 +123,8 @@ private: static narrowPtr encode_byte_offset(size_t offset) { assert(offset != 0, "offset 0 is in protection zone"); precond(offset <= MaxMetadataOffsetBytes); - return checked_cast(offset); + assert(is_aligned(offset, (size_t)1 << MetadataOffsetShift), "offset not aligned"); + return checked_cast(offset >> MetadataOffsetShift); } }; diff --git a/src/hotspot/share/cds/archiveBuilder.cpp b/src/hotspot/share/cds/archiveBuilder.cpp index cb9459172b3..0ea5d6c6ecb 100644 --- a/src/hotspot/share/cds/archiveBuilder.cpp +++ b/src/hotspot/share/cds/archiveBuilder.cpp @@ -321,8 +321,10 @@ void ArchiveBuilder::sort_klasses() { } address ArchiveBuilder::reserve_buffer() { - // AOTCodeCache::max_aot_code_size() accounts for aot code region. - size_t buffer_size = LP64_ONLY(CompressedClassSpaceSize) NOT_LP64(256 * M) + AOTCodeCache::max_aot_code_size(); + // On 64-bit: reserve address space for archives up to the max encoded offset limit. + // On 32-bit: use 256MB + AOT code size due to limited virtual address space. + size_t buffer_size = LP64_ONLY(AOTCompressedPointers::MaxMetadataOffsetBytes) + NOT_LP64(256 * M + AOTCodeCache::max_aot_code_size()); ReservedSpace rs = MemoryReserver::reserve(buffer_size, AOTMetaspace::core_region_alignment(), os::vm_page_size(), diff --git a/src/hotspot/share/cds/archiveUtils.cpp b/src/hotspot/share/cds/archiveUtils.cpp index c13b447bb87..ea9bde8eb8d 100644 --- a/src/hotspot/share/cds/archiveUtils.cpp +++ b/src/hotspot/share/cds/archiveUtils.cpp @@ -312,22 +312,9 @@ void DumpRegion::pack(DumpRegion* next) { } void WriteClosure::do_ptr(void** p) { - // Write ptr into the archive; ptr can be: - // (a) null -> written as 0 - // (b) a "buffered" address -> written as is - // (c) a "source" address -> convert to "buffered" and write - // The common case is (c). E.g., when writing the vmClasses into the archive. - // We have (b) only when we don't have a corresponding source object. E.g., - // the archived c++ vtable entries. address ptr = *(address*)p; - if (ptr != nullptr && !ArchiveBuilder::current()->is_in_buffer_space(ptr)) { - ptr = ArchiveBuilder::current()->get_buffered_addr(ptr); - } - // null pointers do not need to be converted to offsets - if (ptr != nullptr) { - ptr = (address)ArchiveBuilder::current()->buffer_to_offset(ptr); - } - _dump_region->append_intptr_t((intptr_t)ptr, false); + AOTCompressedPointers::narrowPtr narrowp = AOTCompressedPointers::encode(ptr); + _dump_region->append_intptr_t(checked_cast(narrowp), false); } void ReadClosure::do_ptr(void** p) { diff --git a/src/hotspot/share/cds/cppVtables.cpp b/src/hotspot/share/cds/cppVtables.cpp index da68fa70761..dc5a777d7b1 100644 --- a/src/hotspot/share/cds/cppVtables.cpp +++ b/src/hotspot/share/cds/cppVtables.cpp @@ -140,7 +140,7 @@ void CppVtableCloner::initialize(const char* name, CppVtableInfo* info) { // We already checked (and, if necessary, adjusted n) when the vtables were allocated, so we are // safe to do memcpy. - log_debug(aot, vtables)("Copying %3d vtable entries for %s", n, name); + log_debug(aot, vtables)("Copying %3d vtable entries for %s to " INTPTR_FORMAT, n, name, p2i(dstvtable)); memcpy(dstvtable, srcvtable, sizeof(intptr_t) * n); } diff --git a/src/hotspot/share/cds/filemap.cpp b/src/hotspot/share/cds/filemap.cpp index da2d4f6dac2..91fbce701e5 100644 --- a/src/hotspot/share/cds/filemap.cpp +++ b/src/hotspot/share/cds/filemap.cpp @@ -717,8 +717,8 @@ bool FileMapInfo::init_from_file(int fd) { } void FileMapInfo::seek_to_position(size_t pos) { - if (os::lseek(_fd, (long)pos, SEEK_SET) < 0) { - aot_log_error(aot)("Unable to seek to position %zu", pos); + if (os::lseek(_fd, (jlong)pos, SEEK_SET) < 0) { + aot_log_error(aot)("Unable to seek to position %zu (errno=%d: %s)", pos, errno, os::strerror(errno)); AOTMetaspace::unrecoverable_loading_error(); } } diff --git a/src/hotspot/share/classfile/compactHashtable.cpp b/src/hotspot/share/classfile/compactHashtable.cpp index 6808ae7bb8f..de67971c403 100644 --- a/src/hotspot/share/classfile/compactHashtable.cpp +++ b/src/hotspot/share/classfile/compactHashtable.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 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 @@ -96,14 +96,16 @@ void CompactHashtableWriter::allocate_table() { "Too many entries."); } - _compact_buckets = ArchiveBuilder::new_ro_array(_num_buckets + 1); - _compact_entries = ArchiveBuilder::new_ro_array(entries_space); + _num_compact_buckets = checked_cast(_num_buckets + 1); // extra slot for TABLEEND_BUCKET_TYPE + _num_compact_entries = checked_cast(entries_space); + _compact_buckets = (u4*)ArchiveBuilder::ro_region_alloc(_num_compact_buckets * sizeof(u4)); + _compact_entries = (u4*)ArchiveBuilder::ro_region_alloc(_num_compact_entries * sizeof(u4)); _stats->bucket_count = _num_buckets; - _stats->bucket_bytes = align_up(_compact_buckets->size() * BytesPerWord, + _stats->bucket_bytes = align_up(checked_cast(_num_compact_buckets * sizeof(u4)), SharedSpaceObjectAlignment); _stats->hashentry_count = _num_entries_written; - _stats->hashentry_bytes = align_up(_compact_entries->size() * BytesPerWord, + _stats->hashentry_bytes = align_up(checked_cast(_num_compact_entries * sizeof(u4)), SharedSpaceObjectAlignment); } @@ -114,21 +116,21 @@ void CompactHashtableWriter::dump_table(NumberSeq* summary) { GrowableArray* bucket = _buckets[index]; int bucket_size = bucket->length(); if (bucket_size == 1) { - _compact_buckets->at_put(index, BUCKET_INFO(offset, VALUE_ONLY_BUCKET_TYPE)); + compact_buckets_set(index, BUCKET_INFO(offset, VALUE_ONLY_BUCKET_TYPE)); Entry ent = bucket->at(0); // bucket with one entry is value_only and only has the encoded_value - _compact_entries->at_put(offset++, ent.encoded_value()); + compact_entries_set(offset++, ent.encoded_value()); _num_value_only_buckets++; } else { // regular bucket, it could contain zero or more than one entry, // each entry is a pair - _compact_buckets->at_put(index, BUCKET_INFO(offset, REGULAR_BUCKET_TYPE)); + compact_buckets_set(index, BUCKET_INFO(offset, REGULAR_BUCKET_TYPE)); for (int i=0; iat(i); - _compact_entries->at_put(offset++, u4(ent.hash())); // write entry hash - _compact_entries->at_put(offset++, ent.encoded_value()); // write entry encoded_value + compact_entries_set(offset++, u4(ent.hash())); // write entry hash + compact_entries_set(offset++, ent.encoded_value()); // write entry encoded_value } if (bucket_size == 0) { _num_empty_buckets++; @@ -140,10 +142,19 @@ void CompactHashtableWriter::dump_table(NumberSeq* summary) { } // Mark the end of the buckets - _compact_buckets->at_put(_num_buckets, BUCKET_INFO(offset, TABLEEND_BUCKET_TYPE)); - assert(offset == (u4)_compact_entries->length(), "sanity"); + compact_buckets_set(_num_buckets, BUCKET_INFO(offset, TABLEEND_BUCKET_TYPE)); + assert(offset == checked_cast(_num_compact_entries), "sanity"); } +void CompactHashtableWriter::compact_buckets_set(u4 index, u4 value) { + precond(index < _num_compact_buckets); + _compact_buckets[index] = value; +} + +void CompactHashtableWriter::compact_entries_set(u4 index, u4 value) { + precond(index < _num_compact_entries); + _compact_entries[index] = value; +} // Write the compact table void CompactHashtableWriter::dump(SimpleCompactHashtable *cht, const char* table_name) { @@ -154,7 +165,7 @@ void CompactHashtableWriter::dump(SimpleCompactHashtable *cht, const char* table int table_bytes = _stats->bucket_bytes + _stats->hashentry_bytes; address base_address = address(SharedBaseAddress); cht->init(base_address, _num_entries_written, _num_buckets, - _compact_buckets->data(), _compact_entries->data()); + _compact_buckets, _compact_entries); LogMessage(aot, hashtables) msg; if (msg.is_info()) { diff --git a/src/hotspot/share/classfile/compactHashtable.hpp b/src/hotspot/share/classfile/compactHashtable.hpp index 2fe92be0f6d..81f2951289d 100644 --- a/src/hotspot/share/classfile/compactHashtable.hpp +++ b/src/hotspot/share/classfile/compactHashtable.hpp @@ -115,8 +115,13 @@ private: int _num_other_buckets; GrowableArray** _buckets; CompactHashtableStats* _stats; - Array* _compact_buckets; - Array* _compact_entries; + u4* _compact_buckets; + size_t _num_compact_buckets; + u4* _compact_entries; + size_t _num_compact_entries; + + void compact_buckets_set(u4 index, u4 value); + void compact_entries_set(u4 index, u4 value); public: // This is called at dump-time only diff --git a/src/hotspot/share/runtime/vmStructs.cpp b/src/hotspot/share/runtime/vmStructs.cpp index 4d2ba90e326..9ac8f396f9a 100644 --- a/src/hotspot/share/runtime/vmStructs.cpp +++ b/src/hotspot/share/runtime/vmStructs.cpp @@ -1288,6 +1288,12 @@ VM_INT_CONSTANTS_GC(declare_constant, \ declare_constant_with_value) \ \ + /*****************/ \ + /* CDS constants */ \ + /*****************/ \ + \ + CDS_ONLY(declare_constant(AOTCompressedPointers::MetadataOffsetShift)) \ + \ /******************/ \ /* Useful globals */ \ /******************/ \ diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/memory/FileMapInfo.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/memory/FileMapInfo.java index 14d8af58e4d..12b614e7fa8 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/memory/FileMapInfo.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/memory/FileMapInfo.java @@ -41,6 +41,7 @@ public class FileMapInfo { private static Address rwRegionEndAddress; private static Address vtablesIndex; private static Address mapped_base_address; + private static long metadataOffsetShift; // HashMap created by mapping the vTable addresses in the rw region with // the corresponding metadata type. @@ -97,12 +98,15 @@ public class FileMapInfo { headerObj = VMObjectFactory.newObject(FileMapHeader.class, header); // char* mapped_base_address = header->_mapped_base_address - // narrowPtr cloned_vtable_narrowPtr = header->_cloned_vtable_offset + // narrowPtr cloned_vtable_narrowPtr = header->_cloned_vtables // size_t cloned_vtable_offset = AOTCompressedPointers::get_byte_offset(cloned_vtable_narrowPtr); // CppVtableInfo** vtablesIndex = mapped_base_address + cloned_vtable_offset; mapped_base_address = get_AddressField(FileMapHeader_type, header, "_mapped_base_address"); long cloned_vtable_narrowPtr = get_CIntegerField(FileMapHeader_type, header, "_cloned_vtables"); - long cloned_vtable_offset = cloned_vtable_narrowPtr; // Currently narrowPtr is the same as offset + // narrowPtr stores scaled offset units (byte_offset >> MetadataOffsetShift). + // Apply the left shift to convert back to byte offset. + metadataOffsetShift = db.lookupIntConstant("AOTCompressedPointers::MetadataOffsetShift").longValue(); + long cloned_vtable_offset = cloned_vtable_narrowPtr << metadataOffsetShift; vtablesIndex = mapped_base_address.addOffsetTo(cloned_vtable_offset); // CDSFileMapRegion* rw_region = &header->_region[rw]; @@ -176,9 +180,9 @@ public class FileMapInfo { // vtablesIndex points to to an array like this: // long info[] = { - // offset of the CppVtableInfo for ConstantPool, - // offset of the CppVtableInfo for InstanceKlass, - // offset of the CppVtableInfo for InstanceClassLoaderKlass, + // narrowPtr of the CppVtableInfo for ConstantPool, + // narrowPtr of the CppVtableInfo for InstanceKlass, + // narrowPtr of the CppVtableInfo for InstanceClassLoaderKlass, // ... // }; // @@ -189,8 +193,8 @@ public class FileMapInfo { // }; // // The loop below computes the following - // CppVtableInfo* t_ConstantPool = mapped_base_address + info[0]; - // CppVtableInfo* t_InstanceKlass = mapped_base_address + info[1]; + // CppVtableInfo* t_ConstantPool = mapped_base_address + (info[0] << metadataOffsetShift); + // CppVtableInfo* t_InstanceKlass = mapped_base_address + (info[1] << metadataOffsetShift); // ... // // If we have the following objects @@ -203,21 +207,21 @@ public class FileMapInfo { // // To get an idea what these address look like, do this: // - // $ java -Xlog:cds+vtables=debug -XX:+UnlockDiagnosticVMOptions -XX:ArchiveRelocationMode=0 --version - // [0.002s][debug][cds,vtables] Copying 14 vtable entries for ConstantPool to 0x800000018 - // [0.002s][debug][cds,vtables] Copying 41 vtable entries for InstanceKlass to 0x800000090 - // [0.002s][debug][cds,vtables] Copying 41 vtable entries for InstanceClassLoaderKlass to 0x8000001e0 - // [0.002s][debug][cds,vtables] Copying 41 vtable entries for InstanceMirrorKlass to 0x800000330 - // [0.002s][debug][cds,vtables] Copying 41 vtable entries for InstanceRefKlass to 0x800000480 - // [0.002s][debug][cds,vtables] Copying 41 vtable entries for InstanceStackChunkKlass to 0x8000005d0 - // [0.002s][debug][cds,vtables] Copying 14 vtable entries for Method to 0x800000720 - // [0.002s][debug][cds,vtables] Copying 42 vtable entries for ObjArrayKlass to 0x800000798 - // [0.002s][debug][cds,vtables] Copying 42 vtable entries for TypeArrayKlass to 0x8000008f0 - // java 23-internal 2024-09-17 + // $ java -Xlog:aot+vtables=debug -XX:+UnlockDiagnosticVMOptions -XX:ArchiveRelocationMode=0 --version + // [0.002s][debug][aot,vtables] Copying 14 vtable entries for ConstantPool to 0x800000018 + // [0.002s][debug][aot,vtables] Copying 41 vtable entries for InstanceKlass to 0x800000090 + // [0.002s][debug][aot,vtables] Copying 41 vtable entries for InstanceClassLoaderKlass to 0x8000001e0 + // [0.002s][debug][aot,vtables] Copying 41 vtable entries for InstanceMirrorKlass to 0x800000330 + // [0.002s][debug][aot,vtables] Copying 41 vtable entries for InstanceRefKlass to 0x800000480 + // [0.002s][debug][aot,vtables] Copying 41 vtable entries for InstanceStackChunkKlass to 0x8000005d0 + // [0.002s][debug][aot,vtables] Copying 14 vtable entries for Method to 0x800000720 + // [0.002s][debug][aot,vtables] Copying 42 vtable entries for ObjArrayKlass to 0x800000798 + // [0.002s][debug][aot,vtables] Copying 42 vtable entries for TypeArrayKlass to 0x8000008f0 // ... for (int i=0; i < metadataTypeArray.length; i++) { - long vtable_offset = vtablesIndex.getJLongAt(i * addressSize); // long offset = _index[i] + long narrowPtr = vtablesIndex.getJLongAt(i * addressSize); + long vtable_offset = narrowPtr << metadataOffsetShift; // CppVtableInfo* t = the address of the CppVtableInfo for the i-th table Address vtableInfoAddress = mapped_base_address.addOffsetTo(vtable_offset); diff --git a/test/hotspot/gtest/cds/test_scaledOffsets.cpp b/test/hotspot/gtest/cds/test_scaledOffsets.cpp new file mode 100644 index 00000000000..93b1b211276 --- /dev/null +++ b/test/hotspot/gtest/cds/test_scaledOffsets.cpp @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2026 salesforce.com, inc. 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. + * + */ + +#include "cds/aotCompressedPointers.hpp" +#include "unittest.hpp" +#include "utilities/globalDefinitions.hpp" + +#include + +TEST_VM(ScaledOffsetsTest, constants) { +#ifdef _LP64 + ASSERT_EQ((size_t)3, AOTCompressedPointers::MetadataOffsetShift); + ASSERT_TRUE(is_aligned(AOTCompressedPointers::MaxMetadataOffsetBytes, (size_t)1 << AOTCompressedPointers::MetadataOffsetShift)); + ASSERT_EQ((size_t)(3584ULL * M), AOTCompressedPointers::MaxMetadataOffsetBytes); +#else + ASSERT_EQ((size_t)0, AOTCompressedPointers::MetadataOffsetShift); + ASSERT_EQ((size_t)0x7FFFFFFF, AOTCompressedPointers::MaxMetadataOffsetBytes); +#endif +} + +TEST_VM(ScaledOffsetsTest, encode_decode_roundtrip) { + // Test that encoding and decoding via get_byte_offset produces correct results + const size_t unit = (size_t)1 << AOTCompressedPointers::MetadataOffsetShift; + + // Test that get_byte_offset correctly applies the shift + // Note: We can't directly test encode_byte_offset as it's private, but we can verify + // the shift value is applied correctly in get_byte_offset + AOTCompressedPointers::narrowPtr np1 = static_cast(1); + ASSERT_EQ(unit, AOTCompressedPointers::get_byte_offset(np1)); + + AOTCompressedPointers::narrowPtr np2 = static_cast(2); + ASSERT_EQ(2 * unit, AOTCompressedPointers::get_byte_offset(np2)); + + AOTCompressedPointers::narrowPtr np1024 = static_cast(1024); + ASSERT_EQ(1024 * unit, AOTCompressedPointers::get_byte_offset(np1024)); + +#ifdef _LP64 + const uint64_t max_units = (uint64_t)UINT32_MAX; + AOTCompressedPointers::narrowPtr np_max = static_cast(UINT32_MAX); + const uint64_t max_bytes = max_units << AOTCompressedPointers::MetadataOffsetShift; + ASSERT_EQ(max_bytes, AOTCompressedPointers::get_byte_offset(np_max)); + ASSERT_GE(max_bytes, AOTCompressedPointers::MaxMetadataOffsetBytes - unit); +#endif +} + +TEST_VM(ScaledOffsetsTest, null_handling) { + // Test that null() returns 0 + ASSERT_EQ(static_cast(0), AOTCompressedPointers::null()); + ASSERT_EQ((size_t)0, AOTCompressedPointers::get_byte_offset(AOTCompressedPointers::null())); +} From acde30e0ab9cd8fbb6d2e1193771a40fd370659a Mon Sep 17 00:00:00 2001 From: Alexey Semenyuk Date: Mon, 23 Feb 2026 17:34:55 +0000 Subject: [PATCH 52/63] 8377897: jpackage: make jdk.jpackage.internal.MockUtils available from other packages Reviewed-by: almatvee --- .../internal/LinuxBundlingEnvironment.java | 1 + .../internal/DefaultBundlingEnvironment.java | 28 +-- .../jdk/jpackage/internal/Executor.java | 54 +++--- .../jpackage/internal/ExecutorFactory.java | 4 +- .../jdk/jpackage/internal/Globals.java | 6 +- .../jdk/jpackage/internal/ObjectFactory.java | 18 +- .../internal/RetryExecutorFactory.java | 4 +- .../internal/util/MemoizingSupplier.java | 56 ++++++ .../internal/WinBundlingEnvironment.java | 1 + .../test/stdmock/JPackageMockUtils.java} | 91 +++++----- .../internal/LinuxPackageArchTest.java | 3 +- .../internal/LinuxSystemEnvironmentTest.java | 3 +- .../jdk/tools/jpackage/junit/linux/junit.java | 4 +- .../jpackage/internal/MacDmgPackagerTest.java | 7 +- .../internal/MacDmgSystemEnvironmentTest.java | 4 +- .../tools/jpackage/junit/macosx/junit.java | 4 +- .../DefaultBundlingEnvironmentTest.java | 3 +- .../jdk/jpackage/internal/cli/MainTest.java | 7 +- .../internal/util/MemoizingSupplierTest.java | 163 ++++++++++++++++++ 19 files changed, 331 insertions(+), 130 deletions(-) create mode 100644 src/jdk.jpackage/share/classes/jdk/jpackage/internal/util/MemoizingSupplier.java rename test/jdk/tools/jpackage/{junit/share/jdk.jpackage/jdk/jpackage/internal/MockUtils.java => helpers/jdk/jpackage/test/stdmock/JPackageMockUtils.java} (76%) create mode 100644 test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/util/MemoizingSupplierTest.java diff --git a/src/jdk.jpackage/linux/classes/jdk/jpackage/internal/LinuxBundlingEnvironment.java b/src/jdk.jpackage/linux/classes/jdk/jpackage/internal/LinuxBundlingEnvironment.java index d2169ede461..d6d9def9407 100644 --- a/src/jdk.jpackage/linux/classes/jdk/jpackage/internal/LinuxBundlingEnvironment.java +++ b/src/jdk.jpackage/linux/classes/jdk/jpackage/internal/LinuxBundlingEnvironment.java @@ -30,6 +30,7 @@ import static jdk.jpackage.internal.LinuxPackagingPipeline.APPLICATION_LAYOUT; import static jdk.jpackage.internal.cli.StandardBundlingOperation.CREATE_LINUX_APP_IMAGE; import static jdk.jpackage.internal.cli.StandardBundlingOperation.CREATE_LINUX_DEB; import static jdk.jpackage.internal.cli.StandardBundlingOperation.CREATE_LINUX_RPM; +import static jdk.jpackage.internal.util.MemoizingSupplier.runOnce; import java.util.Map; import java.util.Optional; diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/DefaultBundlingEnvironment.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/DefaultBundlingEnvironment.java index 331bde29d27..3a58180aa35 100644 --- a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/DefaultBundlingEnvironment.java +++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/DefaultBundlingEnvironment.java @@ -25,6 +25,7 @@ package jdk.jpackage.internal; import static java.util.stream.Collectors.toMap; +import static jdk.jpackage.internal.util.MemoizingSupplier.runOnce; import java.io.IOException; import java.io.UncheckedIOException; @@ -36,7 +37,6 @@ import java.util.Map; import java.util.NoSuchElementException; import java.util.Objects; import java.util.Optional; -import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiConsumer; import java.util.function.BiFunction; import java.util.function.Consumer; @@ -50,6 +50,7 @@ import jdk.jpackage.internal.model.Application; import jdk.jpackage.internal.model.BundlingOperationDescriptor; import jdk.jpackage.internal.model.JPackageException; import jdk.jpackage.internal.model.Package; +import jdk.jpackage.internal.util.MemoizingSupplier; import jdk.jpackage.internal.util.PathUtils; import jdk.jpackage.internal.util.Result; @@ -66,7 +67,7 @@ class DefaultBundlingEnvironment implements CliBundlingEnvironment { return runOnce(e.getValue()); })); - this.defaultOperationSupplier = Objects.requireNonNull(defaultOperationSupplier).map(DefaultBundlingEnvironment::runOnce); + this.defaultOperationSupplier = Objects.requireNonNull(defaultOperationSupplier).map(MemoizingSupplier::runOnce); } @@ -110,10 +111,6 @@ class DefaultBundlingEnvironment implements CliBundlingEnvironment { return new Builder(); } - static Supplier runOnce(Supplier supplier) { - return new CachingSupplier<>(supplier); - } - static Supplier>> createBundlerSupplier( Supplier> sysEnvResultSupplier, BiConsumer bundler) { Objects.requireNonNull(sysEnvResultSupplier); @@ -223,25 +220,6 @@ class DefaultBundlingEnvironment implements CliBundlingEnvironment { }); } - - private static final class CachingSupplier implements Supplier { - - CachingSupplier(Supplier getter) { - this.getter = Objects.requireNonNull(getter); - } - - @Override - public T get() { - return cachedValue.updateAndGet(v -> { - return Optional.ofNullable(v).orElseGet(getter); - }); - } - - private final Supplier getter; - private final AtomicReference cachedValue = new AtomicReference<>(); - } - - private final Map>>> bundlers; private final Optional>> defaultOperationSupplier; } diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/Executor.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/Executor.java index 53c587ab37c..f9ccec7e3bb 100644 --- a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/Executor.java +++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/Executor.java @@ -49,7 +49,7 @@ import jdk.jpackage.internal.util.CommandOutputControl.Result; import jdk.jpackage.internal.util.RetryExecutor; import jdk.jpackage.internal.util.function.ExceptionBox; -final class Executor { +public final class Executor { static Executor of(String... cmdline) { return of(List.of(cmdline)); @@ -78,118 +78,118 @@ final class Executor { mapper = other.mapper; } - Executor saveOutput(boolean v) { + public Executor saveOutput(boolean v) { commandOutputControl.saveOutput(v); return this; } - Executor saveOutput() { + public Executor saveOutput() { return saveOutput(true); } - Executor saveFirstLineOfOutput() { + public Executor saveFirstLineOfOutput() { commandOutputControl.saveFirstLineOfOutput(); return this; } - Executor charset(Charset v) { + public Executor charset(Charset v) { commandOutputControl.charset(v); return this; } - Executor storeOutputInFiles(boolean v) { + public Executor storeOutputInFiles(boolean v) { commandOutputControl.storeOutputInFiles(v); return this; } - Executor storeOutputInFiles() { + public Executor storeOutputInFiles() { return storeOutputInFiles(true); } - Executor binaryOutput(boolean v) { + public Executor binaryOutput(boolean v) { commandOutputControl.binaryOutput(v); return this; } - Executor binaryOutput() { + public Executor binaryOutput() { return binaryOutput(true); } - Executor discardStdout(boolean v) { + public Executor discardStdout(boolean v) { commandOutputControl.discardStdout(v); return this; } - Executor discardStdout() { + public Executor discardStdout() { return discardStdout(true); } - Executor discardStderr(boolean v) { + public Executor discardStderr(boolean v) { commandOutputControl.discardStderr(v); return this; } - Executor discardStderr() { + public Executor discardStderr() { return discardStderr(true); } - Executor timeout(long v, TimeUnit unit) { + public Executor timeout(long v, TimeUnit unit) { return timeout(Duration.of(v, unit.toChronoUnit())); } - Executor timeout(Duration v) { + public Executor timeout(Duration v) { timeout = v; return this; } - Executor toolProvider(ToolProvider v) { + public Executor toolProvider(ToolProvider v) { toolProvider = Objects.requireNonNull(v); processBuilder = null; return this; } - Optional toolProvider() { + public Optional toolProvider() { return Optional.ofNullable(toolProvider); } - Executor processBuilder(ProcessBuilder v) { + public Executor processBuilder(ProcessBuilder v) { processBuilder = Objects.requireNonNull(v); toolProvider = null; return this; } - Optional processBuilder() { + public Optional processBuilder() { return Optional.ofNullable(processBuilder); } - Executor args(List v) { + public Executor args(List v) { args.addAll(v); return this; } - Executor args(String... args) { + public Executor args(String... args) { return args(List.of(args)); } - List args() { + public List args() { return args; } - Executor setQuiet(boolean v) { + public Executor setQuiet(boolean v) { quietCommand = v; return this; } - Executor mapper(UnaryOperator v) { + public Executor mapper(UnaryOperator v) { mapper = v; return this; } - Optional> mapper() { + public Optional> mapper() { return Optional.ofNullable(mapper); } - Executor copy() { + public Executor copy() { return new Executor(this); } @@ -261,7 +261,7 @@ final class Executor { }); } - List commandLine() { + public List commandLine() { if (processBuilder != null) { return Stream.of(processBuilder.command(), args).flatMap(Collection::stream).toList(); } else if (toolProvider != null) { diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ExecutorFactory.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ExecutorFactory.java index ce703358b82..82d81d1052e 100644 --- a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ExecutorFactory.java +++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ExecutorFactory.java @@ -25,9 +25,9 @@ package jdk.jpackage.internal; @FunctionalInterface -interface ExecutorFactory { +public interface ExecutorFactory { Executor executor(); - static final ExecutorFactory DEFAULT = Executor::new; + public static final ExecutorFactory DEFAULT = Executor::new; } diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/Globals.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/Globals.java index 91ae37870a5..d5c714d1a47 100644 --- a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/Globals.java +++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/Globals.java @@ -33,17 +33,17 @@ public final class Globals { private Globals() { } - Globals objectFactory(ObjectFactory v) { + public Globals objectFactory(ObjectFactory v) { checkMutable(); objectFactory = Optional.ofNullable(v).orElse(ObjectFactory.DEFAULT); return this; } - ObjectFactory objectFactory() { + public ObjectFactory objectFactory() { return objectFactory; } - Globals executorFactory(ExecutorFactory v) { + public Globals executorFactory(ExecutorFactory v) { return objectFactory(ObjectFactory.build(objectFactory).executorFactory(v).create()); } diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ObjectFactory.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ObjectFactory.java index f1a83eb9eab..b6a95ae539b 100644 --- a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ObjectFactory.java +++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ObjectFactory.java @@ -28,38 +28,38 @@ import java.util.Objects; import java.util.Optional; import jdk.jpackage.internal.util.CompositeProxy; -interface ObjectFactory extends ExecutorFactory, RetryExecutorFactory { +public interface ObjectFactory extends ExecutorFactory, RetryExecutorFactory { - static ObjectFactory.Builder build() { + public static ObjectFactory.Builder build() { return new Builder(); } - static ObjectFactory.Builder build(ObjectFactory from) { + public static ObjectFactory.Builder build(ObjectFactory from) { return build().initFrom(from); } - static final class Builder { + public static final class Builder { private Builder() { } - ObjectFactory create() { + public ObjectFactory create() { return CompositeProxy.build().invokeTunnel(CompositeProxyTunnel.INSTANCE).create( ObjectFactory.class, Optional.ofNullable(executorFactory).orElse(ExecutorFactory.DEFAULT), Optional.ofNullable(retryExecutorFactory).orElse(RetryExecutorFactory.DEFAULT)); } - Builder initFrom(ObjectFactory of) { + public Builder initFrom(ObjectFactory of) { Objects.requireNonNull(of); return executorFactory(of).retryExecutorFactory(of); } - Builder executorFactory(ExecutorFactory v) { + public Builder executorFactory(ExecutorFactory v) { executorFactory = v; return this; } - Builder retryExecutorFactory(RetryExecutorFactory v) { + public Builder retryExecutorFactory(RetryExecutorFactory v) { retryExecutorFactory = v; return this; } @@ -68,5 +68,5 @@ interface ObjectFactory extends ExecutorFactory, RetryExecutorFactory { private RetryExecutorFactory retryExecutorFactory; } - static final ObjectFactory DEFAULT = build().create(); + public static final ObjectFactory DEFAULT = build().create(); } diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/RetryExecutorFactory.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/RetryExecutorFactory.java index 3efb522abd4..f18ce61fc04 100644 --- a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/RetryExecutorFactory.java +++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/RetryExecutorFactory.java @@ -27,9 +27,9 @@ package jdk.jpackage.internal; import jdk.jpackage.internal.util.RetryExecutor; @FunctionalInterface -interface RetryExecutorFactory { +public interface RetryExecutorFactory { RetryExecutor retryExecutor(Class exceptionType); - static final RetryExecutorFactory DEFAULT = RetryExecutor::new; + public static final RetryExecutorFactory DEFAULT = RetryExecutor::new; } diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/util/MemoizingSupplier.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/util/MemoizingSupplier.java new file mode 100644 index 00000000000..2974c498867 --- /dev/null +++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/util/MemoizingSupplier.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * 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. + */ +package jdk.jpackage.internal.util; + +import jdk.jpackage.internal.util.function.ExceptionBox; +import java.util.Objects; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.FutureTask; +import java.util.function.Supplier; + +public final class MemoizingSupplier implements Supplier { + + public MemoizingSupplier(Supplier supplier) { + this.future = new FutureTask<>(Objects.requireNonNull(supplier)::get); + } + + @Override + public T get() { + try { + future.run(); + return future.get(); + } catch (InterruptedException ex) { + throw ExceptionBox.toUnchecked(ex); + } catch (ExecutionException ex) { + throw ExceptionBox.toUnchecked(ExceptionBox.unbox(ex.getCause())); + } + } + + public static Supplier runOnce(Supplier supplier) { + return new MemoizingSupplier<>(supplier); + } + + private final FutureTask future; +} diff --git a/src/jdk.jpackage/windows/classes/jdk/jpackage/internal/WinBundlingEnvironment.java b/src/jdk.jpackage/windows/classes/jdk/jpackage/internal/WinBundlingEnvironment.java index de52a222d7d..e10bfb95abf 100644 --- a/src/jdk.jpackage/windows/classes/jdk/jpackage/internal/WinBundlingEnvironment.java +++ b/src/jdk.jpackage/windows/classes/jdk/jpackage/internal/WinBundlingEnvironment.java @@ -29,6 +29,7 @@ import static jdk.jpackage.internal.WinPackagingPipeline.APPLICATION_LAYOUT; import static jdk.jpackage.internal.cli.StandardBundlingOperation.CREATE_WIN_APP_IMAGE; import static jdk.jpackage.internal.cli.StandardBundlingOperation.CREATE_WIN_EXE; import static jdk.jpackage.internal.cli.StandardBundlingOperation.CREATE_WIN_MSI; +import static jdk.jpackage.internal.util.MemoizingSupplier.runOnce; import jdk.jpackage.internal.cli.Options; diff --git a/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/MockUtils.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/stdmock/JPackageMockUtils.java similarity index 76% rename from test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/MockUtils.java rename to test/jdk/tools/jpackage/helpers/jdk/jpackage/test/stdmock/JPackageMockUtils.java index e88077a6c9d..604bcd0711f 100644 --- a/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/MockUtils.java +++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/stdmock/JPackageMockUtils.java @@ -21,18 +21,27 @@ * questions. */ -package jdk.jpackage.internal; +package jdk.jpackage.test.stdmock; +import static jdk.jpackage.internal.util.MemoizingSupplier.runOnce; import static jdk.jpackage.internal.util.function.ThrowingSupplier.toSupplier; import java.io.PrintWriter; +import java.lang.reflect.Constructor; import java.util.List; +import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.function.Consumer; +import java.util.function.Supplier; import java.util.function.UnaryOperator; import java.util.spi.ToolProvider; +import java.util.stream.Collectors; import jdk.internal.util.OperatingSystem; +import jdk.jpackage.internal.Executor; +import jdk.jpackage.internal.ExecutorFactory; +import jdk.jpackage.internal.Globals; +import jdk.jpackage.internal.ObjectFactory; import jdk.jpackage.internal.cli.CliBundlingEnvironment; import jdk.jpackage.internal.cli.Main; import jdk.jpackage.internal.util.function.ExceptionBox; @@ -41,11 +50,11 @@ import jdk.jpackage.test.mock.ToolProviderCommandMock; import jdk.jpackage.test.mock.VerbatimCommandMock; /** - * Bridges "jdk.jpackage.internal" and "jdk.jpackage.test.mock" packages. + * Utilities to create jpackage mock. */ -public final class MockUtils { +public final class JPackageMockUtils { - private MockUtils() { + private JPackageMockUtils() { } public static JPackageToolProviderBuilder buildJPackage() { @@ -58,30 +67,23 @@ public final class MockUtils { return createJPackageToolProvider(os(), createObjectFactory()); } - public Consumer createGlobalsMutator() { - var objectFactory = createObjectFactory(); - return globals -> { - globals.objectFactory(objectFactory); - }; - } - public void applyToGlobals() { - createGlobalsMutator().accept(Globals.instance()); + Globals.instance().objectFactory(createObjectFactory()); } - ExecutorFactory createExecutorFactory() { - var commandMocksExecutorFactory = Optional.ofNullable(script).map(MockUtils::withCommandMocks).map(mapper -> { + public ExecutorFactory createExecutorFactory() { + var commandMocksExecutorFactory = Optional.ofNullable(script).map(JPackageMockUtils::withCommandMocks).map(mapper -> { return mapper.apply(ExecutorFactory.DEFAULT); }).orElse(ExecutorFactory.DEFAULT); - var recordingExecutorFactory = Optional.ofNullable(listener).map(MockUtils::withCommandListener).map(mapper -> { + var recordingExecutorFactory = Optional.ofNullable(listener).map(JPackageMockUtils::withCommandListener).map(mapper -> { return mapper.apply(commandMocksExecutorFactory); }).orElse(commandMocksExecutorFactory); return recordingExecutorFactory; } - ObjectFactory createObjectFactory() { + public ObjectFactory createObjectFactory() { var executorFactory = createExecutorFactory(); if (executorFactory == ExecutorFactory.DEFAULT) { return ObjectFactory.DEFAULT; @@ -125,6 +127,31 @@ public final class MockUtils { return createJPackageToolProvider(OperatingSystem.current(), script); } + public static Map> availableBundlingEnvironments() { + return Map.ofEntries( + Map.entry(OperatingSystem.WINDOWS, "WinBundlingEnvironment"), + Map.entry(OperatingSystem.LINUX, "LinuxBundlingEnvironment"), + Map.entry(OperatingSystem.MACOS, "MacBundlingEnvironment") + ).entrySet().stream().map(e -> { + Constructor ctor; + try { + ctor = Class.forName("jdk.jpackage.internal." + e.getValue()).getConstructor(); + } catch (NoSuchMethodException | SecurityException ex) { + throw ExceptionBox.toUnchecked(ex); + } catch (ClassNotFoundException ex) { + return Optional.>>empty(); + } + return Optional.of(Map.entry(e.getKey(), toSupplier(() -> { + return (CliBundlingEnvironment)ctor.newInstance(); + }))); + }).flatMap(Optional::stream).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + } + + public static CliBundlingEnvironment createBundlingEnvironment(OperatingSystem os) { + Objects.requireNonNull(os); + return Objects.requireNonNull(availableBundlingEnvironments().get(os)).get(); + } + private static UnaryOperator withCommandListener(Consumer> listener) { Objects.requireNonNull(listener); return executorFactory -> { @@ -180,39 +207,11 @@ public final class MockUtils { }; } - public static CliBundlingEnvironment createBundlingEnvironment(OperatingSystem os) { - Objects.requireNonNull(os); - - String bundlingEnvironmentClassName; - switch (os) { - case WINDOWS -> { - bundlingEnvironmentClassName = "WinBundlingEnvironment"; - } - case LINUX -> { - bundlingEnvironmentClassName = "LinuxBundlingEnvironment"; - } - case MACOS -> { - bundlingEnvironmentClassName = "MacBundlingEnvironment"; - } - default -> { - throw new IllegalArgumentException(); - } - } - - return toSupplier(() -> { - var ctor = Class.forName(String.join(".", - DefaultBundlingEnvironment.class.getPackageName(), - bundlingEnvironmentClassName - )).getConstructor(); - return (CliBundlingEnvironment)ctor.newInstance(); - }).get(); - } - - static ToolProvider createJPackageToolProvider(OperatingSystem os, ObjectFactory of) { + private static ToolProvider createJPackageToolProvider(OperatingSystem os, ObjectFactory of) { Objects.requireNonNull(os); Objects.requireNonNull(of); - var impl = new Main.Provider(DefaultBundlingEnvironment.runOnce(() -> { + var impl = new Main.Provider(runOnce(() -> { return createBundlingEnvironment(os); })); diff --git a/test/jdk/tools/jpackage/junit/linux/jdk.jpackage/jdk/jpackage/internal/LinuxPackageArchTest.java b/test/jdk/tools/jpackage/junit/linux/jdk.jpackage/jdk/jpackage/internal/LinuxPackageArchTest.java index baf03a32142..d1332fc59e5 100644 --- a/test/jdk/tools/jpackage/junit/linux/jdk.jpackage/jdk/jpackage/internal/LinuxPackageArchTest.java +++ b/test/jdk/tools/jpackage/junit/linux/jdk.jpackage/jdk/jpackage/internal/LinuxPackageArchTest.java @@ -37,6 +37,7 @@ import jdk.jpackage.test.mock.CommandActionSpecs; import jdk.jpackage.test.mock.CommandMockExit; import jdk.jpackage.test.mock.CommandMockSpec; import jdk.jpackage.test.mock.Script; +import jdk.jpackage.test.stdmock.JPackageMockUtils; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -137,7 +138,7 @@ public class LinuxPackageArchTest { Globals.main(() -> { - MockUtils.buildJPackage().script(script).applyToGlobals(); + JPackageMockUtils.buildJPackage().script(script).applyToGlobals(); Result arch = LinuxPackageArch.create(pkgType); diff --git a/test/jdk/tools/jpackage/junit/linux/jdk.jpackage/jdk/jpackage/internal/LinuxSystemEnvironmentTest.java b/test/jdk/tools/jpackage/junit/linux/jdk.jpackage/jdk/jpackage/internal/LinuxSystemEnvironmentTest.java index 8ff958491b1..5104dd1b252 100644 --- a/test/jdk/tools/jpackage/junit/linux/jdk.jpackage/jdk/jpackage/internal/LinuxSystemEnvironmentTest.java +++ b/test/jdk/tools/jpackage/junit/linux/jdk.jpackage/jdk/jpackage/internal/LinuxSystemEnvironmentTest.java @@ -34,6 +34,7 @@ import jdk.jpackage.test.mock.CommandActionSpecs; import jdk.jpackage.test.mock.CommandMockExit; import jdk.jpackage.test.mock.CommandMockSpec; import jdk.jpackage.test.mock.Script; +import jdk.jpackage.test.stdmock.JPackageMockUtils; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -86,7 +87,7 @@ public class LinuxSystemEnvironmentTest { Globals.main(() -> { - MockUtils.buildJPackage().script(script).applyToGlobals(); + JPackageMockUtils.buildJPackage().script(script).applyToGlobals(); var actual = LinuxSystemEnvironment.detectNativePackageType(); diff --git a/test/jdk/tools/jpackage/junit/linux/junit.java b/test/jdk/tools/jpackage/junit/linux/junit.java index 0fd337c812c..ba06cb30db7 100644 --- a/test/jdk/tools/jpackage/junit/linux/junit.java +++ b/test/jdk/tools/jpackage/junit/linux/junit.java @@ -36,9 +36,9 @@ * @requires (os.family == "linux") * @library /test/jdk/tools/jpackage/helpers * @build jdk.jpackage.test.mock.* + * @build jdk.jpackage.test.stdmock.* * @compile/module=jdk.jpackage -Xlint:all -Werror * jdk/jpackage/internal/LinuxSystemEnvironmentTest.java - * ../../share/jdk.jpackage/jdk/jpackage/internal/MockUtils.java * @run junit jdk.jpackage/jdk.jpackage.internal.LinuxSystemEnvironmentTest */ @@ -57,8 +57,8 @@ * @requires (os.family == "linux") * @library /test/jdk/tools/jpackage/helpers * @build jdk.jpackage.test.mock.* + * @build jdk.jpackage.test.stdmock.* * @compile/module=jdk.jpackage -Xlint:all -Werror * jdk/jpackage/internal/LinuxPackageArchTest.java - * ../../share/jdk.jpackage/jdk/jpackage/internal/MockUtils.java * @run junit jdk.jpackage/jdk.jpackage.internal.LinuxPackageArchTest */ diff --git a/test/jdk/tools/jpackage/junit/macosx/jdk.jpackage/jdk/jpackage/internal/MacDmgPackagerTest.java b/test/jdk/tools/jpackage/junit/macosx/jdk.jpackage/jdk/jpackage/internal/MacDmgPackagerTest.java index e5da383142a..0e4893c8a06 100644 --- a/test/jdk/tools/jpackage/junit/macosx/jdk.jpackage/jdk/jpackage/internal/MacDmgPackagerTest.java +++ b/test/jdk/tools/jpackage/junit/macosx/jdk.jpackage/jdk/jpackage/internal/MacDmgPackagerTest.java @@ -56,6 +56,7 @@ import jdk.jpackage.test.mock.CommandMockSpec; import jdk.jpackage.test.mock.MockIllegalStateException; import jdk.jpackage.test.mock.ScriptSpec; import jdk.jpackage.test.mock.ScriptSpecInDir; +import jdk.jpackage.test.stdmock.JPackageMockUtils; import org.junit.jupiter.api.io.TempDir; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -240,7 +241,7 @@ public class MacDmgPackagerTest { var script = dir(Objects.requireNonNull(workDir)).create(); - ExecutorFactory executorFactory = MockUtils.buildJPackage() + ExecutorFactory executorFactory = JPackageMockUtils.buildJPackage() .script(script).listener(System.out::println).createExecutorFactory(); var objectFactory = ObjectFactory.build() @@ -406,14 +407,14 @@ public class MacDmgPackagerTest { } } - private final static BiConsumer> EXPAND_PATH = (path, sink) -> { + private static final BiConsumer> EXPAND_PATH = (path, sink) -> { do { sink.accept(path); path = path.getParent(); } while (path != null); }; - private final static List DMG_ICON_FILES = Stream.of( + private static final List DMG_ICON_FILES = Stream.of( ".VolumeIcon.icns", ".background/background.tiff" ).map(Path::of).collect(Collectors.toUnmodifiableList()); diff --git a/test/jdk/tools/jpackage/junit/macosx/jdk.jpackage/jdk/jpackage/internal/MacDmgSystemEnvironmentTest.java b/test/jdk/tools/jpackage/junit/macosx/jdk.jpackage/jdk/jpackage/internal/MacDmgSystemEnvironmentTest.java index de2b07e86a6..8e892106cb4 100644 --- a/test/jdk/tools/jpackage/junit/macosx/jdk.jpackage/jdk/jpackage/internal/MacDmgSystemEnvironmentTest.java +++ b/test/jdk/tools/jpackage/junit/macosx/jdk.jpackage/jdk/jpackage/internal/MacDmgSystemEnvironmentTest.java @@ -32,11 +32,11 @@ import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.stream.Collectors; -import jdk.jpackage.internal.util.RetryExecutor; import jdk.jpackage.test.mock.CommandActionSpecs; import jdk.jpackage.test.mock.CommandMockExit; import jdk.jpackage.test.mock.CommandMockSpec; import jdk.jpackage.test.mock.Script; +import jdk.jpackage.test.stdmock.JPackageMockUtils; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -143,7 +143,7 @@ public class MacDmgSystemEnvironmentTest { }).createSequence(); Globals.main(() -> { - MockUtils.buildJPackage().script(script).applyToGlobals(); + JPackageMockUtils.buildJPackage().script(script).applyToGlobals(); var actual = MacDmgSystemEnvironment.findSetFileUtility(); diff --git a/test/jdk/tools/jpackage/junit/macosx/junit.java b/test/jdk/tools/jpackage/junit/macosx/junit.java index c7fd2bc5f8d..2253211add0 100644 --- a/test/jdk/tools/jpackage/junit/macosx/junit.java +++ b/test/jdk/tools/jpackage/junit/macosx/junit.java @@ -36,9 +36,9 @@ * @requires (os.family == "mac") * @library /test/jdk/tools/jpackage/helpers * @build jdk.jpackage.test.mock.* + * @build jdk.jpackage.test.stdmock.* * @compile/module=jdk.jpackage -Xlint:all -Werror * jdk/jpackage/internal/MacDmgSystemEnvironmentTest.java - * ../../share/jdk.jpackage/jdk/jpackage/internal/MockUtils.java * @run junit jdk.jpackage/jdk.jpackage.internal.MacDmgSystemEnvironmentTest */ @@ -47,8 +47,8 @@ * @requires (os.family == "mac") * @library /test/jdk/tools/jpackage/helpers * @build jdk.jpackage.test.mock.* + * @build jdk.jpackage.test.stdmock.* * @compile/module=jdk.jpackage -Xlint:all -Werror * jdk/jpackage/internal/MacDmgPackagerTest.java - * ../../share/jdk.jpackage/jdk/jpackage/internal/MockUtils.java * @run junit jdk.jpackage/jdk.jpackage.internal.MacDmgPackagerTest */ diff --git a/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/DefaultBundlingEnvironmentTest.java b/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/DefaultBundlingEnvironmentTest.java index 709f0f8413b..ac05f5e2b69 100644 --- a/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/DefaultBundlingEnvironmentTest.java +++ b/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/DefaultBundlingEnvironmentTest.java @@ -54,6 +54,7 @@ import jdk.jpackage.test.mock.CommandActionSpecs; import jdk.jpackage.test.mock.CommandMock; import jdk.jpackage.test.mock.CommandMockExit; import jdk.jpackage.test.mock.Script; +import jdk.jpackage.test.stdmock.JPackageMockUtils; import org.junit.jupiter.api.Test; @@ -96,7 +97,7 @@ public class DefaultBundlingEnvironmentTest extends JUnitAdapter { var script = createMockScript(op); - ToolProvider jpackage = MockUtils.buildJPackage() + ToolProvider jpackage = JPackageMockUtils.buildJPackage() .os(op.os()) .script(script) .listener(executedCommands::add).create(); diff --git a/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/cli/MainTest.java b/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/cli/MainTest.java index 239ce0d0ce9..1c06d592006 100644 --- a/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/cli/MainTest.java +++ b/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/cli/MainTest.java @@ -50,7 +50,6 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import jdk.internal.util.OperatingSystem; import jdk.jpackage.internal.Globals; -import jdk.jpackage.internal.MockUtils; import jdk.jpackage.internal.model.ConfigException; import jdk.jpackage.internal.model.ExecutableAttributesWithCapturedOutput; import jdk.jpackage.internal.model.JPackageException; @@ -67,6 +66,7 @@ import jdk.jpackage.test.TKit; import jdk.jpackage.test.mock.CommandActionSpecs; import jdk.jpackage.test.mock.Script; import jdk.jpackage.test.mock.VerbatimCommandMock; +import jdk.jpackage.test.stdmock.JPackageMockUtils; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.ValueSource; @@ -124,9 +124,8 @@ public class MainTest extends JUnitAdapter { var jpackageToolProviderMock = new ToolProvider() { @Override public int run(PrintWriter out, PrintWriter err, String... args) { - var globalsMutator = MockUtils.buildJPackage().script(script).createGlobalsMutator(); - return Globals.main(() -> { - globalsMutator.accept(Globals.instance()); + return Globals.main(() -> { + JPackageMockUtils.buildJPackage().script(script).applyToGlobals(); var result = ExecutionResult.create(args); diff --git a/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/util/MemoizingSupplierTest.java b/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/util/MemoizingSupplierTest.java new file mode 100644 index 00000000000..654071359cb --- /dev/null +++ b/test/jdk/tools/jpackage/junit/share/jdk.jpackage/jdk/jpackage/internal/util/MemoizingSupplierTest.java @@ -0,0 +1,163 @@ +/* + * Copyright (c) 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. + */ + +package jdk.jpackage.internal.util; + +import static jdk.jpackage.internal.util.function.ThrowingRunnable.toRunnable; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrowsExactly; + +import java.util.Objects; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Executors; +import java.util.function.Supplier; +import java.util.stream.IntStream; +import org.junit.jupiter.api.Test; + + +class MemoizingSupplierTest { + + @Test + void test() { + var supplier = count(() -> "foo"); + var runOnceSupplier = MemoizingSupplier.runOnce(supplier); + + assertEquals(0, supplier.counter()); + + assertEquals("foo", runOnceSupplier.get()); + assertEquals("foo", runOnceSupplier.get()); + + assertEquals(1, supplier.counter()); + } + + @Test + void test_null() { + CountingSupplier supplier = count(() -> null); + var runOnceSupplier = MemoizingSupplier.runOnce(supplier); + + assertEquals(0, supplier.counter()); + + assertEquals(null, runOnceSupplier.get()); + assertEquals(null, runOnceSupplier.get()); + + assertEquals(1, supplier.counter()); + } + + @Test + void test_throws_Exception() { + CountingSupplier supplier = count(() -> { + throw new IllegalStateException("Kaput!"); + }); + var runOnceSupplier = MemoizingSupplier.runOnce(supplier); + + assertEquals(0, supplier.counter()); + + assertThrowsExactly(IllegalStateException.class, () -> { + runOnceSupplier.get(); + }); + + assertThrowsExactly(IllegalStateException.class, () -> { + runOnceSupplier.get(); + }); + + assertEquals(1, supplier.counter()); + } + + @Test + void test_throws_Error() { + CountingSupplier supplier = count(() -> { + throw new Error("Grand kaput!"); + }); + var runOnceSupplier = MemoizingSupplier.runOnce(supplier); + + assertEquals(0, supplier.counter()); + + assertThrowsExactly(Error.class, () -> { + runOnceSupplier.get(); + }); + + assertThrowsExactly(Error.class, () -> { + runOnceSupplier.get(); + }); + + assertEquals(1, supplier.counter()); + } + + @Test + void testAsync() throws InterruptedException { + var supplier = count(() -> "foo"); + var runOnceSupplier = MemoizingSupplier.runOnce(supplier); + + final var supplierCount = 100; + final var supplierExecutor = Executors.newVirtualThreadPerTaskExecutor(); + + // Schedule invoking "runOnceSupplier.get()" in a separate virtual threads. + // Start and suspend threads, waiting until all scheduled threads have started. + // After all scheduled threads start, resume them. + // This should result in multiple simultaneous "runOnceSupplier.get()" calls. + + var readyLatch = new CountDownLatch(supplierCount); + var startLatch = new CountDownLatch(1); + + var futures = IntStream.range(0, supplierCount).mapToObj(_ -> { + return CompletableFuture.runAsync(toRunnable(() -> { + readyLatch.countDown(); + startLatch.await(); + runOnceSupplier.get(); + + }), supplierExecutor); + }).toList(); + + readyLatch.await(); + startLatch.countDown(); + + CompletableFuture.allOf(futures.toArray(CompletableFuture[]::new)).join(); + + assertEquals(1, supplier.counter()); + } + + private static CountingSupplier count(Supplier supplier) { + return new CountingSupplier<>(supplier); + } + + private static final class CountingSupplier implements Supplier { + + CountingSupplier(Supplier impl) { + this.impl = Objects.requireNonNull(impl); + } + + @Override + public T get() { + counter++; + return impl.get(); + } + + int counter() { + return counter; + } + + private int counter; + private final Supplier impl; + } +} From 3b0160f50f2e0ec1c80c855c667677eb2f553eae Mon Sep 17 00:00:00 2001 From: Brian Burkhalter Date: Mon, 23 Feb 2026 18:09:31 +0000 Subject: [PATCH 53/63] 8378115: (fs) sun.nio.fs.NativeBuffer no longer needs a cleaner Reviewed-by: alanb --- .../classes/sun/nio/fs/NativeBuffer.java | 32 +++++++++---------- .../classes/sun/nio/fs/NativeBuffers.java | 5 +-- .../sun/nio/fs/UnixNativeDispatcher.java | 5 +-- .../sun/nio/fs/WindowsNativeDispatcher.java | 5 +-- 4 files changed, 24 insertions(+), 23 deletions(-) diff --git a/src/java.base/share/classes/sun/nio/fs/NativeBuffer.java b/src/java.base/share/classes/sun/nio/fs/NativeBuffer.java index 9500a737af7..dc0c8e4d8c9 100644 --- a/src/java.base/share/classes/sun/nio/fs/NativeBuffer.java +++ b/src/java.base/share/classes/sun/nio/fs/NativeBuffer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 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 @@ -25,9 +25,7 @@ package sun.nio.fs; -import java.lang.ref.Cleaner.Cleanable; import jdk.internal.misc.Unsafe; -import jdk.internal.ref.CleanerFactory; /** * A light-weight buffer in native memory. @@ -38,27 +36,17 @@ class NativeBuffer implements AutoCloseable { private final long address; private final int size; - private final Cleanable cleanable; // optional "owner" to avoid copying // (only safe for use by thread-local caches) private Object owner; - private static class Deallocator implements Runnable { - private final long address; - Deallocator(long address) { - this.address = address; - } - public void run() { - unsafe.freeMemory(address); - } - } + // owner thread ID + private long ownerTid; NativeBuffer(int size) { this.address = unsafe.allocateMemory(size); this.size = size; - this.cleanable = CleanerFactory.cleaner() - .register(this, new Deallocator(address)); } @Override @@ -79,16 +67,26 @@ class NativeBuffer implements AutoCloseable { } void free() { - cleanable.clean(); + unsafe.freeMemory(address); } // not synchronized; only safe for use by thread-local caches void setOwner(Object owner) { + Thread thread = Thread.currentThread(); + assert !thread.isVirtual(); + assert ownerTid == 0 || ownerTid == thread.threadId(); this.owner = owner; + this.ownerTid = (owner != null) ? thread.threadId() : 0; } // not synchronized; only safe for use by thread-local caches Object owner() { - return owner; + long tid = Thread.currentThread().threadId(); + assert ownerTid == 0 || ownerTid == tid; + if (ownerTid == tid) { + return owner; + } else { + return null; + } } } diff --git a/src/java.base/share/classes/sun/nio/fs/NativeBuffers.java b/src/java.base/share/classes/sun/nio/fs/NativeBuffers.java index 9b93cce9114..750da8c1a3d 100644 --- a/src/java.base/share/classes/sun/nio/fs/NativeBuffers.java +++ b/src/java.base/share/classes/sun/nio/fs/NativeBuffers.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 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 @@ -92,7 +92,8 @@ class NativeBuffers { static NativeBuffer getNativeBuffer(int size) { NativeBuffer buffer = getNativeBufferFromCache(size); if (buffer != null) { - buffer.setOwner(null); + if (!Thread.currentThread().isVirtual()) + buffer.setOwner(null); return buffer; } else { return allocNativeBuffer(size); diff --git a/src/java.base/unix/classes/sun/nio/fs/UnixNativeDispatcher.java b/src/java.base/unix/classes/sun/nio/fs/UnixNativeDispatcher.java index 77dc1851478..2d72aeb2ee9 100644 --- a/src/java.base/unix/classes/sun/nio/fs/UnixNativeDispatcher.java +++ b/src/java.base/unix/classes/sun/nio/fs/UnixNativeDispatcher.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 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 @@ -47,7 +47,8 @@ class UnixNativeDispatcher { return buffer; } NativeBuffers.copyCStringToNativeBuffer(cstr, buffer); - buffer.setOwner(path); + if (!Thread.currentThread().isVirtual()) + buffer.setOwner(path); return buffer; } diff --git a/src/java.base/windows/classes/sun/nio/fs/WindowsNativeDispatcher.java b/src/java.base/windows/classes/sun/nio/fs/WindowsNativeDispatcher.java index 8e351b7e0ef..ba1b7b1aa9f 100644 --- a/src/java.base/windows/classes/sun/nio/fs/WindowsNativeDispatcher.java +++ b/src/java.base/windows/classes/sun/nio/fs/WindowsNativeDispatcher.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 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 @@ -1085,7 +1085,8 @@ class WindowsNativeDispatcher { unsafe.copyMemory(chars, Unsafe.ARRAY_CHAR_BASE_OFFSET, null, buffer.address(), (long)stringLengthInBytes); unsafe.putChar(buffer.address() + stringLengthInBytes, (char)0); - buffer.setOwner(s); + if (!Thread.currentThread().isVirtual()) + buffer.setOwner(s); return buffer; } From 1cb8b6d1b579a91b71bc0a478044a04b84d12ae9 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Mon, 23 Feb 2026 18:21:58 +0000 Subject: [PATCH 54/63] 8378202: Remove AppContext from XAWT classes Reviewed-by: serb, azvegint --- .../sun/awt/X11/XDropTargetContextPeer.java | 23 ++++--------------- .../classes/sun/awt/X11/XEmbedCanvasPeer.java | 8 +++---- .../unix/classes/sun/awt/X11/XSelection.java | 9 ++------ .../classes/sun/awt/X11/XSystemTrayPeer.java | 16 ++++--------- 4 files changed, 14 insertions(+), 42 deletions(-) diff --git a/src/java.desktop/unix/classes/sun/awt/X11/XDropTargetContextPeer.java b/src/java.desktop/unix/classes/sun/awt/X11/XDropTargetContextPeer.java index a7130fa7fe9..560e114982f 100644 --- a/src/java.desktop/unix/classes/sun/awt/X11/XDropTargetContextPeer.java +++ b/src/java.desktop/unix/classes/sun/awt/X11/XDropTargetContextPeer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 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 @@ -35,7 +35,6 @@ import java.util.Iterator; import sun.awt.AWTAccessor; import sun.util.logging.PlatformLogger; -import sun.awt.AppContext; import sun.awt.SunToolkit; import sun.awt.dnd.SunDropTargetContextPeer; @@ -55,20 +54,14 @@ final class XDropTargetContextPeer extends SunDropTargetContextPeer { private static final Unsafe unsafe = XlibWrapper.unsafe; - /* - * A key to store a peer instance for an AppContext. - */ - private static final Object DTCP_KEY = "DropTargetContextPeer"; - private XDropTargetContextPeer() {} - static XDropTargetContextPeer getPeer(AppContext appContext) { + private static XDropTargetContextPeer peer; + + static XDropTargetContextPeer getPeer() { synchronized (_globalLock) { - XDropTargetContextPeer peer = - (XDropTargetContextPeer)appContext.get(DTCP_KEY); if (peer == null) { peer = new XDropTargetContextPeer(); - appContext.put(DTCP_KEY, peer); } return peer; @@ -261,17 +254,11 @@ final class XDropTargetContextPeer extends SunDropTargetContextPeer { int eventID) { Object target = xwindow.getTarget(); - // The Every component is associated with some AppContext. assert target instanceof Component; Component component = (Component)target; - AppContext appContext = SunToolkit.targetToAppContext(target); - - // Every component is associated with some AppContext. - assert appContext != null; - - XDropTargetContextPeer peer = XDropTargetContextPeer.getPeer(appContext); + XDropTargetContextPeer peer = XDropTargetContextPeer.getPeer(); peer.postDropTargetEvent(component, x, y, dropAction, actions, formats, nativeCtxt, eventID, diff --git a/src/java.desktop/unix/classes/sun/awt/X11/XEmbedCanvasPeer.java b/src/java.desktop/unix/classes/sun/awt/X11/XEmbedCanvasPeer.java index bc1b3ac9f4b..f5bb47db50c 100644 --- a/src/java.desktop/unix/classes/sun/awt/X11/XEmbedCanvasPeer.java +++ b/src/java.desktop/unix/classes/sun/awt/X11/XEmbedCanvasPeer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 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 @@ -338,7 +338,7 @@ public final class XEmbedCanvasPeer extends XCanvasPeer implements WindowFocusLi // Rectangle my_bounds = getBounds(); // setBounds(my_bounds.x, my_bounds.y, bounds.width, bounds.height, SET_BOUNDS); } - XToolkit.postEvent(XToolkit.targetToAppContext(target), new ComponentEvent(target, ComponentEvent.COMPONENT_RESIZED)); + XToolkit.postEvent(new ComponentEvent(target, ComponentEvent.COMPONENT_RESIZED)); } void focusNext() { @@ -735,9 +735,7 @@ public final class XEmbedCanvasPeer extends XCanvasPeer implements WindowFocusLi xembedLog.finest(" Drop target=" + target.getDropTarget()); } if (target.getDropTarget() instanceof XEmbedDropTarget) { - AppContext appContext = XToolkit.targetToAppContext(getTarget()); - XDropTargetContextPeer peer = - XDropTargetContextPeer.getPeer(appContext); + XDropTargetContextPeer peer = XDropTargetContextPeer.getPeer(); peer.forwardEventToEmbedded(xembed.handle, ctxt, eventID); return true; } else { diff --git a/src/java.desktop/unix/classes/sun/awt/X11/XSelection.java b/src/java.desktop/unix/classes/sun/awt/X11/XSelection.java index f7a40312fe7..e93b311633d 100644 --- a/src/java.desktop/unix/classes/sun/awt/X11/XSelection.java +++ b/src/java.desktop/unix/classes/sun/awt/X11/XSelection.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 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 @@ -34,7 +34,6 @@ import java.io.IOException; import java.util.Hashtable; import java.util.Map; -import sun.awt.AppContext; import sun.awt.SunToolkit; import sun.awt.UNIXToolkit; @@ -91,8 +90,6 @@ final class XSelection { private Map formatMap = null; /* The formats supported by the current owner was set. */ private long[] formats = null; - /* The AppContext in which the current owner was set. */ - private AppContext appContext = null; // The X server time of the last XConvertSelection() call; // protected with 'lock' and awtLock. private static long lastRequestServerTime; @@ -148,7 +145,6 @@ final class XSelection { this.contents = contents; this.formatMap = formatMap; this.formats = formats; - this.appContext = AppContext.getAppContext(); this.ownershipTime = time; XToolkit.awtLock(); @@ -469,7 +465,6 @@ final class XSelection { contents = null; formatMap = null; formats = null; - appContext = null; ownershipTime = 0; } @@ -483,7 +478,7 @@ final class XSelection { int count = 0; try { - SunToolkit.insertTargetMapping(this, appContext); + SunToolkit.insertTargetMapping(this); byteData = DataTransferer.getInstance().convertData(this, contents, diff --git a/src/java.desktop/unix/classes/sun/awt/X11/XSystemTrayPeer.java b/src/java.desktop/unix/classes/sun/awt/X11/XSystemTrayPeer.java index 473b638cb74..82423a75d0c 100644 --- a/src/java.desktop/unix/classes/sun/awt/X11/XSystemTrayPeer.java +++ b/src/java.desktop/unix/classes/sun/awt/X11/XSystemTrayPeer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 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 @@ -28,7 +28,6 @@ package sun.awt.X11; import java.awt.*; import java.awt.peer.SystemTrayPeer; import sun.awt.SunToolkit; -import sun.awt.AppContext; import sun.awt.AWTAccessor; import sun.awt.UNIXToolkit; import sun.util.logging.PlatformLogger; @@ -183,7 +182,7 @@ public final class XSystemTrayPeer implements SystemTrayPeer, XMSelectionListene .firePropertyChange(target, propertyName, oldValue, newValue); } }; - invokeOnEachAppContext(runnable); + SunToolkit.invokeLater(runnable); } private void createTrayPeers() { @@ -198,7 +197,7 @@ public final class XSystemTrayPeer implements SystemTrayPeer, XMSelectionListene } } }; - invokeOnEachAppContext(runnable); + SunToolkit.invokeLater(runnable); } private void removeTrayPeers() { @@ -210,13 +209,6 @@ public final class XSystemTrayPeer implements SystemTrayPeer, XMSelectionListene } } }; - invokeOnEachAppContext(runnable); + SunToolkit.invokeLater(runnable); } - - private void invokeOnEachAppContext(Runnable runnable) { - for (AppContext appContext : AppContext.getAppContexts()) { - SunToolkit.invokeLaterOnAppContext(appContext, runnable); - } - } - } From 569d18fbe51a036629337c38230ae4892365a228 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Mon, 23 Feb 2026 18:36:00 +0000 Subject: [PATCH 55/63] 8337853: Remove SunLayoutEngineKey and SunLayoutEngineFactory and its cache. Reviewed-by: azvegint, dnguyen --- .../share/classes/java/awt/Font.java | 4 +- .../sun/font/ExtendedTextSourceLabel.java | 4 +- .../share/classes/sun/font/GlyphLayout.java | 114 ++--------------- .../classes/sun/font/SunLayoutEngine.java | 118 ++---------------- 4 files changed, 24 insertions(+), 216 deletions(-) diff --git a/src/java.desktop/share/classes/java/awt/Font.java b/src/java.desktop/share/classes/java/awt/Font.java index 0614163fb7f..cb811d5d533 100644 --- a/src/java.desktop/share/classes/java/awt/Font.java +++ b/src/java.desktop/share/classes/java/awt/Font.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1995, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1995, 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 @@ -2709,7 +2709,7 @@ public class Font implements java.io.Serializable int limit, int flags) { - GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines + GlyphLayout gl = GlyphLayout.get(); StandardGlyphVector gv = gl.layout(this, frc, text, start, limit-start, flags, null); GlyphLayout.done(gl); diff --git a/src/java.desktop/share/classes/sun/font/ExtendedTextSourceLabel.java b/src/java.desktop/share/classes/sun/font/ExtendedTextSourceLabel.java index 85c631d6e3e..f3569941321 100644 --- a/src/java.desktop/share/classes/sun/font/ExtendedTextSourceLabel.java +++ b/src/java.desktop/share/classes/sun/font/ExtendedTextSourceLabel.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 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 @@ -399,7 +399,7 @@ class ExtendedTextSourceLabel implements TextLineComponent, Decoration.Label { int start = source.getStart(); int length = source.getLength(); - GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines + GlyphLayout gl = GlyphLayout.get(); gv = gl.layout(font, frc, context, start, length, flags, null); // ??? use textsource GlyphLayout.done(gl); diff --git a/src/java.desktop/share/classes/sun/font/GlyphLayout.java b/src/java.desktop/share/classes/sun/font/GlyphLayout.java index fe2a8bf2599..df42cce344e 100644 --- a/src/java.desktop/share/classes/sun/font/GlyphLayout.java +++ b/src/java.desktop/share/classes/sun/font/GlyphLayout.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 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 @@ -87,7 +87,6 @@ public final class GlyphLayout { // cached glyph layout data for reuse private static volatile GlyphLayout cache; // reusable - private LayoutEngineFactory _lef; // set when get is called, unset when done is called private TextRecord _textRecord; // the text we're working on, used by iterators private ScriptRun _scriptRuns; // iterator over script runs private FontRunIterator _fontRuns; // iterator over physical fonts in a composite @@ -100,91 +99,10 @@ public final class GlyphLayout { private int _typo_flags; private int _offset; - public static final class LayoutEngineKey { - private Font2D font; - private int script; - private int lang; - - LayoutEngineKey() { - } - - LayoutEngineKey(Font2D font, int script, int lang) { - init(font, script, lang); - } - - void init(Font2D font, int script, int lang) { - this.font = font; - this.script = script; - this.lang = lang; - } - - LayoutEngineKey copy() { - return new LayoutEngineKey(font, script, lang); - } - - Font2D font() { - return font; - } - - int script() { - return script; - } - - int lang() { - return lang; - } - - public boolean equals(Object rhs) { - if (this == rhs) return true; - if (rhs == null) return false; - try { - LayoutEngineKey that = (LayoutEngineKey)rhs; - return this.script == that.script && - this.lang == that.lang && - this.font.equals(that.font); - } - catch (ClassCastException e) { - return false; - } - } - - public int hashCode() { - return script ^ lang ^ font.hashCode(); - } - } - - public static interface LayoutEngineFactory { - /** - * Given a font, script, and language, determine a layout engine to use. - */ - public LayoutEngine getEngine(Font2D font, int script, int lang); - - /** - * Given a key, determine a layout engine to use. - */ - public LayoutEngine getEngine(LayoutEngineKey key); - } - - public static interface LayoutEngine { - /** - * Given a strike descriptor, text, rtl flag, and starting point, append information about - * glyphs, positions, and character indices to the glyphvector data, and advance the point. - * - * If the GVData does not have room for the glyphs, throws an IndexOutOfBoundsException and - * leave pt and the gvdata unchanged. - */ - public void layout(FontStrikeDesc sd, float[] mat, float ptSize, int gmask, - int baseIndex, TextRecord text, int typo_flags, Point2D.Float pt, GVData data); - } - /** - * Return a new instance of GlyphLayout, using the provided layout engine factory. - * If null, the system layout engine factory will be used. + * Return a possibly recycled instance of GlyphLayout */ - public static GlyphLayout get(LayoutEngineFactory lef) { - if (lef == null) { - lef = SunLayoutEngine.instance(); - } + public static GlyphLayout get() { GlyphLayout result = null; synchronized(GlyphLayout.class) { if (cache != null) { @@ -195,7 +113,6 @@ public final class GlyphLayout { if (result == null) { result = new GlyphLayout(); } - result._lef = lef; return result; } @@ -204,7 +121,6 @@ public final class GlyphLayout { * of GlyphLayout objects. */ public static void done(GlyphLayout gl) { - gl._lef = null; cache = gl; // object reference assignment is thread safe, it says here... } @@ -398,8 +314,6 @@ public final class GlyphLayout { } } - int lang = -1; // default for now - Font2D font2D = FontUtilities.getFont2D(font); if (font2D instanceof FontSubstitution) { font2D = ((FontSubstitution)font2D).getCompositeFont2D(); @@ -426,7 +340,7 @@ public final class GlyphLayout { } int gmask = _fontRuns.getGlyphMask(); int pos = _fontRuns.getPos(); - nextEngineRecord(start, pos, script, lang, pfont, gmask); + nextEngineRecord(start, pos, script, pfont, gmask); start = pos; } } @@ -435,7 +349,7 @@ public final class GlyphLayout { while (_scriptRuns.next()) { int limit = _scriptRuns.getScriptLimit(); int script = _scriptRuns.getScriptCode(); - nextEngineRecord(start, limit, script, lang, font2D, 0); + nextEngineRecord(start, limit, script, font2D, 0); start = limit; } } @@ -508,7 +422,7 @@ public final class GlyphLayout { this._gvdata.init(capacity); } - private void nextEngineRecord(int start, int limit, int script, int lang, Font2D font, int gmask) { + private void nextEngineRecord(int start, int limit, int script, Font2D font, int gmask) { EngineRecord er = null; if (_ercount == _erecords.size()) { er = new EngineRecord(); @@ -516,7 +430,7 @@ public final class GlyphLayout { } else { er = _erecords.get(_ercount); } - er.init(start, limit, font, script, lang, gmask); + er.init(start, limit, font, script, gmask); ++_ercount; } @@ -627,18 +541,18 @@ public final class GlyphLayout { private int limit; private int gmask; private int eflags; - private LayoutEngineKey key; - private LayoutEngine engine; + private Font2D font; + private int script; EngineRecord() { - key = new LayoutEngineKey(); } - void init(int start, int limit, Font2D font, int script, int lang, int gmask) { + void init(int start, int limit, Font2D font, int script, int gmask) { this.start = start; this.limit = limit; + this.font = font; + this.script = script; this.gmask = gmask; - this.key.init(font, script, lang); this.eflags = 0; // only request canonical substitution if we have combining marks @@ -659,14 +573,12 @@ public final class GlyphLayout { break; } } - - this.engine = _lef.getEngine(key); // flags? } void layout() { _textRecord.start = start; _textRecord.limit = limit; - engine.layout(_sd, _mat, ptSize, gmask, start - _offset, _textRecord, + SunLayoutEngine.layout(font, script, _sd, _mat, ptSize, gmask, start - _offset, _textRecord, _typo_flags | eflags, _pt, _gvdata); } } diff --git a/src/java.desktop/share/classes/sun/font/SunLayoutEngine.java b/src/java.desktop/share/classes/sun/font/SunLayoutEngine.java index f1d6de7d4bc..99d3987e5fd 100644 --- a/src/java.desktop/share/classes/sun/font/SunLayoutEngine.java +++ b/src/java.desktop/share/classes/sun/font/SunLayoutEngine.java @@ -1,4 +1,5 @@ /* + * Copyright (c) 2003, 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 @@ -36,126 +37,22 @@ import sun.java2d.DisposerRecord; import java.awt.geom.Point2D; import java.lang.foreign.MemorySegment; -import java.lang.ref.SoftReference; import java.util.concurrent.ConcurrentHashMap; import java.util.WeakHashMap; -/* - * different ways to do this - * 1) each physical font2d keeps a hashtable mapping scripts to layout - * engines, we query and fill this cache. - * 2) we keep a mapping independent of font using the key Most likely - * few fonts will be used, so option 2 seems better - * - * Once we know which engine to use for a font, we always know, so we - * shouldn't have to recheck each time we do layout. So the cache is - * ok. - * - * Should we reuse engines? We could instantiate an engine for each - * font/script pair. The engine would hold onto the table(s) from the - * font that it needs. If we have multiple threads using the same - * engine, we still need to keep the state separate, so the native - * engines would still need to be allocated for each call, since they - * keep their state in themselves. If they used the passed-in GVData - * arrays directly (with some checks for space) then since each GVData - * is different per thread, we could reuse the layout engines. This - * still requires a separate layout engine per font, because of the - * table state in the engine. If we pushed that out too and passed it - * in with the native call as well, we'd be ok if the layout engines - * keep all their process state on the stack, but I don't know if this - * is true. Then we'd basically just be down to an engine index which - * we pass into native and then invoke the engine code (now a - * procedure call, not an object invocation) based on a switch on the - * index. There would be only half a dozen engine objects then, not - * potentially half a dozen per font. But we'd have to stack-allocate - * some state that included the pointer to the required font tables. - * - * Seems for now that the way to do things is to come in with a - * selector and the font. The selector indicates which engine to use, - * the engine is stack allocated and initialized with the required - * font tables (the selector indicates which). Then layout is called, - * the contents are copied (or not), and the stack is destroyed on - * exit. So the association is between the font/script (layout engine - * desc) and one of a few permanent engine objects, which are - * handed the key when they need to process something. In the native - * case, the engine holds an index, and just passes it together with - * the key info down to native. Some default cases are the 'default - * layout' case that just runs the c2gmapper, this stays in java and - * just uses the mapper from the font/strike. Another default case - * might be the unicode arabic shaper, since this doesn't care about - * the font (or script or lang?) it wouldn't need to extract this - * data. It could be (yikes) ported back to java even to avoid - * upcalls to check if the font supports a particular unicode - * character. - * - * I'd expect that the majority of scripts use the default mapper for - * a particular font. Loading the hashtable with 40 or so keys 30+ of - * which all map to the same object is unfortunate. It might be worth - * instead having a per-font list of 'scripts with non-default - * engines', e.g. the factory has a hashtable mapping fonts to 'script - * lists' (the factory has this since the design potentially has other - * factories, though I admit there's no client for this yet and no - * public api) and then the script list is queried for the script in - * question. it can be preloaded at creation time with all the - * scripts that don't have default engines-- either a list or a hash - * table, so a null return from the table means 'default' and not 'i - * don't know yet'. - * - * On the other hand, in most all cases the number of unique - * script/font combinations will be small, so a flat hashtable should - * suffice. - * */ -public final class SunLayoutEngine implements LayoutEngine, LayoutEngineFactory { +public final class SunLayoutEngine { + static { FontManagerNativeLibrary.load(); } - private LayoutEngineKey key; - - private static LayoutEngineFactory instance; - - public static LayoutEngineFactory instance() { - if (instance == null) { - instance = new SunLayoutEngine(); - } - return instance; - } - private SunLayoutEngine() { - // actually a factory, key is null so layout cannot be called on it - } - - public LayoutEngine getEngine(Font2D font, int script, int lang) { - return getEngine(new LayoutEngineKey(font, script, lang)); - } - - // !!! don't need this unless we have more than one sun layout engine... - public LayoutEngine getEngine(LayoutEngineKey key) { - ConcurrentHashMap cache = cacheref.get(); - if (cache == null) { - cache = new ConcurrentHashMap<>(); - cacheref = new SoftReference<>(cache); - } - - LayoutEngine e = cache.get(key); - if (e == null) { - LayoutEngineKey copy = key.copy(); - e = new SunLayoutEngine(copy); - cache.put(copy, e); - } - return e; - } - private SoftReference> cacheref = - new SoftReference<>(null); - - private SunLayoutEngine(LayoutEngineKey key) { - this.key = key; } private static final WeakHashMap facePtr = new WeakHashMap<>(); - private long getFacePtr(Font2D font2D) { + private static long getFacePtr(Font2D font2D) { FaceRef ref; synchronized (facePtr) { ref = facePtr.computeIfAbsent(font2D, FaceRef::new); @@ -170,17 +67,16 @@ public final class SunLayoutEngine implements LayoutEngine, LayoutEngineFactory } - public void layout(FontStrikeDesc desc, float[] mat, float ptSize, int gmask, + public static void layout(Font2D font, int script, FontStrikeDesc desc, float[] mat, float ptSize, int gmask, int baseIndex, TextRecord tr, int typo_flags, Point2D.Float pt, GVData data) { - Font2D font = key.font(); FontStrike strike = font.getStrike(desc); if (useFFM) { MemorySegment face = HBShaper.getFace(font); if (face != null) { HBShaper.shape(font, strike, ptSize, mat, face, - tr.text, data, key.script(), + tr.text, data, script, tr.start, tr.limit, baseIndex, pt, typo_flags, gmask); } @@ -188,7 +84,7 @@ public final class SunLayoutEngine implements LayoutEngine, LayoutEngineFactory long pFace = getFacePtr(font); if (pFace != 0) { shape(font, strike, ptSize, mat, pFace, - tr.text, data, key.script(), + tr.text, data, script, tr.start, tr.limit, baseIndex, pt, typo_flags, gmask); } From 74a07b7487a8eed43e5514fb16336998e9b1ebc7 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Mon, 23 Feb 2026 18:39:46 +0000 Subject: [PATCH 56/63] 8378197: Remove AppContext from sun/swing/plaf/DesktopProperty.java Reviewed-by: serb, kizune --- .../sun/swing/plaf/DesktopProperty.java | 31 ++++--------------- 1 file changed, 6 insertions(+), 25 deletions(-) diff --git a/src/java.desktop/share/classes/sun/swing/plaf/DesktopProperty.java b/src/java.desktop/share/classes/sun/swing/plaf/DesktopProperty.java index 8af75f98b83..6b33f0786a8 100644 --- a/src/java.desktop/share/classes/sun/swing/plaf/DesktopProperty.java +++ b/src/java.desktop/share/classes/sun/swing/plaf/DesktopProperty.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 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 @@ -42,8 +42,6 @@ import javax.swing.UIManager; import javax.swing.plaf.ColorUIResource; import javax.swing.plaf.FontUIResource; -import sun.awt.AppContext; - /** * Wrapper for a value from the desktop. The value is lazily looked up, and * can be accessed using the UIManager.ActiveValue method @@ -52,8 +50,6 @@ import sun.awt.AppContext; * invalidate to force the value to be fetched again. */ public class DesktopProperty implements UIDefaults.ActiveValue { - private static final StringBuilder DESKTOP_PROPERTY_UPDATE_PENDING_KEY = - new StringBuilder("DesktopPropertyUpdatePending"); /** * ReferenceQueue of unreferenced WeakPCLs. @@ -90,23 +86,6 @@ public class DesktopProperty implements UIDefaults.ActiveValue { } } - - /** - * Sets whether or not an updateUI call is pending. - */ - private static synchronized void setUpdatePending(boolean update) { - AppContext.getAppContext() - .put(DESKTOP_PROPERTY_UPDATE_PENDING_KEY, update); - } - - /** - * Returns true if a UI update is pending. - */ - private static synchronized boolean isUpdatePending() { - return Boolean.TRUE.equals(AppContext.getAppContext() - .get(DESKTOP_PROPERTY_UPDATE_PENDING_KEY)); - } - /** * Updates the UIs of all the known Frames. */ @@ -202,6 +181,8 @@ public class DesktopProperty implements UIDefaults.ActiveValue { value = null; } + private static volatile boolean updatePending; + /** * Requests that all components in the GUI hierarchy be updated * to reflect dynamic changes in this {@literal look&feel}. This update occurs @@ -210,14 +191,14 @@ public class DesktopProperty implements UIDefaults.ActiveValue { * many desktop properties will change at once. */ protected void updateUI() { - if (!isUpdatePending()) { - setUpdatePending(true); + if (!updatePending) { + updatePending = true; Runnable uiUpdater = new Runnable() { public void run() { try { updateAllUIs(); } finally { - setUpdatePending(false); + updatePending = false; } } }; From 6b576235b84f51e273da44158bfcadbb48f51baa Mon Sep 17 00:00:00 2001 From: Alexey Ivanov Date: Mon, 23 Feb 2026 19:09:20 +0000 Subject: [PATCH 57/63] 8377924: Inconsistent parsing of XBM files after JDK-8361748 8377826: Eliminate code duplication in XbmImageDecoder Reviewed-by: dnguyen, prr, dmarkov --- .../sun/awt/image/XbmImageDecoder.java | 17 +-- .../awt/image/XBMDecoder/XBMDecoderTest.java | 14 +-- .../XBMDecoder/XBMDecoderWidthHeight.java | 115 ++++++++++++++++++ .../XBMDecoder/invalid_WH1-no-height.xbm | 3 + .../image/XBMDecoder/invalid_WH2-no-width.xbm | 3 + .../invalid_WH3-no-width-height.xbm | 3 + .../awt/image/XBMDecoder/valid_WH1-th-ht.xbm | 3 + .../awt/image/XBMDecoder/valid_WH2-h-ht.xbm | 3 + .../awt/image/XBMDecoder/valid_WH3-ht-th.xbm | 3 + .../awt/image/XBMDecoder/valid_WH4-ht-h.xbm | 3 + .../awt/image/XBMDecoder/valid_WH5-w-h.xbm | 3 + .../awt/image/XBMDecoder/valid_WH6-h-w.xbm | 3 + 12 files changed, 155 insertions(+), 18 deletions(-) create mode 100644 test/jdk/java/awt/image/XBMDecoder/XBMDecoderWidthHeight.java create mode 100644 test/jdk/java/awt/image/XBMDecoder/invalid_WH1-no-height.xbm create mode 100644 test/jdk/java/awt/image/XBMDecoder/invalid_WH2-no-width.xbm create mode 100644 test/jdk/java/awt/image/XBMDecoder/invalid_WH3-no-width-height.xbm create mode 100644 test/jdk/java/awt/image/XBMDecoder/valid_WH1-th-ht.xbm create mode 100644 test/jdk/java/awt/image/XBMDecoder/valid_WH2-h-ht.xbm create mode 100644 test/jdk/java/awt/image/XBMDecoder/valid_WH3-ht-th.xbm create mode 100644 test/jdk/java/awt/image/XBMDecoder/valid_WH4-ht-h.xbm create mode 100644 test/jdk/java/awt/image/XBMDecoder/valid_WH5-w-h.xbm create mode 100644 test/jdk/java/awt/image/XBMDecoder/valid_WH6-h-w.xbm diff --git a/src/java.desktop/share/classes/sun/awt/image/XbmImageDecoder.java b/src/java.desktop/share/classes/sun/awt/image/XbmImageDecoder.java index bc025b87f3c..f1ccdcf07f8 100644 --- a/src/java.desktop/share/classes/sun/awt/image/XbmImageDecoder.java +++ b/src/java.desktop/share/classes/sun/awt/image/XbmImageDecoder.java @@ -110,20 +110,15 @@ public class XbmImageDecoder extends ImageDecoder { error("Error while parsing define statement"); } try { - if (!token[2].isBlank() && state == 0) { - if (token[1].endsWith("th")) { + if (state < 2) { + if (token[1].endsWith("h")) { W = Integer.parseInt(token[2]); - } else if (token[1].endsWith("t")) { + } else if (token[1].endsWith("ht")) { H = Integer.parseInt(token[2]); } - state = 1; // after first dimension is set - } else if (!token[2].isBlank() && state == 1) { - if (token[1].endsWith("th")) { - W = Integer.parseInt(token[2]); - } else if (token[1].endsWith("t")) { - H = Integer.parseInt(token[2]); - } - state = 2; // after second dimension is set + // After the 1st dimension is set, state becomes 1; + // after the 2nd dimension is set, state becomes 2 + ++state; } } catch (NumberFormatException nfe) { // parseInt() can throw NFE diff --git a/test/jdk/java/awt/image/XBMDecoder/XBMDecoderTest.java b/test/jdk/java/awt/image/XBMDecoder/XBMDecoderTest.java index 9694043d1bb..9d2a23bd29b 100644 --- a/test/jdk/java/awt/image/XBMDecoder/XBMDecoderTest.java +++ b/test/jdk/java/awt/image/XBMDecoder/XBMDecoderTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2025, 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 @@ -23,7 +23,7 @@ /* * @test - * @bug 8361748 + * @bug 8361748 8377924 * @summary Tests XBM image size limits and if XBMImageDecoder.produceImage() * throws appropriate error when parsing invalid XBM image data. * @run main XBMDecoderTest @@ -63,7 +63,9 @@ public class XBMDecoderTest { boolean isErrEmpty = errContent.toString().isEmpty(); if (!isErrEmpty) { - System.out.println("Expected ImageFormatException occurred."); + if (!validCase) { + System.out.println("Expected ImageFormatException occurred."); + } System.out.print(errContent); } if (validCase && !isErrEmpty) { @@ -91,9 +93,7 @@ public class XBMDecoderTest { g.drawImage(img, 0, 0, null); g.dispose(); int[] pixels = bi.getRGB(0, 0, w, h, null, 0, w); - if (Arrays.stream(pixels).allMatch(i -> i == 0)) { - return false; - } - return true; + return !Arrays.stream(pixels) + .allMatch(i -> i == 0); } } diff --git a/test/jdk/java/awt/image/XBMDecoder/XBMDecoderWidthHeight.java b/test/jdk/java/awt/image/XBMDecoder/XBMDecoderWidthHeight.java new file mode 100644 index 00000000000..7a9328b1554 --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/XBMDecoderWidthHeight.java @@ -0,0 +1,115 @@ +/* + * Copyright (c) 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. + */ + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.PrintStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.List; +import java.util.Objects; +import java.util.regex.Pattern; +import java.util.stream.Stream; + +import javax.swing.ImageIcon; + +/* + * @test + * @bug 8377924 + * @summary Verifies XBM decoder parses width and height in backward-compatible + * way: `-h` corresponds to width; `-ht` corresponds to height + * @run main XBMDecoderWidthHeight + */ +public final class XBMDecoderWidthHeight { + private static final PrintStream originalErr = System.err; + + private static final String dir = System.getProperty("test.src", "."); + + private static final int WIDTH = 8; + private static final int HEIGHT = 1; + + private static final Pattern glob = + Pattern.compile("valid_WH.?-.*\\.xbm"); + + private static boolean matchesGlob(final Path file) { + return glob.matcher(file.getFileName() + .toString()) + .matches(); + } + + public static void main(String[] args) throws Exception { + final List errors; + + try (Stream files = Files.list(Paths.get(dir))) { + errors = files.filter(XBMDecoderWidthHeight::matchesGlob) + .map(XBMDecoderWidthHeight::testFileWrapper) + .filter(Objects::nonNull) + .toList(); + } + + if (!errors.isEmpty()) { + errors.stream() + .map(Throwable::getMessage) + .forEach(System.err::println); + throw new RuntimeException("Errors found: " + errors.size() + ". " + + errors.get(0).getMessage()); + } + } + + private static Throwable testFileWrapper(final Path file) { + try { + testFile(file); + } catch (Throwable t) { + return t; + } + return null; + } + + private static void testFile(final Path file) throws IOException, Error { + try (ByteArrayOutputStream errContent = new ByteArrayOutputStream()) { + System.setErr(new PrintStream(errContent)); + + ImageIcon icon = new ImageIcon(Files.readAllBytes(file)); + + if (errContent.size() != 0) { + throw new Error(file.getFileName() + " " + + errContent.toString().split("\\n")[0]); + } + + if (icon.getIconWidth() != WIDTH || icon.getIconHeight() != HEIGHT) { + throw new Error(file.getFileName() + + " Unexpected size: " + + formatSize(icon.getIconWidth(), + icon.getIconHeight()) + + " vs " + formatSize(WIDTH, HEIGHT)); + } + } finally { + System.setErr(originalErr); + } + } + + private static String formatSize(int width, int height) { + return width + " x " + height; + } +} diff --git a/test/jdk/java/awt/image/XBMDecoder/invalid_WH1-no-height.xbm b/test/jdk/java/awt/image/XBMDecoder/invalid_WH1-no-height.xbm new file mode 100644 index 00000000000..09fcfe0d576 --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/invalid_WH1-no-height.xbm @@ -0,0 +1,3 @@ +#define width 8 +#define width 1 +k[] = {0xAB}; diff --git a/test/jdk/java/awt/image/XBMDecoder/invalid_WH2-no-width.xbm b/test/jdk/java/awt/image/XBMDecoder/invalid_WH2-no-width.xbm new file mode 100644 index 00000000000..fa2e6d9546b --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/invalid_WH2-no-width.xbm @@ -0,0 +1,3 @@ +#define height 8 +#define height 1 +k[] = {0xAB}; diff --git a/test/jdk/java/awt/image/XBMDecoder/invalid_WH3-no-width-height.xbm b/test/jdk/java/awt/image/XBMDecoder/invalid_WH3-no-width-height.xbm new file mode 100644 index 00000000000..cf22314b055 --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/invalid_WH3-no-width-height.xbm @@ -0,0 +1,3 @@ +#define test1 8 +#define test2 1 +k[] = {0xAB}; diff --git a/test/jdk/java/awt/image/XBMDecoder/valid_WH1-th-ht.xbm b/test/jdk/java/awt/image/XBMDecoder/valid_WH1-th-ht.xbm new file mode 100644 index 00000000000..c287afe79b3 --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/valid_WH1-th-ht.xbm @@ -0,0 +1,3 @@ +#define th 8 +#define ht 1 +k[] = {0xAB}; diff --git a/test/jdk/java/awt/image/XBMDecoder/valid_WH2-h-ht.xbm b/test/jdk/java/awt/image/XBMDecoder/valid_WH2-h-ht.xbm new file mode 100644 index 00000000000..58605910d70 --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/valid_WH2-h-ht.xbm @@ -0,0 +1,3 @@ +#define h 8 +#define ht 1 +k[] = {0xAB}; diff --git a/test/jdk/java/awt/image/XBMDecoder/valid_WH3-ht-th.xbm b/test/jdk/java/awt/image/XBMDecoder/valid_WH3-ht-th.xbm new file mode 100644 index 00000000000..7d8bc74d1ec --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/valid_WH3-ht-th.xbm @@ -0,0 +1,3 @@ +#define ht 1 +#define th 8 +k[] = {0xAB}; diff --git a/test/jdk/java/awt/image/XBMDecoder/valid_WH4-ht-h.xbm b/test/jdk/java/awt/image/XBMDecoder/valid_WH4-ht-h.xbm new file mode 100644 index 00000000000..94afe2c39b9 --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/valid_WH4-ht-h.xbm @@ -0,0 +1,3 @@ +#define ht 1 +#define h 8 +k[] = {0xAB}; diff --git a/test/jdk/java/awt/image/XBMDecoder/valid_WH5-w-h.xbm b/test/jdk/java/awt/image/XBMDecoder/valid_WH5-w-h.xbm new file mode 100644 index 00000000000..cf423b737a1 --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/valid_WH5-w-h.xbm @@ -0,0 +1,3 @@ +#define width 8 +#define height 1 +k[] = {0xAB}; diff --git a/test/jdk/java/awt/image/XBMDecoder/valid_WH6-h-w.xbm b/test/jdk/java/awt/image/XBMDecoder/valid_WH6-h-w.xbm new file mode 100644 index 00000000000..d9641b9009f --- /dev/null +++ b/test/jdk/java/awt/image/XBMDecoder/valid_WH6-h-w.xbm @@ -0,0 +1,3 @@ +#define height 1 +#define width 8 +k[] = {0xAB}; From c0c1775a2b002e82347bb0a0b1167cfe45e7006e Mon Sep 17 00:00:00 2001 From: Mikael Vidstedt Date: Tue, 24 Feb 2026 00:33:52 +0000 Subject: [PATCH 58/63] 8377905: gcc.md included with every build Reviewed-by: erikj, jsjolen, prr, dholmes --- make/modules/java.base/Copy.gmk | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/make/modules/java.base/Copy.gmk b/make/modules/java.base/Copy.gmk index b8c1f2c05fa..43b9db651e0 100644 --- a/make/modules/java.base/Copy.gmk +++ b/make/modules/java.base/Copy.gmk @@ -1,5 +1,5 @@ # -# Copyright (c) 2014, 2025, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2014, 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 @@ -172,6 +172,10 @@ ifeq ($(USE_EXTERNAL_LIBZ), true) LEGAL_EXCLUDES += zlib.md endif +ifneq ($(TOOLCHAIN_TYPE), gcc) + LEGAL_EXCLUDES += gcc.md +endif + $(eval $(call SetupCopyLegalFiles, COPY_LEGAL, \ EXCLUDES := $(LEGAL_EXCLUDES), \ )) From 171d788bce176ef147840fadd5551579ac7bb9b6 Mon Sep 17 00:00:00 2001 From: Jaikiran Pai Date: Tue, 24 Feb 2026 02:21:33 +0000 Subject: [PATCH 59/63] 8378378: Remove references to obsolete jdk.net.usePlainDatagramSocketImpl property from tests Reviewed-by: alanb, vyazici, dfuchs --- .../jndi/dns/ConfigTests/PortUnreachable.java | 4 +- .../UnreferencedDatagramSockets.java | 53 +++++-------------- .../UnreferencedMulticastSockets.java | 51 +++++------------- 3 files changed, 29 insertions(+), 79 deletions(-) diff --git a/test/jdk/com/sun/jndi/dns/ConfigTests/PortUnreachable.java b/test/jdk/com/sun/jndi/dns/ConfigTests/PortUnreachable.java index 0a92e52c270..eb917c2f25a 100644 --- a/test/jdk/com/sun/jndi/dns/ConfigTests/PortUnreachable.java +++ b/test/jdk/com/sun/jndi/dns/ConfigTests/PortUnreachable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 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 @@ -36,7 +36,7 @@ import javax.naming.directory.InitialDirContext; * @requires os.family != "aix" * @library ../lib/ * @modules java.base/sun.security.util - * @run main/othervm -Djdk.net.usePlainDatagramSocketImpl=false PortUnreachable + * @run main PortUnreachable */ public class PortUnreachable extends DNSTestBase { diff --git a/test/jdk/java/net/DatagramSocket/UnreferencedDatagramSockets.java b/test/jdk/java/net/DatagramSocket/UnreferencedDatagramSockets.java index dff8b38d3c1..e5bf0b3822d 100644 --- a/test/jdk/java/net/DatagramSocket/UnreferencedDatagramSockets.java +++ b/test/jdk/java/net/DatagramSocket/UnreferencedDatagramSockets.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 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 @@ -21,11 +21,11 @@ * questions. */ -/** +/* * @test * @library /test/lib * @modules java.management java.base/java.io:+open java.base/java.net:+open - * java.base/sun.net java.base/sun.nio.ch:+open + * java.base/sun.nio.ch:+open * @run main/othervm/timeout=480 UnreferencedDatagramSockets * @run main/othervm/timeout=480 -Djava.net.preferIPv4Stack=true UnreferencedDatagramSockets * @summary Check that unreferenced datagram sockets are closed @@ -41,15 +41,12 @@ import java.io.IOException; import java.lang.reflect.Method; import java.net.DatagramPacket; import java.net.DatagramSocket; -import java.net.DatagramSocketImpl; import java.net.InetAddress; import java.net.UnknownHostException; import java.nio.channels.DatagramChannel; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.security.AccessController; -import java.security.PrivilegedAction; import java.util.ArrayDeque; import java.util.List; import java.util.Optional; @@ -59,7 +56,6 @@ import java.util.concurrent.CountDownLatch; import com.sun.management.UnixOperatingSystemMXBean; import jdk.test.lib.net.IPSupport; -import sun.net.NetProperties; public class UnreferencedDatagramSockets { @@ -191,48 +187,27 @@ public class UnreferencedDatagramSockets { : -1L; } - private static boolean usePlainDatagramSocketImpl() { - PrivilegedAction pa = () -> NetProperties.get("jdk.net.usePlainDatagramSocketImpl"); - String s = AccessController.doPrivileged(pa); - return (s != null) && (s.isEmpty() || s.equalsIgnoreCase("true")); - } - // Reflect to find references in the datagram implementation that will be gc'd private static void extractRefs(DatagramSocket s, String name) { try { Field datagramSocketField = DatagramSocket.class.getDeclaredField("delegate"); datagramSocketField.setAccessible(true); - if (!usePlainDatagramSocketImpl()) { - // DatagramSocket using DatagramSocketAdaptor - Object DatagramSocket = datagramSocketField.get(s); - assert DatagramSocket.getClass() == Class.forName("sun.nio.ch.DatagramSocketAdaptor"); + // DatagramSocket using DatagramSocketAdaptor + Object DatagramSocket = datagramSocketField.get(s); + assert DatagramSocket.getClass() == Class.forName("sun.nio.ch.DatagramSocketAdaptor"); - Method m = DatagramSocket.class.getDeclaredMethod("getChannel"); - m.setAccessible(true); - DatagramChannel datagramChannel = (DatagramChannel) m.invoke(DatagramSocket); + Method m = DatagramSocket.class.getDeclaredMethod("getChannel"); + m.setAccessible(true); + DatagramChannel datagramChannel = (DatagramChannel) m.invoke(DatagramSocket); - assert datagramChannel.getClass() == Class.forName("sun.nio.ch.DatagramChannelImpl"); + assert datagramChannel.getClass() == Class.forName("sun.nio.ch.DatagramChannelImpl"); - Field fileDescriptorField = datagramChannel.getClass().getDeclaredField("fd"); - fileDescriptorField.setAccessible(true); - FileDescriptor fileDescriptor = (FileDescriptor) fileDescriptorField.get(datagramChannel); - extractRefs(fileDescriptor, name); + Field fileDescriptorField = datagramChannel.getClass().getDeclaredField("fd"); + fileDescriptorField.setAccessible(true); + FileDescriptor fileDescriptor = (FileDescriptor) fileDescriptorField.get(datagramChannel); + extractRefs(fileDescriptor, name); - } else { - // DatagramSocket using PlainDatagramSocketImpl - Object DatagramSocket = datagramSocketField.get(s); - assert DatagramSocket.getClass() == Class.forName("java.net.NetMulticastSocket"); - - Method m = DatagramSocket.getClass().getDeclaredMethod("getImpl"); - m.setAccessible(true); - DatagramSocketImpl datagramSocketImpl = (DatagramSocketImpl) m.invoke(DatagramSocket); - - Field fileDescriptorField = DatagramSocketImpl.class.getDeclaredField("fd"); - fileDescriptorField.setAccessible(true); - FileDescriptor fileDescriptor = (FileDescriptor) fileDescriptorField.get(datagramSocketImpl); - extractRefs(fileDescriptor, name); - } } catch (Exception ex) { ex.printStackTrace(); throw new AssertionError("missing field", ex); diff --git a/test/jdk/java/net/MulticastSocket/UnreferencedMulticastSockets.java b/test/jdk/java/net/MulticastSocket/UnreferencedMulticastSockets.java index 2a87207c961..0f4faa4065b 100644 --- a/test/jdk/java/net/MulticastSocket/UnreferencedMulticastSockets.java +++ b/test/jdk/java/net/MulticastSocket/UnreferencedMulticastSockets.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 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 @@ -21,11 +21,11 @@ * questions. */ -/** +/* * @test * @library /test/lib * @modules java.management java.base/java.io:+open java.base/java.net:+open - * java.base/sun.net java.base/sun.nio.ch:+open + * java.base/sun.nio.ch:+open * @run main/othervm/timeout=480 -Djava.net.preferIPv4Stack=true UnreferencedMulticastSockets * @run main/othervm/timeout=480 UnreferencedMulticastSockets * @summary Check that unreferenced multicast sockets are closed @@ -41,7 +41,6 @@ import java.io.IOException; import java.lang.reflect.Method; import java.net.DatagramPacket; import java.net.DatagramSocket; -import java.net.DatagramSocketImpl; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.MulticastSocket; @@ -50,8 +49,6 @@ import java.nio.channels.DatagramChannel; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.security.AccessController; -import java.security.PrivilegedAction; import java.util.ArrayDeque; import java.util.List; import java.util.Optional; @@ -61,7 +58,6 @@ import java.util.concurrent.TimeUnit; import jdk.test.lib.net.IPSupport; import com.sun.management.UnixOperatingSystemMXBean; -import sun.net.NetProperties; public class UnreferencedMulticastSockets { @@ -229,12 +225,6 @@ public class UnreferencedMulticastSockets { : -1L; } - private static boolean usePlainDatagramSocketImpl() { - PrivilegedAction pa = () -> NetProperties.get("jdk.net.usePlainDatagramSocketImpl"); - String s = AccessController.doPrivileged(pa); - return (s != null) && (s.isEmpty() || s.equalsIgnoreCase("true")); - } - // Reflect to find references in the datagram implementation that will be gc'd private static void extractRefs(DatagramSocket s, String name) { @@ -242,35 +232,20 @@ public class UnreferencedMulticastSockets { Field datagramSocketField = DatagramSocket.class.getDeclaredField("delegate"); datagramSocketField.setAccessible(true); - if (!usePlainDatagramSocketImpl()) { - // MulticastSocket using DatagramSocketAdaptor - Object MulticastSocket = datagramSocketField.get(s); + // MulticastSocket using DatagramSocketAdaptor + Object MulticastSocket = datagramSocketField.get(s); - Method m = DatagramSocket.class.getDeclaredMethod("getChannel"); - m.setAccessible(true); - DatagramChannel datagramChannel = (DatagramChannel) m.invoke(MulticastSocket); + Method m = DatagramSocket.class.getDeclaredMethod("getChannel"); + m.setAccessible(true); + DatagramChannel datagramChannel = (DatagramChannel) m.invoke(MulticastSocket); - assert datagramChannel.getClass() == Class.forName("sun.nio.ch.DatagramChannelImpl"); + assert datagramChannel.getClass() == Class.forName("sun.nio.ch.DatagramChannelImpl"); - Field fileDescriptorField = datagramChannel.getClass().getDeclaredField("fd"); - fileDescriptorField.setAccessible(true); - FileDescriptor fileDescriptor = (FileDescriptor) fileDescriptorField.get(datagramChannel); - extractRefs(fileDescriptor, name); + Field fileDescriptorField = datagramChannel.getClass().getDeclaredField("fd"); + fileDescriptorField.setAccessible(true); + FileDescriptor fileDescriptor = (FileDescriptor) fileDescriptorField.get(datagramChannel); + extractRefs(fileDescriptor, name); - } else { - // MulticastSocket using PlainDatagramSocketImpl - Object MulticastSocket = datagramSocketField.get(s); - assert MulticastSocket.getClass() == Class.forName("java.net.NetMulticastSocket"); - - Method m = MulticastSocket.getClass().getDeclaredMethod("getImpl"); - m.setAccessible(true); - DatagramSocketImpl datagramSocketImpl = (DatagramSocketImpl) m.invoke(MulticastSocket); - - Field fileDescriptorField = DatagramSocketImpl.class.getDeclaredField("fd"); - fileDescriptorField.setAccessible(true); - FileDescriptor fileDescriptor = (FileDescriptor) fileDescriptorField.get(datagramSocketImpl); - extractRefs(fileDescriptor, name); - } } catch (Exception ex) { ex.printStackTrace(); throw new AssertionError("missing field", ex); From f25d429c8d6d099666aefd698ed14628cce5b1cf Mon Sep 17 00:00:00 2001 From: Yasumasa Suenaga Date: Tue, 24 Feb 2026 03:01:19 +0000 Subject: [PATCH 60/63] 8306591: SA and hotspot generate different hprof records for GC roots Reviewed-by: cjplummer, dholmes --- src/hotspot/share/runtime/vmStructs.cpp | 2 ++ .../hotspot/classfile/ClassLoaderData.java | 8 +++++++- .../utilities/AbstractHeapGraphWriter.java | 8 +++++++- .../hotspot/utilities/HeapHprofBinWriter.java | 20 +++++++++++++++++++ .../serviceability/sa/ClhsdbDumpheap.java | 13 ++++++++++++ 5 files changed, 49 insertions(+), 2 deletions(-) diff --git a/src/hotspot/share/runtime/vmStructs.cpp b/src/hotspot/share/runtime/vmStructs.cpp index 9ac8f396f9a..a54fbc7e8ab 100644 --- a/src/hotspot/share/runtime/vmStructs.cpp +++ b/src/hotspot/share/runtime/vmStructs.cpp @@ -408,6 +408,8 @@ volatile_nonstatic_field(ClassLoaderData, _klasses, Klass*) \ nonstatic_field(ClassLoaderData, _has_class_mirror_holder, bool) \ \ + static_field(ClassLoaderData, _the_null_class_loader_data, ClassLoaderData*) \ + \ volatile_static_field(ClassLoaderDataGraph, _head, ClassLoaderData*) \ \ /**********/ \ diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/classfile/ClassLoaderData.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/classfile/ClassLoaderData.java index 44b407edaca..7ce46799495 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/classfile/ClassLoaderData.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/classfile/ClassLoaderData.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 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 @@ -44,12 +44,14 @@ public class ClassLoaderData extends VMObject { private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { Type type = db.lookupType("ClassLoaderData"); classLoaderFieldOffset = type.getAddressField("_class_loader").getOffset(); + theNullClassLoaderDataField = type.getAddressField("_the_null_class_loader_data"); nextField = type.getAddressField("_next"); klassesField = new MetadataField(type.getAddressField("_klasses"), 0); hasClassMirrorHolderField = new CIntField(type.getCIntegerField("_has_class_mirror_holder"), 0); } private static long classLoaderFieldOffset; + private static AddressField theNullClassLoaderDataField; private static AddressField nextField; private static MetadataField klassesField; private static CIntField hasClassMirrorHolderField; @@ -75,6 +77,10 @@ public class ClassLoaderData extends VMObject { return hasClassMirrorHolderField.getValue(this) != 0; } + public static ClassLoaderData theNullClassLoaderData() { + return instantiateWrapperFor(theNullClassLoaderDataField.getValue()); + } + public ClassLoaderData next() { return instantiateWrapperFor(nextField.getValue(getAddress())); } diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java index 51f40fad12b..80ea272ea2c 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2004, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2004, 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 @@ -121,6 +121,9 @@ public abstract class AbstractHeapGraphWriter implements HeapGraphWriter { // write JNI global handles writeGlobalJNIHandles(); + // write classes in null class loader data + writeStickyClasses(); + } catch (RuntimeException re) { handleRuntimeException(re); } @@ -168,6 +171,9 @@ public abstract class AbstractHeapGraphWriter implements HeapGraphWriter { } } + protected void writeStickyClasses() throws IOException { + } + protected void writeGlobalJNIHandle(Address handleAddr) throws IOException { } diff --git a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/HeapHprofBinWriter.java b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/HeapHprofBinWriter.java index ce048bf2d86..2745e1f0783 100644 --- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/HeapHprofBinWriter.java +++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/HeapHprofBinWriter.java @@ -967,6 +967,22 @@ public class HeapHprofBinWriter extends AbstractHeapGraphWriter { } } + @Override + protected void writeStickyClasses() throws IOException { + ClassLoaderData.theNullClassLoaderData().classesDo(k -> { + if (k instanceof InstanceKlass) { + try { + int size = 1 + (int)VM.getVM().getAddressSize(); + writeHeapRecordPrologue(size); + out.writeByte((byte)HPROF_GC_ROOT_STICKY_CLASS); + writeClassID(k); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } + }); + } + protected void writeObjectArray(ObjArray array) throws IOException { int headerSize = getArrayHeaderSize(true); final int length = calculateArrayMaxLength(array.getLength(), @@ -1304,6 +1320,10 @@ public class HeapHprofBinWriter extends AbstractHeapGraphWriter { writeObjectID(address); } + private void writeClassID(Klass k) throws IOException { + writeObjectID(k.getJavaMirror()); + } + private void writeSymbolID(Symbol sym) throws IOException { assert names.contains(sym); long address = (sym != null) ? getAddressValue(sym.getAddress()) : getAddressValue(null); diff --git a/test/hotspot/jtreg/serviceability/sa/ClhsdbDumpheap.java b/test/hotspot/jtreg/serviceability/sa/ClhsdbDumpheap.java index 722c641f5b9..d9f856ab0a3 100644 --- a/test/hotspot/jtreg/serviceability/sa/ClhsdbDumpheap.java +++ b/test/hotspot/jtreg/serviceability/sa/ClhsdbDumpheap.java @@ -81,10 +81,23 @@ public class ClhsdbDumpheap { fail("HPROF_GC_ROOT_JAVA_FRAME not found"); } + private static void verifyStickyClasses(String file) throws IOException { + try (var snapshot = HprofReader.readFile(file, false, 0)) { + for (var root = snapshot.getRoots(); root.hasMoreElements();) { + if (root.nextElement().getType() == Root.SYSTEM_CLASS) { + // expected + return; + } + } + } + fail("HPROF_GC_ROOT_STICKY_CLASS not found"); + } + private static void verifyDumpFile(File dump) throws Exception { assertTrue(dump.exists() && dump.isFile(), "Could not create dump file " + dump.getAbsolutePath()); printStackTraces(dump.getAbsolutePath()); verifyLocalRefs(dump.getAbsolutePath()); + verifyStickyClasses(dump.getAbsolutePath()); } private static class SubTest { From cb3a57ccede6709205e75c7eb2ff9998cb7a82d0 Mon Sep 17 00:00:00 2001 From: Amit Kumar Date: Tue, 24 Feb 2026 04:27:44 +0000 Subject: [PATCH 61/63] 8377863: [s390x] Increase inlining thresholds to the same as other platforms Reviewed-by: aph, lucy --- src/hotspot/cpu/s390/c2_globals_s390.hpp | 4 ++-- src/hotspot/share/compiler/compilerDefinitions.cpp | 6 ++---- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/src/hotspot/cpu/s390/c2_globals_s390.hpp b/src/hotspot/cpu/s390/c2_globals_s390.hpp index 431a36cda07..125b317588d 100644 --- a/src/hotspot/cpu/s390/c2_globals_s390.hpp +++ b/src/hotspot/cpu/s390/c2_globals_s390.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2016, 2018 SAP SE. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * @@ -44,7 +44,7 @@ define_pd_global(intx, CompileThreshold, 10000); define_pd_global(intx, OnStackReplacePercentage, 140); define_pd_global(intx, ConditionalMoveLimit, 4); -define_pd_global(intx, FreqInlineSize, 175); +define_pd_global(intx, FreqInlineSize, 325); define_pd_global(intx, InteriorEntryAlignment, 4); define_pd_global(size_t, NewSizeThreadIncrease, ScaleForWordSize(4*K)); define_pd_global(intx, RegisterCostAreaRatio, 12000); diff --git a/src/hotspot/share/compiler/compilerDefinitions.cpp b/src/hotspot/share/compiler/compilerDefinitions.cpp index 75d84bedcc6..9bd6e893bcd 100644 --- a/src/hotspot/share/compiler/compilerDefinitions.cpp +++ b/src/hotspot/share/compiler/compilerDefinitions.cpp @@ -404,14 +404,12 @@ void CompilerConfig::set_compilation_policy_flags() { #endif if (CompilerConfig::is_tiered() && CompilerConfig::is_c2_enabled()) { -#ifdef COMPILER2 - // Some inlining tuning -#if defined(X86) || defined(AARCH64) || defined(RISCV64) || defined(PPC64) +#if defined(COMPILER2) && defined(_LP64) + // LP64 specific inlining tuning for C2 if (FLAG_IS_DEFAULT(InlineSmallCode)) { FLAG_SET_DEFAULT(InlineSmallCode, 2500); } #endif -#endif // COMPILER2 } } From 75f8f08f3b6b4e3b211553ed78862ab03ca5d216 Mon Sep 17 00:00:00 2001 From: David Beaumont Date: Tue, 24 Feb 2026 05:19:17 +0000 Subject: [PATCH 62/63] 8378118: Test tools/jimage/JImageBadFileTest.java failed on Windows Reviewed-by: rriggs, alanb --- test/jdk/tools/jimage/JImageBadFileTest.java | 67 +++++++------------- 1 file changed, 23 insertions(+), 44 deletions(-) diff --git a/test/jdk/tools/jimage/JImageBadFileTest.java b/test/jdk/tools/jimage/JImageBadFileTest.java index 26795f68d16..d25c994b265 100644 --- a/test/jdk/tools/jimage/JImageBadFileTest.java +++ b/test/jdk/tools/jimage/JImageBadFileTest.java @@ -31,6 +31,8 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.function.Consumer; +import jdk.test.lib.Utils; + import static java.nio.file.StandardOpenOption.READ; import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING; import static java.util.regex.Pattern.quote; @@ -77,7 +79,7 @@ public class JImageBadFileTest extends JImageCliTest { private Path writeModifiedJimage(String label, int maxLen, Consumer headerFn) throws IOException { int remaining = maxLen >= 0 ? maxLen : Integer.MAX_VALUE; - Path dst = Files.createTempFile(Path.of("."), "modules-" + label, ""); + Path dst = Utils.createTempFile("modules-" + label, ""); try (InputStream rest = Files.newInputStream(Path.of(getImagePath()), READ); OutputStream out = Files.newOutputStream(dst, TRUNCATE_EXISTING)) { ByteBuffer bytes = ByteBuffer.wrap(rest.readNBytes(HEADER_SIZE_BYTES)); @@ -95,75 +97,52 @@ public class JImageBadFileTest extends JImageCliTest { } while (rest.available() > 0 && remaining > 0); } return dst.toAbsolutePath(); - } catch (IOException e) { - Files.deleteIfExists(dst); - throw e; } } public void testBadMagicNumber() throws IOException { // Flip some bits in the magic number. Path tempJimage = writeModifiedJimage("bad_magic", -1, b -> b.put(0, b.get(1) ^ 0x1010)); - try { - JImageResult result = jimage("info", tempJimage.toString()); - result.assertShowsError(); - assertMatches(quote("Unable to open"), result.output); - assertMatches(quote("is not an image file"), result.output); - } finally { - Files.delete(tempJimage); - } + JImageResult result = jimage("info", tempJimage.toString()); + result.assertShowsError(); + assertMatches(quote("Unable to open"), result.output); + assertMatches(quote("is not an image file"), result.output); } public void testMismatchedVersion() throws IOException { // Add one to minor version (lowest bits). Path tempJimage = writeModifiedJimage("bad_version", -1, b -> b.put(1, b.get(1) + 1)); - try { - JImageResult result = jimage("info", tempJimage.toString()); - result.assertShowsError(); - assertMatches(quote("Unable to open"), result.output); - assertMatches(quote("/bin/jimage"), result.output); - assertMatches(quote("not the correct version"), result.output); - assertMatches("Major: \\d+", result.output); - assertMatches("Minor: \\d+", result.output); - } finally { - Files.delete(tempJimage); - } + JImageResult result = jimage("info", tempJimage.toString()); + result.assertShowsError(); + assertMatches(quote("Unable to open"), result.output); + assertMatches(quote("/bin/jimage"), result.output); + assertMatches(quote("not the correct version"), result.output); + assertMatches("Major: \\d+", result.output); + assertMatches("Minor: \\d+", result.output); } public void testTruncatedHeader() throws IOException { // Copy less than the header. Path tempJimage = writeModifiedJimage("truncated_header", HEADER_SIZE_BYTES - 4, b -> {}); - try { - JImageResult result = jimage("info", tempJimage.toString()); - result.assertShowsError(); - assertMatches(quote("Unable to open"), result.output); - assertMatches(quote("is not an image file"), result.output); - } finally { - Files.delete(tempJimage); - } + JImageResult result = jimage("info", tempJimage.toString()); + result.assertShowsError(); + assertMatches(quote("Unable to open"), result.output); + assertMatches(quote("is not an image file"), result.output); } public void testTruncatedData() throws IOException { // Copy more than the header, but definitely less than the whole file. Path tempJimage = writeModifiedJimage("truncated_data", HEADER_SIZE_BYTES + 1024, b -> {}); - try { - JImageResult result = jimage("info", tempJimage.toString()); - result.assertShowsError(); - assertMatches(quote("Unable to open"), result.output); - assertMatches("image file \".*\" is corrupted", result.output); - } finally { - Files.delete(tempJimage); - } + JImageResult result = jimage("info", tempJimage.toString()); + result.assertShowsError(); + assertMatches(quote("Unable to open"), result.output); + assertMatches("image file \".*\" is corrupted", result.output); } public void testGoodFileCopy() throws IOException { // Self test that the file copying isn't itself corrupting anything. Path tempJimage = writeModifiedJimage("good_file", -1, b -> {}); - try { - jimage("info", tempJimage.toString()).assertSuccess(); - } finally { - Files.delete(tempJimage); - } + jimage("info", tempJimage.toString()).assertSuccess(); } public static void main(String[] args) throws Throwable { From f0da04a40a010ed7e561735f0b1fdbd3f02ca42b Mon Sep 17 00:00:00 2001 From: Serguei Spitsyn Date: Tue, 24 Feb 2026 06:54:10 +0000 Subject: [PATCH 63/63] 8375457: Test serviceability/jvmti/vthread/SelfSuspendDisablerTest/SelfSuspendDisablerTest.java#default timed out Reviewed-by: pchilanomate, amenkov --- src/hotspot/share/prims/jvmtiEnv.cpp | 10 +++++++++- .../SelfSuspendDisablerTest.java | 2 +- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/hotspot/share/prims/jvmtiEnv.cpp b/src/hotspot/share/prims/jvmtiEnv.cpp index e0863c07f4f..9c5abdf790b 100644 --- a/src/hotspot/share/prims/jvmtiEnv.cpp +++ b/src/hotspot/share/prims/jvmtiEnv.cpp @@ -1077,11 +1077,19 @@ JvmtiEnv::SuspendAllVirtualThreads(jint except_count, const jthread* except_list JvmtiVTSuspender::register_vthread_resume(thread_oop); } } + // Restore resumed state for current thread if it is virtual. + // It must be suspended in the suspend_thread call out of disabler context. + oop cur_oop = self_tobj(); + if (cur_oop != nullptr) { + assert(JvmtiVTSuspender::is_vthread_suspended(cur_oop), "sanity check"); + JvmtiVTSuspender::register_vthread_resume(cur_oop); + } } // Self suspend after all other suspends if necessary. // Do not use MountUnmountDisabler in context of self suspend to avoid deadlocks. if (self_tobj() != nullptr) { - suspend_thread(self_tobj(), current, /* single_suspend */ false); + // Register current vthread as suspended with the suspend_thread call. + suspend_thread(self_tobj(), current, /* single_suspend */ true); } return JVMTI_ERROR_NONE; } /* end SuspendAllVirtualThreads */ diff --git a/test/hotspot/jtreg/serviceability/jvmti/vthread/SelfSuspendDisablerTest/SelfSuspendDisablerTest.java b/test/hotspot/jtreg/serviceability/jvmti/vthread/SelfSuspendDisablerTest/SelfSuspendDisablerTest.java index b596a5c7ee2..359d4a0b5be 100644 --- a/test/hotspot/jtreg/serviceability/jvmti/vthread/SelfSuspendDisablerTest/SelfSuspendDisablerTest.java +++ b/test/hotspot/jtreg/serviceability/jvmti/vthread/SelfSuspendDisablerTest/SelfSuspendDisablerTest.java @@ -111,7 +111,7 @@ public class SelfSuspendDisablerTest { t3.start(); while(!isSuspended(t3)) { - sleep(100); + sleep(1); } testJvmtiThreadState(t3, SUSPENDED);