/*
* 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
* @modules java.management
* @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}},
};
}