--- /dev/null 2015-06-16 16:00:51.952800020 +0300 +++ new/test/runtime/CommandLine/OptionsValidation/common/optionsvalidation/IntJVMOption.java 2015-06-16 18:36:45.077575624 +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 getValidValues() { + List 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 getInvalidValues() { + List 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; + } +}