mirrors/JetBrainsRuntime
1
0
Fork 0
mirror of https://github.com/JetBrains/JetBrainsRuntime.git synced 2025-12-06 09:29:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

8345471: Clean up compiler/intrinsics/sha/cli tests

Browse Source 
Reviewed-by: phh
Backport-of: 3b9732edc6
This commit is contained in:
Goetz Lindenmaier
2025-06-23 09:23:41 +00:00
committed by Vitaly Provodin
parent 8e4d62410f
commit 96e170c177
10 changed files with 26 additions and 406 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
test/hotspot/jtreg/compiler/intrinsics/sha/cli/TestUseMD5IntrinsicsOptionOnUnsupportedCPU.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2020, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -37,19 +37,12 @@
package compiler.intrinsics.sha.cli;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForOtherCPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedAArch64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedX86CPU;
import compiler.intrinsics.sha.cli.testcases.UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedCPU;
public class TestUseMD5IntrinsicsOptionOnUnsupportedCPU {
public static void main(String args[]) throws Throwable {
new DigestOptionsBase(
new GenericTestCaseForUnsupportedX86CPU(
DigestOptionsBase.USE_MD5_INTRINSICS_OPTION, /* checkUseSHA = */ false),
new GenericTestCaseForUnsupportedAArch64CPU(
DigestOptionsBase.USE_MD5_INTRINSICS_OPTION, /* checkUseSHA = */ false),
new GenericTestCaseForOtherCPU(
new GenericTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_MD5_INTRINSICS_OPTION, /* checkUseSHA = */ false)).test();
}
}

15
test/hotspot/jtreg/compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnUnsupportedCPU.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2014, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -37,24 +37,15 @@
package compiler.intrinsics.sha.cli;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForOtherCPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedAArch64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedRISCV64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedX86CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedCPU;
import compiler.intrinsics.sha.cli.testcases.UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU;
public class TestUseSHA1IntrinsicsOptionOnUnsupportedCPU {
public static void main(String args[]) throws Throwable {
new DigestOptionsBase(
new GenericTestCaseForUnsupportedX86CPU(
DigestOptionsBase.USE_SHA1_INTRINSICS_OPTION),
new GenericTestCaseForUnsupportedAArch64CPU(
DigestOptionsBase.USE_SHA1_INTRINSICS_OPTION),
new GenericTestCaseForUnsupportedRISCV64CPU(
new GenericTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA1_INTRINSICS_OPTION),
new UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA1_INTRINSICS_OPTION),
new GenericTestCaseForOtherCPU(
DigestOptionsBase.USE_SHA1_INTRINSICS_OPTION)).test();
}
}

15
test/hotspot/jtreg/compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnUnsupportedCPU.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2014, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -37,24 +37,15 @@
package compiler.intrinsics.sha.cli;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForOtherCPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedAArch64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedRISCV64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedX86CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedCPU;
import compiler.intrinsics.sha.cli.testcases.UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU;
public class TestUseSHA256IntrinsicsOptionOnUnsupportedCPU {
public static void main(String args[]) throws Throwable {
new DigestOptionsBase(
new GenericTestCaseForUnsupportedX86CPU(
DigestOptionsBase.USE_SHA256_INTRINSICS_OPTION),
new GenericTestCaseForUnsupportedAArch64CPU(
DigestOptionsBase.USE_SHA256_INTRINSICS_OPTION),
new GenericTestCaseForUnsupportedRISCV64CPU(
new GenericTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA256_INTRINSICS_OPTION),
new UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA256_INTRINSICS_OPTION),
new GenericTestCaseForOtherCPU(
DigestOptionsBase.USE_SHA256_INTRINSICS_OPTION)).test();
}
}

10
test/hotspot/jtreg/compiler/intrinsics/sha/cli/TestUseSHA3IntrinsicsOptionOnUnsupportedCPU.java
View File

@@ -38,21 +38,15 @@
package compiler.intrinsics.sha.cli;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForOtherCPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedAArch64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedX86CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedCPU;
import compiler.intrinsics.sha.cli.testcases.UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU;
public class TestUseSHA3IntrinsicsOptionOnUnsupportedCPU {
public static void main(String args[]) throws Throwable {
new DigestOptionsBase(
new GenericTestCaseForUnsupportedX86CPU(
DigestOptionsBase.USE_SHA3_INTRINSICS_OPTION),
new GenericTestCaseForUnsupportedAArch64CPU(
new GenericTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA3_INTRINSICS_OPTION),
new UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA3_INTRINSICS_OPTION),
new GenericTestCaseForOtherCPU(
DigestOptionsBase.USE_SHA3_INTRINSICS_OPTION)).test();
}
}

