| /* |
| * 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<>(); |
| |
| if (testMinRange) { |
| validValues.add(min.toString()); |
| } |
| if (testMaxRange) { |
| validValues.add(max.toString()); |
| } |
| |
| if (testMinRange) { |
| 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 (testMaxRange) { |
| if ((min.compareTo(MAX_4_BYTE_INT_PLUS_ONE) == -1) && (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 ((min.compareTo(MAX_4_BYTE_UNSIGNED_INT_PLUS_ONE) == -1) && (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<>(); |
| |
| /* Return invalid values only for options which have defined range in VM */ |
| if (withRange) { |
| if (unsigned) { |
| /* Only add non-negative out-of-range values for unsigned options */ |
| if (min.compareTo(BigInteger.ZERO) == 1) { |
| invalidValues.add(min.subtract(BigInteger.ONE).toString()); |
| } |
| |
| if ((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()); |
| } |
| } else { |
| if ((is32Bit && min.compareTo(MIN_4_BYTE_INT) != 0) |
| || (!is32Bit && min.compareTo(MIN_LONG) != 0)) { |
| invalidValues.add(min.subtract(BigInteger.ONE).toString()); |
| } |
| if ((is32Bit && (max.compareTo(MAX_4_BYTE_INT) != 0)) |
| || (!is32Bit && (max.compareTo(MAX_LONG) != 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; |
| } |
| } |
