| /* |
| * Copyright (c) 2005, 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. |
| */ |
| |
| /* |
| * @test |
| * @bug 6204469 |
| * @summary Test that Open MBean attributes and parameters check constraints |
| * @author Eamonn McManus |
| * |
| * @run clean ConstraintTest |
| * @run build ConstraintTest |
| * @run main ConstraintTest |
| */ |
| |
| import java.util.*; |
| import javax.management.*; |
| import javax.management.openmbean.*; |
| |
| public class ConstraintTest { |
| private static String failure; |
| |
| public static void main(String[] args) throws Exception { |
| for (Object[][] test : tests) { |
| if (test.length != 4) { |
| throw new Exception("Test element has wrong length: " + |
| Arrays.deepToString(test)); |
| } |
| |
| if (test[0].length != 4) { |
| throw new Exception("Test constraints should have size 4: " + |
| Arrays.deepToString(test[0])); |
| } |
| Object defaultValue = test[0][0]; |
| Comparable<?> minValue = (Comparable<?>) test[0][1]; |
| Comparable<?> maxValue = (Comparable<?>) test[0][2]; |
| Object[] legalValues = (Object[]) test[0][3]; |
| System.out.println("test: defaultValue=" + defaultValue + |
| "; minValue=" + minValue + |
| "; maxValue=" + maxValue + |
| "; legalValues=" + |
| Arrays.deepToString(legalValues)); |
| |
| if (test[1].length != 1) { |
| throw new Exception("OpenType list should have size 1: " + |
| Arrays.deepToString(test[1])); |
| } |
| OpenType<?> openType = (OpenType<?>) test[1][0]; |
| |
| Object[] valid = test[2]; |
| Object[] invalid = test[3]; |
| |
| System.out.println("...valid=" + Arrays.deepToString(valid)); |
| System.out.println("...invalid=" + Arrays.deepToString(invalid)); |
| |
| test(openType, defaultValue, minValue, maxValue, legalValues, |
| valid, invalid); |
| } |
| |
| if (failure == null) |
| System.out.println("Test passed"); |
| else |
| throw new Exception("TEST FAILED: " + failure); |
| } |
| |
| private static <T> void test(OpenType<T> openType, Object defaultValue, |
| Comparable<?> minValue, |
| Comparable<?> maxValue, Object[] legalValues, |
| Object[] valid, Object[] invalid) |
| throws Exception { |
| /* This hack is needed to avoid grief from the parameter checking |
| in the OpenMBean*InfoSupport constructors. Since they are defined |
| to check that the defaultValue etc are of the same type as the |
| OpenType<T>, there is no way to pass a defaultValue etc when |
| the type is OpenType<?>. So either you have to write plain |
| OpenType, and get unchecked warnings for every constructor |
| invocation, or you do this, and get the unchecked warnings just |
| here. */ |
| test1(openType, (T) defaultValue, (Comparable<T>) minValue, |
| (Comparable<T>) maxValue, (T[]) legalValues, valid, invalid); |
| } |
| |
| private static <T> void test1(OpenType<T> openType, T defaultValue, |
| Comparable<T> minValue, |
| Comparable<T> maxValue, T[] legalValues, |
| Object[] valid, Object[] invalid) |
| throws Exception { |
| |
| if (legalValues != null && (minValue != null || maxValue != null)) |
| throw new Exception("Test case has both legals and min/max"); |
| |
| if (defaultValue == null && minValue == null && maxValue == null && |
| legalValues == null) { |
| test(new OpenMBeanAttributeInfoSupport("name", "descr", openType, |
| true, true, false), |
| valid, invalid); |
| test(new OpenMBeanAttributeInfoSupport("name", "descr", openType, |
| true, true, false, nullD), |
| valid, invalid); |
| test(new OpenMBeanAttributeInfoSupport("name", "descr", openType, |
| true, true, false, emptyD), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("name", "descr", openType), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("name", "descr", openType, |
| nullD), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("name", "descr", openType, |
| emptyD), |
| valid, invalid); |
| } |
| |
| if (minValue == null && maxValue == null && legalValues == null) { |
| Descriptor d = descriptor("defaultValue", defaultValue); |
| test(new OpenMBeanAttributeInfoSupport("blah", "descr", openType, |
| true, true, false, d), |
| valid, invalid); |
| test(new OpenMBeanAttributeInfoSupport("blah", "descr", |
| openType, true, true, |
| false, defaultValue), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("blah", "descr", openType, |
| d), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("blah", "descr", openType, |
| defaultValue), |
| valid, invalid); |
| } |
| |
| if (legalValues == null) { |
| Descriptor d = descriptor("defaultValue", defaultValue, |
| "minValue", minValue, |
| "maxValue", maxValue); |
| test(new OpenMBeanAttributeInfoSupport("name", "descr", openType, |
| true, true, false, d), |
| valid, invalid); |
| test(new OpenMBeanAttributeInfoSupport("name", "descr", openType, |
| true, true, false, |
| defaultValue, |
| minValue, maxValue), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("name", "descr", openType, |
| d), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("name", "descr", openType, |
| defaultValue, |
| minValue, maxValue), |
| valid, invalid); |
| } |
| |
| if (minValue == null && maxValue == null) { |
| // Legal values in descriptor can be either an array or a set |
| Descriptor d1 = descriptor("defaultValue", defaultValue, |
| "legalValues", legalValues); |
| Descriptor d2; |
| if (legalValues == null) |
| d2 = d1; |
| else { |
| d2 = descriptor("defaultValue", defaultValue, |
| "legalValues", arraySet(legalValues)); |
| } |
| test(new OpenMBeanAttributeInfoSupport("name", "descr", openType, |
| true, true, false, d1), |
| valid, invalid); |
| test(new OpenMBeanAttributeInfoSupport("name", "descr", openType, |
| true, true, false, d2), |
| valid, invalid); |
| test(new OpenMBeanAttributeInfoSupport("name", "descr", openType, |
| true, true, false, |
| defaultValue, legalValues), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("name", "descr", openType, |
| d1), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("name", "descr", openType, |
| d2), |
| valid, invalid); |
| test(new OpenMBeanParameterInfoSupport("name", "descr", openType, |
| defaultValue, legalValues), |
| valid, invalid); |
| } |
| } |
| |
| /* Test one of the objects. Note that OpenMBeanAttributeInfo |
| extends OpenMBeanParameterInfo, so OpenMBeanAttributeInfoSupport |
| is-an OpenMBeanParameterInfo. */ |
| private static void test(OpenMBeanParameterInfo info, |
| Object[] valid, Object[] invalid) { |
| test1(info, valid, invalid); |
| |
| // Check that the constraints can be specified as strings |
| // rather than objects |
| if (info.getOpenType() instanceof SimpleType<?>) { |
| Descriptor d = ((DescriptorRead) info).getDescriptor(); |
| String[] names = d.getFieldNames(); |
| Object[] values = d.getFieldValues(names); |
| for (int i = 0; i < values.length; i++) { |
| if (values[i] == null) |
| continue; |
| if (names[i].equals("legalValues")) { |
| Collection<?> legals; |
| if (values[i] instanceof Collection<?>) |
| legals = (Collection<?>) values[i]; |
| else |
| legals = Arrays.asList((Object[]) values[i]); |
| List<String> strings = new ArrayList<String>(); |
| for (Object legal : legals) |
| strings.add(legal.toString()); |
| values[i] = strings.toArray(new String[0]); |
| } else if (!(values[i] instanceof OpenType<?>)) |
| values[i] = values[i].toString(); |
| } |
| d = new ImmutableDescriptor(names, values); |
| OpenType<?> ot = info.getOpenType(); |
| if (info instanceof OpenMBeanAttributeInfo) { |
| OpenMBeanAttributeInfo ai = (OpenMBeanAttributeInfo) info; |
| info = new OpenMBeanAttributeInfoSupport(info.getName(), |
| info.getDescription(), |
| info.getOpenType(), |
| ai.isReadable(), |
| ai.isWritable(), |
| ai.isIs(), |
| d); |
| } else { |
| info = new OpenMBeanParameterInfoSupport(info.getName(), |
| info.getDescription(), |
| info.getOpenType(), |
| d); |
| } |
| test1(info, valid, invalid); |
| } |
| } |
| |
| private static void test1(OpenMBeanParameterInfo info, |
| Object[] valid, Object[] invalid) { |
| |
| for (Object x : valid) { |
| if (!info.isValue(x)) { |
| fail("Object should be valid but is not: " + x + " for: " + |
| info); |
| } |
| } |
| |
| for (Object x : invalid) { |
| if (info.isValue(x)) { |
| fail("Object should not be valid but is: " + x + " for: " + |
| info); |
| } |
| } |
| |
| /* If you specify e.g. minValue in a descriptor, then we arrange |
| for getMinValue() to return the same value, and if you specify |
| a minValue as a constructor parameter then we arrange for the |
| descriptor to have a minValue entry. Check that these values |
| do in fact match. */ |
| |
| Descriptor d = ((DescriptorRead) info).getDescriptor(); |
| |
| checkSameValue("defaultValue", info.getDefaultValue(), |
| d.getFieldValue("defaultValue")); |
| checkSameValue("minValue", info.getMinValue(), |
| d.getFieldValue("minValue")); |
| checkSameValue("maxValue", info.getMaxValue(), |
| d.getFieldValue("maxValue")); |
| checkSameValues("legalValues", info.getLegalValues(), |
| d.getFieldValue("legalValues")); |
| } |
| |
| private static void checkSameValue(String what, Object getterValue, |
| Object descriptorValue) { |
| if (getterValue == null) { |
| if (descriptorValue != null) { |
| fail("Getter returned null but descriptor has entry for " + |
| what + ": " + descriptorValue); |
| } |
| } else if (descriptorValue == null) { |
| fail("Getter returned value but descriptor has no entry for " + |
| what + ": " + getterValue); |
| } else if (!getterValue.equals(descriptorValue) && |
| !getterValue.toString().equals(descriptorValue)) { |
| fail("For " + what + " getter returned " + getterValue + |
| " but descriptor entry is " + descriptorValue); |
| } |
| } |
| |
| private static void checkSameValues(String what, Set<?> getterValues, |
| Object descriptorValues) { |
| if (getterValues == null) { |
| if (descriptorValues != null) { |
| fail("Getter returned null but descriptor has entry for " + |
| what + ": " + descriptorValues); |
| } |
| } else if (descriptorValues == null) { |
| fail("Getter returned value but descriptor has no entry for " + |
| what + ": " + getterValues); |
| } else { |
| Set<?> descriptorValueSet; |
| if (descriptorValues instanceof Set<?>) |
| descriptorValueSet = (Set<?>) descriptorValues; |
| else |
| descriptorValueSet = arraySet((Object[]) descriptorValues); |
| boolean same = true; |
| if (getterValues.size() != descriptorValueSet.size()) |
| same = false; |
| else { |
| for (Object x : getterValues) { |
| if (!descriptorValueSet.contains(x) |
| && !descriptorValueSet.contains(x.toString())) { |
| same = false; |
| break; |
| } |
| } |
| } |
| if (!same) { |
| fail("For " + what + " getter returned " + getterValues + |
| " but descriptor entry is " + descriptorValueSet); |
| } |
| } |
| } |
| |
| private static void fail(String why) { |
| System.out.println("FAILED: " + why); |
| failure = why; |
| } |
| |
| private static Descriptor descriptor(Object... entries) { |
| if (entries.length % 2 != 0) |
| throw new RuntimeException("Odd length descriptor entries"); |
| String[] names = new String[entries.length / 2]; |
| Object[] values = new Object[entries.length / 2]; |
| for (int i = 0; i < entries.length; i += 2) { |
| names[i / 2] = (String) entries[i]; |
| values[i / 2] = entries[i + 1]; |
| } |
| return new ImmutableDescriptor(names, values); |
| } |
| |
| private static <T> Set<T> arraySet(T[] array) { |
| return new HashSet<T>(Arrays.asList(array)); |
| } |
| |
| private static final OpenType<?> |
| ostring = SimpleType.STRING, |
| oint = SimpleType.INTEGER, |
| obool = SimpleType.BOOLEAN, |
| olong = SimpleType.LONG, |
| obyte = SimpleType.BYTE, |
| ofloat = SimpleType.FLOAT, |
| odouble = SimpleType.DOUBLE, |
| ostringarray, ostringarray2; |
| private static final CompositeType ocomposite; |
| private static final CompositeData compositeData, compositeData2; |
| static { |
| try { |
| ostringarray = new ArrayType<String[]>(1, ostring); |
| ostringarray2 = new ArrayType<String[][]>(2, ostring); |
| ocomposite = |
| new CompositeType("name", "descr", |
| new String[] {"s", "i"}, |
| new String[] {"sdesc", "idesc"}, |
| new OpenType[] {ostring, oint}); |
| compositeData = |
| new CompositeDataSupport(ocomposite, |
| new String[] {"s", "i"}, |
| new Object[] {"foo", 23}); |
| compositeData2 = |
| new CompositeDataSupport(ocomposite, |
| new String[] {"s", "i"}, |
| new Object[] {"bar", -23}); |
| } catch (OpenDataException e) { // damn checked exceptions... |
| throw new IllegalArgumentException(e.toString(), e); |
| } |
| } |
| |
| private static final Descriptor |
| nullD = null, |
| emptyD = ImmutableDescriptor.EMPTY_DESCRIPTOR; |
| |
| /* The elements of this array are grouped as follows. Each |
| element contains four Object[]s. The first one is a set of |
| four values: default value, min value, max value, legal values |
| (an Object[]), some of which can be null. These will be used |
| to derive the OpenMBean*Info values to be tested. The second |
| is an array with one element that is the OpenType that will be |
| given to the constructors of the OpenMBean*Infos. The third |
| element is a set of values that should be valid according to |
| the constraints in the OpenMBean*Info. The fourth is a set of |
| values that should be invalid according to those |
| constraints. */ |
| private static final Object[][][] tests = { |
| |
| // Test cases when there are no constraints |
| // Validity checking is limited to type of object |
| |
| {{null, null, null, null}, |
| {oint}, |
| {-1, 0, 1, Integer.MAX_VALUE, Integer.MIN_VALUE}, |
| {null, "noddy", 1.3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{null, null, null, null}, |
| {obool}, |
| {true, false}, |
| {null, "noddy", 1.3, 3, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{null, null, null, null}, |
| {ostring}, |
| {"", "yes!"}, |
| {null, 1.3, 3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{null, null, null, null}, |
| {obyte}, |
| {Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 0}, |
| {null, "noddy", 1.3, 3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{null, null, null, null}, |
| {ostringarray}, |
| {new String[0], new String[] {"hello", "world"}}, |
| {null, "noddy", 1.3, 3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{null, null, null, null}, |
| {ostringarray2}, |
| {new String[0][0], new String[][] {{"hello", "world"}, |
| {"goodbye", "cruel", "world"}}}, |
| {null, "noddy", 1.3, 3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{null, null, null, null}, |
| {ocomposite}, |
| {compositeData, compositeData2}, |
| {null, "noddy", 1.3, 3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| // Test cases where there is a default value, so null is allowed |
| |
| {{23, null, null, null}, |
| {oint}, |
| {null, -1, 0, 1, Integer.MAX_VALUE, Integer.MIN_VALUE}, |
| {"noddy", 1.3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{true, null, null, null}, |
| {obool}, |
| {null, true, false}, |
| {"noddy", 1.3, 3, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{"foo", null, null, null}, |
| {ostring}, |
| {null, "", "yes!"}, |
| {1.3, 3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{(byte) 23, null, null, null}, |
| {obyte}, |
| {null, Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 0}, |
| {"noddy", 1.3, 3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| {{compositeData, null, null, null}, |
| {ocomposite}, |
| {null, compositeData, compositeData2}, |
| {"noddy", 1.3, 3, false, 3L, Long.MAX_VALUE, emptyD, |
| new int[2], new Integer[2], new Integer[] {3}, new Integer[0]}}, |
| |
| // Test cases where there is a min and/or max, with or without default |
| |
| {{23, 0, 50, null}, |
| {oint}, |
| {null, 0, 25, 50}, |
| {"noddy", -1, 51, Integer.MIN_VALUE, Integer.MAX_VALUE, 25L}}, |
| |
| {{null, 0, 50, null}, |
| {oint}, |
| {0, 25, 50}, |
| {null, "noddy", -1, 51, Integer.MIN_VALUE, Integer.MAX_VALUE, 25L}}, |
| |
| {{null, 0, null, null}, |
| {oint}, |
| {0, 25, 50, Integer.MAX_VALUE}, |
| {null, "noddy", -1, Integer.MIN_VALUE, 25L}}, |
| |
| {{null, null, 50, null}, |
| {oint}, |
| {Integer.MIN_VALUE, -1, 0, 25, 50}, |
| {null, "noddy", 51, Integer.MAX_VALUE, 25L}}, |
| |
| {{"go", "a", "z~", null}, |
| {ostring}, |
| {null, "a", "z~", "zzzz", "z!"}, |
| {"A", "~", "", -1}}, |
| |
| // Test cases where there is a set of legal values |
| |
| {{23, null, null, new Integer[] {2, 3, 5, 7, 11, 13, 17, 23}}, |
| {oint}, |
| {null, 2, 11, 23}, |
| {"noddy", -1, 1, 51, Integer.MIN_VALUE, Integer.MAX_VALUE, 25L}}, |
| |
| {{null, null, null, new CompositeData[] {compositeData}}, |
| {ocomposite}, |
| {compositeData}, |
| {null, compositeData2, "noddy"}}, |
| |
| {{null, null, null, new Long[0]}, |
| {olong}, |
| {}, // constraint is impossible to satisfy! |
| {null, 23L, "x", 23}}, |
| }; |
| } |