15
test/hotspot/jtreg/compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnUnsupportedCPU.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2014, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -37,24 +37,15 @@
package compiler.intrinsics.sha.cli;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForOtherCPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedAArch64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedRISCV64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedX86CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedCPU;
import compiler.intrinsics.sha.cli.testcases.UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU;
public class TestUseSHA512IntrinsicsOptionOnUnsupportedCPU {
public static void main(String args[]) throws Throwable {
new DigestOptionsBase(
new GenericTestCaseForUnsupportedX86CPU(
DigestOptionsBase.USE_SHA512_INTRINSICS_OPTION),
new GenericTestCaseForUnsupportedAArch64CPU(
DigestOptionsBase.USE_SHA512_INTRINSICS_OPTION),
new GenericTestCaseForUnsupportedRISCV64CPU(
new GenericTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA512_INTRINSICS_OPTION),
new UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA512_INTRINSICS_OPTION),
new GenericTestCaseForOtherCPU(
DigestOptionsBase.USE_SHA512_INTRINSICS_OPTION)).test();
}
}

15
test/hotspot/jtreg/compiler/intrinsics/sha/cli/TestUseSHAOptionOnUnsupportedCPU.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2014, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -37,24 +37,15 @@
package compiler.intrinsics.sha.cli;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForOtherCPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedAArch64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedRISCV64CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedX86CPU;
import compiler.intrinsics.sha.cli.testcases.GenericTestCaseForUnsupportedCPU;
import compiler.intrinsics.sha.cli.testcases.UseSHASpecificTestCaseForUnsupportedCPU;
public class TestUseSHAOptionOnUnsupportedCPU {
public static void main(String args[]) throws Throwable {
new DigestOptionsBase(
new GenericTestCaseForUnsupportedX86CPU(
DigestOptionsBase.USE_SHA_OPTION),
new GenericTestCaseForUnsupportedAArch64CPU(
DigestOptionsBase.USE_SHA_OPTION),
new GenericTestCaseForUnsupportedRISCV64CPU(
new GenericTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA_OPTION),
new UseSHASpecificTestCaseForUnsupportedCPU(
DigestOptionsBase.USE_SHA_OPTION),
new GenericTestCaseForOtherCPU(
DigestOptionsBase.USE_SHA_OPTION)).test();
}
}

106
test/hotspot/jtreg/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForOtherCPU.java
View File

@@ -1,106 +0,0 @@
/*
* Copyright (c) 2014, 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 compiler.intrinsics.sha.cli.testcases;
import compiler.intrinsics.sha.cli.DigestOptionsBase;
import jdk.test.lib.process.ExitCode;
import jdk.test.lib.Platform;
import jdk.test.lib.cli.CommandLineOptionTest;
import jdk.test.lib.cli.predicate.NotPredicate;
import jdk.test.lib.cli.predicate.OrPredicate;
/**
* Generic test case for SHA-related options targeted to any CPU except
* AArch64, RISCV64, PPC, S390x, and X86.
*/
public class GenericTestCaseForOtherCPU extends
DigestOptionsBase.TestCase {
final private boolean checkUseSHA;
public GenericTestCaseForOtherCPU(String optionName) {
this(optionName, true);
}
public GenericTestCaseForOtherCPU(String optionName, boolean checkUseSHA) {
// Execute the test case on any CPU except AArch64, RISCV64, PPC, S390x, and X86.
super(optionName, new NotPredicate(
new OrPredicate(Platform::isAArch64,
new OrPredicate(Platform::isRISCV64,
new OrPredicate(Platform::isS390x,
new OrPredicate(Platform::isPPC,
new OrPredicate(Platform::isX64,
Platform::isX86)))))));
this.checkUseSHA = checkUseSHA;
}
@Override
protected void verifyWarnings() throws Throwable {
String shouldPassMessage = String.format("JVM should start with "
+ "option '%s' without any warnings", optionName);
// Verify that on non-x86, non-RISCV64 and non-AArch64 CPU usage of SHA-related
// options will not cause any warnings.
CommandLineOptionTest.verifySameJVMStartup(null,
new String[] { ".*" + optionName + ".*" }, shouldPassMessage,
shouldPassMessage, ExitCode.OK,
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, true));
CommandLineOptionTest.verifySameJVMStartup(null,
new String[] { ".*" + optionName + ".*" }, shouldPassMessage,
shouldPassMessage, ExitCode.OK,
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, false));
}
@Override
protected void verifyOptionValues() throws Throwable {
// Verify that option is disabled by default.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be disabled by default",
optionName),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS);
// Verify that option is disabled even if it was explicitly enabled
// using CLI options.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be off on unsupported "
+ "CPU even if set to true directly", optionName),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, true));
if (checkUseSHA) {
// Verify that option is disabled when it explicitly disabled
// using CLI options.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be off on unsupported CPU"
+ " even if '%s' flag set to JVM", optionName,
CommandLineOptionTest.prepareBooleanFlag(
DigestOptionsBase.USE_SHA_OPTION, true)),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, false));
}
}
}

