archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-26 14:24:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8059623: JEP-JDK-8043304: Test task: command line options tests

Browse source 
Reviewed-by: twisti, thartmann, goetz, iignatyev
This commit is contained in:
Filipp Zhinkin 2014-12-26 14:33:23 +03:00
parent 80613b8656
commit f70b5b2e9c
11 changed files with 1123 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

182
hotspot/test/compiler/codecache/cli/TestSegmentedCodeCacheOption.java Normal file
View file

@ -0,0 +1,182 @@
/*
* 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.
*/
import com.oracle.java.testlibrary.ExitCode;
import com.oracle.java.testlibrary.Platform;
import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
import common.CodeCacheOptions;
import sun.hotspot.code.BlobType;
/**
* @test
* @bug 8015774
* @summary Verify SegmentedCodeCache option's processing
* @library /testlibrary /../../test/lib
* @build TestSegmentedCodeCacheOption com.oracle.java.testlibrary.*
* @run main TestSegmentedCodeCacheOption
*/
public class TestSegmentedCodeCacheOption {
private static final String INT_MODE = "-Xint";
private static final String TIERED_COMPILATION = "TieredCompilation";
private static final String SEGMENTED_CODE_CACHE = "SegmentedCodeCache";
private static final String USE_SEGMENTED_CODE_CACHE
= CommandLineOptionTest.prepareBooleanFlag(SEGMENTED_CODE_CACHE,
true);
private static final long THRESHOLD_CC_SIZE_VALUE
= CodeCacheOptions.mB(240);
private static final long BELOW_THRESHOLD_CC_SIZE
= THRESHOLD_CC_SIZE_VALUE - CodeCacheOptions.mB(1);
private static final String[] UNEXPECTED_MESSAGES = new String[] {
".*" + SEGMENTED_CODE_CACHE + ".*"
};
private static enum TestCase {
JVM_STARTUP {
@Override
public void run() throws Throwable {
// There should be no errors when we're trying to enable SCC ...
String testCaseWarningMessage = "JVM output should not contain "
+ "any warnings related to " + SEGMENTED_CODE_CACHE;
String testCaseExitCodeMessage = "JVM should start without any "
+ "issues with " + USE_SEGMENTED_CODE_CACHE;
CommandLineOptionTest.verifySameJVMStartup(
/* expectedMessages */ null, UNEXPECTED_MESSAGES,
testCaseExitCodeMessage, testCaseWarningMessage,
ExitCode.OK, USE_SEGMENTED_CODE_CACHE);
// ... and when we're trying to enable it w/o TieredCompilation
testCaseExitCodeMessage = "Disabled tiered compilation should "
+ "not cause startup failure w/ "
+ USE_SEGMENTED_CODE_CACHE;
CommandLineOptionTest.verifySameJVMStartup(
/* expectedMessages */ null, UNEXPECTED_MESSAGES,
testCaseExitCodeMessage, testCaseWarningMessage,
ExitCode.OK, USE_SEGMENTED_CODE_CACHE,
CommandLineOptionTest.prepareBooleanFlag(
TIERED_COMPILATION, false));
// ... and even w/ Xint.
testCaseExitCodeMessage = "It should be possible to use "
+ USE_SEGMENTED_CODE_CACHE + " in interpreted mode "
+ "without any errors.";
CommandLineOptionTest.verifyJVMStartup(
/* expected messages */ null, UNEXPECTED_MESSAGES,
testCaseExitCodeMessage, testCaseWarningMessage,
ExitCode.OK, false, INT_MODE, USE_SEGMENTED_CODE_CACHE);
}
},
OPTION_VALUES_GENERIC {
@Override
public void run() throws Throwable {
// SCC is disabled w/o TieredCompilation by default
String errorMessage = SEGMENTED_CODE_CACHE
+ " should be disabled by default when tiered "
+ "compilation is disabled";
CommandLineOptionTest.verifyOptionValueForSameVM(
SEGMENTED_CODE_CACHE, "false", errorMessage,
CommandLineOptionTest.prepareBooleanFlag(
TIERED_COMPILATION, false));
// SCC is disabled by default when ReservedCodeCacheSize is too
// small
errorMessage = String.format("%s should be disabled bu default "
+ "when %s value is too small.", SEGMENTED_CODE_CACHE,
BlobType.All.sizeOptionName);
CommandLineOptionTest.verifyOptionValueForSameVM(
SEGMENTED_CODE_CACHE, "false", errorMessage,
CommandLineOptionTest.prepareNumericFlag(
BlobType.All.sizeOptionName,
BELOW_THRESHOLD_CC_SIZE));
// SCC could be explicitly enabled w/ Xint
errorMessage = String.format("It should be possible to "
+ "explicitly enable %s in interpreted mode.",
SEGMENTED_CODE_CACHE);
CommandLineOptionTest.verifyOptionValue(SEGMENTED_CODE_CACHE,
"true", errorMessage, false, INT_MODE,
USE_SEGMENTED_CODE_CACHE);
// SCC could be explicitly enabled w/o TieredCompilation and w/
// small ReservedCodeCacheSize value
errorMessage = String.format("It should be possible to "
+ "explicitly enable %s with small %s and "
+ "disabled tiered comp.", SEGMENTED_CODE_CACHE,
BlobType.All.sizeOptionName);
CommandLineOptionTest.verifyOptionValueForSameVM(
SEGMENTED_CODE_CACHE, "true", errorMessage,
CommandLineOptionTest.prepareBooleanFlag(
TIERED_COMPILATION, false),
CommandLineOptionTest.prepareNumericFlag(
BlobType.All.sizeOptionName,
BELOW_THRESHOLD_CC_SIZE),
USE_SEGMENTED_CODE_CACHE);
}
},
OPTION_VALUES_SERVER_SPECIFIC {
@Override
public boolean isApplicable() {
return Platform.isServer() && Platform.isTieredSupported();
}
@Override
public void run() throws Throwable {
// SCC is enabled by default when TieredCompilation is on and
// ReservedCodeCacheSize is large enough
String errorMessage = String.format("Large enough %s and "
+ "enabled tiered compilation should enable %s "
+ "by default.", BlobType.All.sizeOptionName,
SEGMENTED_CODE_CACHE);
CommandLineOptionTest.verifyOptionValueForSameVM(
SEGMENTED_CODE_CACHE, "true", errorMessage,
CommandLineOptionTest.prepareNumericFlag(
BlobType.All.sizeOptionName,
THRESHOLD_CC_SIZE_VALUE),
CommandLineOptionTest.prepareBooleanFlag(
TIERED_COMPILATION, true));
}
};
TestCase() {
}
public boolean isApplicable() {
return true;
}
public abstract void run() throws Throwable;
}
public static void main(String args[]) throws Throwable {
for (TestCase testCase : TestCase.values()) {
if (testCase.isApplicable()) {
System.out.println("Running test case: " + testCase.name());
testCase.run();
} else {
System.out.println("Test case skipped: " + testCase.name());
}
}
}
}