/*
* Copyright (c) 2004, 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 6273765
* @summary Test various aspects of the Descriptor interface
* @author Eamonn McManus
* @run clean DescriptorTest
* @run build DescriptorTest
* @run main DescriptorTest
*/
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
import javax.management.*;
public class DescriptorTest {
private static String failureMessage;
// Warning: many tests here know the contents of these variables
// so if you change them you must change the tests
private static final String[] testFieldNames = {
"a", "C", "aa", "int", "nul",
};
private static final Object[] testFieldValues = {
"b", "D", "bb", 5, null,
};
private static final String[] testFieldStrings = {
"a=b", "C=D", "aa=bb", "int=(5)", "nul=",
};
public static void main(String[] args) throws Exception {
genericTests(ImmutableDescriptor.class);
genericTests(javax.management.modelmbean.DescriptorSupport.class);
if (failureMessage != null)
throw new Exception("TEST FAILED: " + failureMessage);
else
System.out.println("Test passed");
}
private static void genericTests(Class<? extends Descriptor> descrClass) {
System.out.println("--- generic tests for " + descrClass.getName() +
" ---");
for (Case<Class<? extends Descriptor>, ?, ?> test :
genericDescriptorTests)
test.run(descrClass);
}
/*
Testing has three parts. We take the input parameter, of type P,
and give it to the "prepare" method. That returns us a test
parameter, of type T. We give that to the "test" method. That
in turn returns us a check value, of type C. We give this to the
"check" method. If the "check" method returns null, the test passes.
If the "check" method returns a string, that string explains the
test failure. If any of the methods throws an exception, the
test fails.
*/
private static abstract class Case<P, T, C> {
Case(String name) {
this.name = name;
}
void run(P p) {
System.out.println("test: " + name);
try {
T t = prepare(p);
C c = test(t);
String failed = check(c);
if (failed != null) {
System.out.println("FAILED: " + name + ": " + failed);
failureMessage = failed;
}
} catch (Exception e) {
System.out.println("FAILED: " + name + ": exception:");
e.printStackTrace(System.out);
failureMessage = e.toString();
}
}
abstract T prepare(P p) throws Exception;
abstract C test(T t) throws Exception;
abstract String check(C c) throws Exception;
private final String name;
}
/*
Test case where the preparation step consists of constructing an
instance of the given Descriptor subclass containing test values,
then giving that to the "test" method.
*/
private static abstract class ProtoCase<C>
extends Case<Class<? extends Descriptor>, Descriptor, C> {
ProtoCase(String name) {
super(name);
}
Descriptor prepare(Class<? extends Descriptor> descrClass)
throws Exception {
Constructor<? extends Descriptor> con =
descrClass.getConstructor(String[].class, Object[].class);
return con.newInstance(testFieldNames, testFieldValues);
}
}
/*
Test case where the "test" method must return a value of type C
which we will compare against the testValue parameter given to
the test constructor.
*/
private static abstract class ValueProtoCase<C> extends ProtoCase<C> {
ValueProtoCase(String name, C testValue) {
super(name);
this.testValue = testValue;
}
String check(C c) {
final boolean array = (testValue instanceof Object[]);
final boolean equal =
array ?
Arrays.deepEquals((Object[]) testValue, (Object[]) c) :
testValue.equals(c);
if (equal)
return null;
return "wrong value: " + string(c) + " should be " +
string(testValue);
}
private final C testValue;
}
/*
Test case where the dontChange method does some operation on the
test Descriptor that is not supposed to change the contents of
the Descriptor. This should work for both mutable and immutable
Descriptors, since immutable Descriptors are supposed to do
nothing (rather than throw an exception) for mutation operations
that would not in fact change the contents.
*/
private static abstract class UnchangedCase extends ProtoCase<Descriptor> {
UnchangedCase(String name) {
super(name);
}
Descriptor test(Descriptor d) {
dontChange(d);
return d;
}
String check(Descriptor d) {
String[] dnames = d.getFieldNames();
if (!strings(dnames).equals(strings(testFieldNames)))
return "descriptor names changed: " + strings(dnames);
Object[] values = d.getFieldValues(testFieldNames);
if (values.length != testFieldValues.length)
return "getFieldValues: bogus length: " + values.length;
for (int i = 0; i < values.length; i++) {
Object expected = testFieldValues[i];
Object found = values[i];
if ((expected == null) ?
found != null :
!expected.equals(found))
return "descriptor value changed: " + testFieldNames[i] +
" was " + expected + " now " + found;
}
return null;
}
abstract void dontChange(Descriptor d);
}
/*
Test case where the change(d) method attempts to make some
change to the Descriptor d. The behaviour depends on whether
the Descriptor is mutable or not. If the Descriptor is
immutable, then the change attempt must throw a
RuntimeOperationsException wrapping an
UnsupportedOperationException. If the Descriptor is mutable,
then the change attempt must succeed, and the Descriptor must
then look like the fieldsAndValues parameter to the constructor.
This is simply an alternating set of field names and corresponding
values. So for example if it is
"a", "b", "x", 5
that represents a Descriptor with fields "a" and "x" whose
corresponding values are "x" and Integer.valueOf(5).
*/
private static abstract class ChangedCase extends ProtoCase<Object> {
ChangedCase(String name, Object... fieldsAndValues) {
super(name);
if (fieldsAndValues.length % 2 != 0)
throw new AssertionError("test wrong: odd fieldsAndValues");
this.fieldsAndValues = fieldsAndValues;
this.immutableTest = new UnsupportedExceptionCase(name) {
void provoke(Descriptor d) {
ChangedCase.this.change(d);
}
};
}
Object test(Descriptor d) {
if (immutable(d))
return immutableTest.test(d);
else {
change(d);
return d;
}
}
String check(Object c) {
if (c instanceof Exception)
return immutableTest.check((Exception) c);
else if (!(c instanceof Descriptor)) {
return "test returned strange value: " +
c.getClass() + ": " + c;
} else {
Descriptor d = (Descriptor) c;
String[] names = new String[fieldsAndValues.length / 2];
Object[] expected = new Object[names.length];
for (int i = 0; i < fieldsAndValues.length; i += 2) {
names[i / 2] = (String) fieldsAndValues[i];
expected[i / 2] = fieldsAndValues[i + 1];
}
String[] foundNames = d.getFieldNames();
if (!strings(foundNames).equals(strings(names))) {
return "wrong field names after change: found " +
strings(foundNames) + ", expected " + strings(names);
}
Object[] found = d.getFieldValues(names);
if (!Arrays.deepEquals(expected, found)) {
return "wrong value after change: for fields " +
Arrays.asList(names) + " values are " +
Arrays.asList(found) + ", should be " +
Arrays.asList(expected);
}
return null;
}
}
abstract void change(Descriptor d);
private final Object[] fieldsAndValues;
private final ExceptionCase immutableTest;
}
/*
Test case where an operation provoke(d) on the test Descriptor d
is supposed to provoke an exception. The exception must be a
RuntimeOperationsException wrapping another exception whose type
is determined by the exceptionClass() method.
*/
private static abstract class ExceptionCase extends ProtoCase<Exception> {
ExceptionCase(String name) {
super(name);
}
Exception test(Descriptor d) {
try {
provoke(d);
return null;
} catch (Exception e) {
return e;
}
}
String check(Exception e) {
if (e == null)
return "did not throw exception: " + expected();
if (!(e instanceof RuntimeOperationsException)) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
e.printStackTrace(pw);
pw.flush();
return "wrong exception: " + expected() + ": found: " + sw;
}
Throwable cause = e.getCause();
if (!exceptionClass().isInstance(cause))
return "wrong wrapped exception: " + cause + ": " + expected();
return null;
}
String expected() {
return "expected " + RuntimeOperationsException.class.getName() +
" wrapping " + exceptionClass().getName();
}
abstract Class<? extends Exception> exceptionClass();
abstract void provoke(Descriptor d);
}
private static abstract class IllegalExceptionCase extends ExceptionCase {
IllegalExceptionCase(String name) {
super(name);
}
Class<IllegalArgumentException> exceptionClass() {
return IllegalArgumentException.class;
}
}
private static abstract class UnsupportedExceptionCase
extends ExceptionCase {
UnsupportedExceptionCase(String name) {
super(name);
}
Class<UnsupportedOperationException> exceptionClass() {
return UnsupportedOperationException.class;
}
}
/*
List of test cases. We will run through these once for
ImmutableDescriptor and once for DescriptorSupport.
Expect a compiler [unchecked] warning for this initialization.
Writing
new Case<Class<? extends Descriptor>, ?, ?>[] = {...}
would cause a compiler error since you can't have arrays of
parameterized types unless all the parameters are just "?".
This hack with varargs gives us a compiler warning instead.
Writing just:
new Case<?, ?, ?>[] = {...}
would compile here, but not where we call test.run, since you
cannot pass an object to the run(P) method if P is "?".
*/
private static final Case<Class<? extends Descriptor>, ?, ?>
genericDescriptorTests[] = constantArray(
// TEST VALUES RETURNED BY GETTERS
new Case<Class<? extends Descriptor>, Descriptor, Object[]>(
"getFieldValues on empty Descriptor") {
Descriptor prepare(Class<? extends Descriptor> c)
throws Exception {
Constructor<? extends Descriptor> con =
c.getConstructor(String[].class);
return con.newInstance(new Object[] {new String[0]});
}
Object[] test(Descriptor d) {
return d.getFieldValues("foo", "bar");
}
String check(Object[] v) {
if (v.length == 2 && v[0] == null && v[1] == null)
return null;
return "value should be array with null elements: " +
Arrays.deepToString(v);
}
},
new ValueProtoCase<Set<String>>("getFieldNames",
strings(testFieldNames)) {
Set<String> test(Descriptor d) {
return set(d.getFieldNames());
}
},
new ValueProtoCase<Set<String>>("getFields",
strings(testFieldStrings)) {
Set<String> test(Descriptor d) {
return set(d.getFields());
}
},
new ValueProtoCase<Object>("getFieldValue with exact case", "b") {
Object test(Descriptor d) {
return d.getFieldValue("a");
}
},
new ValueProtoCase<Object>("getFieldValue with lower case for upper",
"D") {
Object test(Descriptor d) {
return d.getFieldValue("c");
}
},
new ValueProtoCase<Object>("getFieldValue with upper case for lower",
"bb") {
Object test(Descriptor d) {
return d.getFieldValue("AA");
}
},
new ValueProtoCase<Object>("getFieldValue with mixed case for lower",
"bb") {
Object test(Descriptor d) {
return d.getFieldValue("aA");
}
},
new ValueProtoCase<Set<?>>("getFieldValues with null arg",
set(testFieldValues)) {
Set<?> test(Descriptor d) {
return set(d.getFieldValues((String[]) null));
}
},
new ValueProtoCase<Object[]>("getFieldValues with not all values",
new Object[] {"b", "D", 5}) {
Object[] test(Descriptor d) {
return d.getFieldValues("a", "c", "int");
}
},
new ValueProtoCase<Object[]>("getFieldValues with all values " +
"lower case",
new Object[]{"bb", "D", "b", 5}) {
Object[] test(Descriptor d) {
return d.getFieldValues("aa", "c", "a", "int");
}
},
new ValueProtoCase<Object[]>("getFieldValues with all values " +
"upper case",
new Object[] {5, "b", "D", "bb"}) {
Object[] test(Descriptor d) {
return d.getFieldValues("int", "A", "C", "AA");
}
},
new ValueProtoCase<Object[]>("getFieldValues with null name",
new Object[] {null}) {
Object[] test(Descriptor d) {
return d.getFieldValues((String) null);
}
},
new ValueProtoCase<Object[]>("getFieldValues with empty name",
new Object[] {null}) {
Object[] test(Descriptor d) {
return d.getFieldValues("");
}
},
new ValueProtoCase<Object[]>("getFieldValues with no names",
new Object[0]) {
Object[] test(Descriptor d) {
return d.getFieldValues();
}
},
// TEST OPERATIONS THAT DON'T CHANGE THE DESCRIPTOR
// Even for immutable descriptors, these are allowed
new UnchangedCase("removeField with nonexistent field") {
void dontChange(Descriptor d) {
d.removeField("noddy");
}
},
new UnchangedCase("removeField with null field") {
void dontChange(Descriptor d) {
d.removeField(null);
}
},
new UnchangedCase("removeField with empty field") {
void dontChange(Descriptor d) {
d.removeField("");
}
},
new UnchangedCase("setField leaving string unchanged") {
void dontChange(Descriptor d) {
d.setField("a", "b");
}
},
new UnchangedCase("setField leaving int unchanged") {
void dontChange(Descriptor d) {
d.setField("int", 5);
}
},
// We do not test whether you can do a setField/s with an
// unchanged value but the case of the name different.
// From the spec, that should probably be illegal, but
// it's such a corner case that we leave it alone.
new UnchangedCase("setFields with empty arrays") {
void dontChange(Descriptor d) {
d.setFields(new String[0], new Object[0]);
}
},
new UnchangedCase("setFields with unchanged values") {
void dontChange(Descriptor d) {
d.setFields(new String[] {"a", "int"},
new Object[] {"b", 5});
}
},
// TEST OPERATIONS THAT DO CHANGE THE DESCRIPTOR
// For immutable descriptors, these should provoke an exception
new ChangedCase("removeField with exact case",
"a", "b", "C", "D", "int", 5, "nul", null) {
void change(Descriptor d) {
d.removeField("aa");
}
},
new ChangedCase("removeField with upper case for lower",
"a", "b", "C", "D", "int", 5, "nul", null) {
void change(Descriptor d) {
d.removeField("AA");
}
},
new ChangedCase("removeField with lower case for upper",
"a", "b", "aa", "bb", "int", 5, "nul", null) {
void change(Descriptor d) {
d.removeField("c");
}
},
new ChangedCase("setField keeping lower case",
"a", "x", "C", "D", "aa", "bb", "int", 5,
"nul", null) {
void change(Descriptor d) {
d.setField("a", "x");
}
},
// spec says we should conserve the original case of the field name:
new ChangedCase("setField changing lower case to upper",
"a", "x", "C", "D", "aa", "bb", "int", 5,
"nul", null) {
void change(Descriptor d) {
d.setField("A", "x");
}
},
new ChangedCase("setField changing upper case to lower",
"a", "b", "C", "x", "aa", "bb", "int", 5,
"nul", null) {
void change(Descriptor d) {
d.setField("c", "x");
}
},
new ChangedCase("setField adding new field",
"a", "b", "C", "D", "aa", "bb", "int", 5, "xX", "yY",
"nul", null) {
void change(Descriptor d) {
d.setField("xX", "yY");
}
},
new ChangedCase("setField changing type of field",
"a", true, "C", "D", "aa", "bb", "int", 5,
"nul", null) {
void change(Descriptor d) {
d.setField("a", true);
}
},
new ChangedCase("setField changing non-null to null",
"a", null, "C", "D", "aa", "bb", "int", 5,
"nul", null) {
void change(Descriptor d) {
d.setField("a", null);
}
},
new ChangedCase("setField changing null to non-null",
"a", "b", "C", "D", "aa", "bb", "int", 5,
"nul", 3.14) {
void change(Descriptor d) {
d.setField("nul", 3.14);
}
},
// TEST EXCEPTION BEHAVIOUR COMMON BETWEEN MUTABLE AND IMMUTABLE
new IllegalExceptionCase("getFieldValue with null name") {
void provoke(Descriptor d) {
d.getFieldValue(null);
}
},
new IllegalExceptionCase("getFieldValue with empty name") {
void provoke(Descriptor d) {
d.getFieldValue("");
}
},
new IllegalExceptionCase("setField with null name") {
void provoke(Descriptor d) {
d.setField(null, "x");
}
},
new IllegalExceptionCase("setField with empty name") {
void provoke(Descriptor d) {
d.setField("", "x");
}
},
new IllegalExceptionCase("setFields with null fieldNames") {
void provoke(Descriptor d) {
d.setFields(null, new Object[] {"X"});
}
},
new IllegalExceptionCase("setFields with null fieldValues") {
void provoke(Descriptor d) {
d.setFields(new String[] {"X"}, null);
}
},
new IllegalExceptionCase("setFields with null fieldNames and " +
"fieldValues") {
void provoke(Descriptor d) {
d.setFields(null, null);
}
},
new IllegalExceptionCase("setFields with more fieldNames than " +
"fieldValues") {
void provoke(Descriptor d) {
d.setFields(new String[] {"A", "B"}, new String[] {"C"});
}
},
new IllegalExceptionCase("setFields with more fieldValues than " +
"fieldNames") {
void provoke(Descriptor d) {
d.setFields(new String[] {"A"}, new String[] {"B", "C"});
}
},
new IllegalExceptionCase("setFields with null element of fieldNames") {
void provoke(Descriptor d) {
d.setFields(new String[] {null}, new String[] {"X"});
}
}
);
static <T> T[] constantArray(T... array) {
return array;
}
static String string(Object x) {
if (x instanceof Object[])
return Arrays.asList((Object[]) x).toString();
else
return String.valueOf(x);
}
static Set<String> strings(String... values) {
return new TreeSet<String>(Arrays.asList(values));
}
static <T> Set<T> set(T[] values) {
return new HashSet<T>(Arrays.asList(values));
}
static boolean immutable(Descriptor d) {
return (d instanceof ImmutableDescriptor);
// good enough for our purposes
}
}