18
test/hotspot/jtreg/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForUnsupportedAArch64CPU.java → test/hotspot/jtreg/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForUnsupportedCPU.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2014, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -31,22 +31,22 @@ import jdk.test.lib.cli.predicate.AndPredicate;
import jdk.test.lib.cli.predicate.NotPredicate;
/**
* Generic test case for SHA-related options targeted to AArch64 CPUs
* Generic test case for SHA-related options targeted to CPUs
* which don't support instruction required by the tested option.
*/
public class GenericTestCaseForUnsupportedAArch64CPU extends
public class GenericTestCaseForUnsupportedCPU extends
DigestOptionsBase.TestCase {
final private boolean checkUseSHA;
public GenericTestCaseForUnsupportedAArch64CPU(String optionName) {
public GenericTestCaseForUnsupportedCPU(String optionName) {
this(optionName, true);
}
public GenericTestCaseForUnsupportedAArch64CPU(String optionName, boolean checkUseSHA) {
super(optionName, new AndPredicate(Platform::isAArch64,
public GenericTestCaseForUnsupportedCPU(String optionName, boolean checkUseSHA) {
super(optionName,
new NotPredicate(DigestOptionsBase.getPredicateForOption(
optionName))));
optionName)));
this.checkUseSHA = checkUseSHA;
}
@@ -95,7 +95,7 @@ public class GenericTestCaseForUnsupportedAArch64CPU extends
// using CLI options.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be off on unsupported "
+ "AArch64CPU even if set to true directly", optionName),
+ "CPU even if set to true directly", optionName),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, true));
@@ -103,7 +103,7 @@ public class GenericTestCaseForUnsupportedAArch64CPU extends
// Verify that option is disabled when +UseSHA was passed to JVM.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be off on unsupported "
+ "AArch64CPU even if %s flag set to JVM",
+ "CPU even if %s flag set to JVM",
optionName, CommandLineOptionTest.prepareBooleanFlag(
DigestOptionsBase.USE_SHA_OPTION, true)),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,

115
test/hotspot/jtreg/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForUnsupportedRISCV64CPU.java
View File

@@ -1,115 +0,0 @@
/*
* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2020, 2021, Huawei Technologies Co., Ltd. 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.intrinsics.sha.cli.testcases;
import compiler.intrinsics.sha.cli.DigestOptionsBase;
import jdk.test.lib.process.ExitCode;
import jdk.test.lib.Platform;
import jdk.test.lib.cli.CommandLineOptionTest;
import jdk.test.lib.cli.predicate.AndPredicate;
import jdk.test.lib.cli.predicate.NotPredicate;
/**
* Generic test case for SHA-related options targeted to RISCV64 CPUs
* which don't support instruction required by the tested option.
*/
public class GenericTestCaseForUnsupportedRISCV64CPU extends
DigestOptionsBase.TestCase {
final private boolean checkUseSHA;
public GenericTestCaseForUnsupportedRISCV64CPU(String optionName) {
this(optionName, true);
}
public GenericTestCaseForUnsupportedRISCV64CPU(String optionName, boolean checkUseSHA) {
super(optionName, new AndPredicate(Platform::isRISCV64,
new NotPredicate(DigestOptionsBase.getPredicateForOption(
optionName))));
this.checkUseSHA = checkUseSHA;
}
@Override
protected void verifyWarnings() throws Throwable {
String shouldPassMessage = String.format("JVM startup should pass with"
+ "option '-XX:-%s' without any warnings", optionName);
//Verify that option could be disabled without any warnings.
CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
DigestOptionsBase.getWarningForUnsupportedCPU(optionName)
}, shouldPassMessage, shouldPassMessage, ExitCode.OK,
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, false));
if (checkUseSHA) {
shouldPassMessage = String.format("If JVM is started with '-XX:-"
+ "%s' '-XX:+%s', output should contain warning.",
DigestOptionsBase.USE_SHA_OPTION, optionName);
// Verify that when the tested option is enabled, then
// a warning will occur in VM output if UseSHA is disabled.
if (!optionName.equals(DigestOptionsBase.USE_SHA_OPTION)) {
CommandLineOptionTest.verifySameJVMStartup(
new String[] { DigestOptionsBase.getWarningForUnsupportedCPU(optionName) },
null,
shouldPassMessage,
shouldPassMessage,
ExitCode.OK,
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(DigestOptionsBase.USE_SHA_OPTION, false),
CommandLineOptionTest.prepareBooleanFlag(optionName, true));
}
}
}
@Override
protected void verifyOptionValues() throws Throwable {
// Verify that option is disabled by default.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be disabled by default",
optionName),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS);
if (checkUseSHA) {
// Verify that option is disabled even if it was explicitly enabled
// using CLI options.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be off on unsupported "
+ "RISCV64CPU even if set to true directly", optionName),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, true));
// Verify that option is disabled when +UseSHA was passed to JVM.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be off on unsupported "
+ "RISCV64CPU even if %s flag set to JVM",
optionName, CommandLineOptionTest.prepareBooleanFlag(
DigestOptionsBase.USE_SHA_OPTION, true)),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(
DigestOptionsBase.USE_SHA_OPTION, true));
}
}
}

