|
|
Java example source code file (ConstraintTest.java)
This example Java source code file (ConstraintTest.java) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The ConstraintTest.java Java example source code
/*
* Copyright (c) 2005, 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 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 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();
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 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}},
};
}
Other Java examples (source code examples)
Here is a short list of links related to this Java ConstraintTest.java source code file:
|
The search page
Other Java source code examples at this package level
Click here to learn more about this project
