534 lines
23 KiB
Java
534 lines
23 KiB
Java
/*
|
|
* 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}},
|
|
};
|
|
}
|