110
test/hotspot/jtreg/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForUnsupportedX86CPU.java
View File

@@ -1,110 +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 compiler.intrinsics.sha.cli.testcases;
import compiler.intrinsics.sha.cli.DigestOptionsBase;
import jdk.test.lib.process.ExitCode;
import jdk.test.lib.Platform;
import jdk.test.lib.cli.CommandLineOptionTest;
import jdk.test.lib.cli.predicate.AndPredicate;
import jdk.test.lib.cli.predicate.NotPredicate;
import jdk.test.lib.cli.predicate.OrPredicate;
/**
* Generic test case for SHA-related options targeted to X86 CPUs that don't
* support SHA-related instructions.
*/
public class GenericTestCaseForUnsupportedX86CPU
extends DigestOptionsBase.TestCase {
final private boolean checkUseSHA;
public GenericTestCaseForUnsupportedX86CPU(String optionName) {
this(optionName, true);
}
public GenericTestCaseForUnsupportedX86CPU(String optionName, boolean checkUseSHA) {
super(optionName, new AndPredicate(new OrPredicate(Platform::isX64, Platform::isX86),
new NotPredicate(DigestOptionsBase.getPredicateForOption(
optionName))));
this.checkUseSHA = checkUseSHA;
}
@Override
protected void verifyWarnings() throws Throwable {
String shouldPassMessage = String.format("JVM should start with '-XX:-%s' "
+ "flag without any warnings", optionName);
// Verify that the tested option could be explicitly disabled without
// a warning.
CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
DigestOptionsBase.getWarningForUnsupportedCPU(optionName)
}, shouldPassMessage, shouldPassMessage, ExitCode.OK,
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, false));
// Verify that when the tested option is enabled, then
// a warning will occur in VM output if UseSHA is disabled.
if (checkUseSHA && !optionName.equals(DigestOptionsBase.USE_SHA_OPTION)) {
CommandLineOptionTest.verifySameJVMStartup(
new String[] { DigestOptionsBase.getWarningForUnsupportedCPU(optionName) },
null,
shouldPassMessage,
shouldPassMessage,
ExitCode.OK,
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(DigestOptionsBase.USE_SHA_OPTION, false),
CommandLineOptionTest.prepareBooleanFlag(optionName, true));
}
}
@Override
protected void verifyOptionValues() throws Throwable {
// Verify that the tested option is disabled by default.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be disabled by default",
optionName),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS);
// Verify that it is not possible to explicitly enable the option.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be off on unsupported "
+ "X86CPU even if set to true directly", optionName),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(optionName, true));
if (checkUseSHA) {
// Verify that the tested option is disabled even if +UseSHA was passed
// to JVM.
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
String.format("Option '%s' should be off on unsupported "
+ "X86CPU even if %s flag set to JVM",
optionName, CommandLineOptionTest.prepareBooleanFlag(
DigestOptionsBase.USE_SHA_OPTION, true)),
DigestOptionsBase.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
CommandLineOptionTest.prepareBooleanFlag(
DigestOptionsBase.USE_SHA_OPTION, true));
}
}
}