hotspot/test/runtime/CommandLine/OptionsValidation/common/optionsvalidation/IntJVMOption.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/CommandLine/OptionsValidation/common/optionsvalidation/IntJVMOption.java Fri Jun 19 07:57:31 2015 +0300
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2015, 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 optionsvalidation;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import jdk.test.lib.Platform;
+
+public class IntJVMOption extends JVMOption {
+
+ private static final BigInteger MIN_LONG;
+ private static final BigInteger MAX_LONG;
+ private static final BigInteger MAX_UNSIGNED_LONG;
+ private static final BigInteger MAX_UNSIGNED_LONG_64;
+ private static final BigInteger MINUS_ONE = new BigInteger("-1");
+ private static final BigInteger TWO = new BigInteger("2");
+ private static final BigInteger MIN_4_BYTE_INT = new BigInteger("-2147483648");
+ private static final BigInteger MAX_4_BYTE_INT = new BigInteger("2147483647");
+ private static final BigInteger MAX_4_BYTE_INT_PLUS_ONE = new BigInteger("2147483648");
+ private static final BigInteger MAX_4_BYTE_UNSIGNED_INT = new BigInteger("4294967295");
+ private static final BigInteger MAX_4_BYTE_UNSIGNED_INT_PLUS_ONE = new BigInteger("4294967296");
+
+ /**
+ * Mininum option value
+ */
+ private BigInteger min;
+
+ /**
+ * Maximum option value
+ */
+ private BigInteger max;
+
+ /**
+ * Option type: intx, uintx, size_t or uint64_t
+ */
+ private String type;
+
+ /**
+ * Is this value signed or unsigned
+ */
+ private boolean unsigned;
+
+ /**
+ * Is this 32 bit type
+ */
+ private boolean is32Bit = false;
+
+ /**
+ * Is this value 64 bit unsigned
+ */
+ private boolean uint64 = false;
+
+ static {
+ if (Platform.is32bit()) {
+ MIN_LONG = new BigInteger(String.valueOf(Integer.MIN_VALUE));
+ MAX_LONG = new BigInteger(String.valueOf(Integer.MAX_VALUE));
+ MAX_UNSIGNED_LONG = MAX_LONG.multiply(TWO).add(BigInteger.ONE);
+ } else {
+ MIN_LONG = new BigInteger(String.valueOf(Long.MIN_VALUE));
+ MAX_LONG = new BigInteger(String.valueOf(Long.MAX_VALUE));
+ MAX_UNSIGNED_LONG = MAX_LONG.multiply(TWO).add(BigInteger.ONE);
+ }
+
+ MAX_UNSIGNED_LONG_64 = (new BigInteger(String.valueOf(Long.MAX_VALUE)))
+ .multiply(TWO).add(BigInteger.ONE);
+ }
+
+ private IntJVMOption() {
+ type = "";
+ }
+
+ /**
+ * Initialize new integer option with given type. Type can be: INTX -
+ * integer signed option UINTX - unsigned integer option UINT64_T - unsigned
+ * 64 bit integer option
+ *
+ * @param name name of the option
+ * @param type type of the option
+ */
+ IntJVMOption(String name, String type) {
+ this.name = name;
+ this.type = type;
+
+ switch (type) {
+ case "uint64_t":
+ unsigned = true;
+ uint64 = true;
+ max = MAX_UNSIGNED_LONG_64;
+ break;
+ case "uintx":
+ case "size_t":
+ unsigned = true;
+ max = MAX_UNSIGNED_LONG;
+ break;
+ case "uint":
+ unsigned = true;
+ is32Bit = true;
+ max = MAX_4_BYTE_UNSIGNED_INT;
+ break;
+ case "int":
+ min = MIN_4_BYTE_INT;
+ max = MAX_4_BYTE_INT;
+ is32Bit = true;
+ break;
+ default:
+ min = MIN_LONG;
+ max = MAX_LONG;
+ break;
+ }
+
+ if (unsigned) {
+ min = BigInteger.ZERO;
+ }
+ }
+
+ /**
+ * Initialize integer option with passed name, min and max values. Min and
+ * max are string because they can be very big, bigger than long.
+ *
+ * @param name name of the option
+ * @param min minimum value of the option
+ * @param max maximum value of the option
+ */
+ public IntJVMOption(String name, String min, String max) {
+ this();
+ this.name = name;
+ this.min = new BigInteger(min);
+ this.max = new BigInteger(max);
+ }
+
+ /**
+ * Set new minimum option value
+ *
+ * @param min new minimum value
+ */
+ @Override
+ void setMin(String min) {
+ this.min = new BigInteger(min);
+ }
+
+ /**
+ * Get string with minimum value of the option
+ *
+ * @return string with minimum value of the option
+ */
+ @Override
+ String getMin() {
+ return min.toString();
+ }
+
+ /**
+ * Set new maximum option value
+ *
+ * @param max new maximum value
+ */
+ @Override
+ void setMax(String max) {
+ this.max = new BigInteger(max);
+ }
+
+ /**
+ * Get string with maximum value of the option
+ *
+ * @return string with maximum value of the option
+ */
+ @Override
+ String getMax() {
+ return max.toString();
+ }
+
+ /**
+ * Return list of strings with valid option values which used for testing
+ * using jcmd, attach and etc.
+ *
+ * @return list of strings which contain valid values for option
+ */
+ @Override
+ protected List<String> getValidValues() {
+ List<String> validValues = new ArrayList<>();
+
+ validValues.add(min.toString());
+ validValues.add(max.toString());
+
+ if ((min.compareTo(MINUS_ONE) == -1) && (max.compareTo(MINUS_ONE) == 1)) {
+ /*
+ * Add -1 as valid value if min is less than -1 and max is greater than -1
+ */
+ validValues.add("-1");
+ }
+
+ if ((min.compareTo(BigInteger.ZERO) == -1) && (max.compareTo(BigInteger.ZERO) == 1)) {
+ /*
+ * Add 0 as valid value if min is less than 0 and max is greater than 0
+ */
+ validValues.add("0");
+ }
+ if ((min.compareTo(BigInteger.ONE) == -1) && (max.compareTo(BigInteger.ONE) == 1)) {
+ /*
+ * Add 1 as valid value if min is less than 1 and max is greater than 1
+ */
+ validValues.add("1");
+ }
+
+ if (max.compareTo(MAX_4_BYTE_INT_PLUS_ONE) == 1) {
+ /*
+ * Check for overflow when flag is assigned to the
+ * 4 byte int variable
+ */
+ validValues.add(MAX_4_BYTE_INT_PLUS_ONE.toString());
+ }
+
+ if (max.compareTo(MAX_4_BYTE_UNSIGNED_INT_PLUS_ONE) == 1) {
+ /*
+ * Check for overflow when flag is assigned to the
+ * 4 byte unsigned int variable
+ */
+ validValues.add(MAX_4_BYTE_UNSIGNED_INT_PLUS_ONE.toString());
+ }
+
+ return validValues;
+ }
+
+ /**
+ * Return list of strings with invalid option values which used for testing
+ * using jcmd, attach and etc.
+ *
+ * @return list of strings which contain invalid values for option
+ */
+ @Override
+ protected List<String> getInvalidValues() {
+ List<String> invalidValues = new ArrayList<>();
+
+ if (withRange) {
+ /* Return invalid values only for options which have defined range in VM */
+ if ((is32Bit && min.compareTo(MIN_4_BYTE_INT) != 0)
+ || (!is32Bit && min.compareTo(MIN_LONG) != 0)) {
+ invalidValues.add(min.subtract(BigInteger.ONE).toString());
+ }
+
+ if (!unsigned
+ && ((is32Bit && (max.compareTo(MAX_4_BYTE_INT) != 0))
+ || (!is32Bit && (max.compareTo(MAX_LONG) != 0)))) {
+ invalidValues.add(max.add(BigInteger.ONE).toString());
+ }
+
+ if (unsigned
+ && ((is32Bit && (max.compareTo(MAX_4_BYTE_UNSIGNED_INT) != 0))
+ || (!is32Bit && !uint64 && (max.compareTo(MAX_UNSIGNED_LONG) != 0))
+ || (uint64 && (max.compareTo(MAX_UNSIGNED_LONG_64) != 0)))) {
+ invalidValues.add(max.add(BigInteger.ONE).toString());
+ }
+ }
+
+ return invalidValues;
+ }
+
+ /**
+ * Return expected error message for option with value "value" when it used
+ * on command line with passed value
+ *
+ * @param value Option value
+ * @return expected error message
+ */
+ @Override
+ protected String getErrorMessageCommandLine(String value) {
+ String errorMsg;
+
+ if (withRange) {
+ /* Option have defined range in VM */
+ if (unsigned && ((new BigInteger(value)).compareTo(BigInteger.ZERO) < 0)) {
+ /*
+ * Special case for unsigned options with lower range equal to 0. If
+ * passed value is negative then error will be caught earlier for
+ * such options. Thus use different error message.
+ */
+ errorMsg = String.format("Improperly specified VM option '%s=%s'", name, value);
+ } else {
+ errorMsg = String.format("%s %s=%s is outside the allowed range [ %s ... %s ]",
+ type, name, value, min.toString(), max.toString());
+ }
+ } else {
+ errorMsg = "";
+ }
+
+ return errorMsg;
+ }
+}