import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import javax.management.Descriptor;

import javax.management.RuntimeOperationsException;

import javax.management.modelmbean.DescriptorSupport;

import javax.management.modelmbean.ModelMBeanInfo;

import javax.management.modelmbean.ModelMBeanInfoSupport;

public class DescriptorSupportTest {

private static final Object[] goodFields = {

"value", "",

"severity", "0",

"severity", "6",

};

private static final Object[] badFields = {

"name", null,

"name", "",

"descriptorType", null,

"descriptorType", "",

"setMethod", null,

"getMethod", null,

"role", null,

"class", null,

"visibility", null,

"visibility", new Integer(0),

"visibility", "0",

"visibility", new Integer(5),

"visibility", "5",

"severity", null,

"severity", new Integer(-1),

"severity", "-1",

"severity", new Integer(7),

"severity", "7",

"persistPolicy", null,

"persistPolicy", "bogusPersistPolicy",

"persistPeriod", null,

"persistPeriod", "not a number",

"currencyTimeLimit", null,

"currencyTimeLimit", "not a number",

"lastUpdatedTimeStamp", null,

"lastUpdatedTimeStamp", "not a number",

"lastReturnedTimeStamp", null,

"lastReturnedTimeStamp", "not a number",

"log", null,

"log", "not T or F or true or false",

"log", new Object[0],

};

public static void main(String[] args) throws Exception {

boolean ok = true;

System.out.println("Checking that name and descriptorType are " +

"mandatory");

// Try omitting name and/or descriptorType

for (int i = 0; i < 3; i++) {

final boolean addName = ((i & 1) != 0);

final boolean addDescriptorType = ((i & 2) != 0);

final List fields = new ArrayList();

if (addName)

fields.add("name=something");

if (addDescriptorType)

fields.add("descriptorType=something-else");

final String[] fs = (String[]) fields.toArray(new String[0]);

final String what =

"DescriptorSupport with " +

(addName ? "" : "no ") + "name and " +

(addDescriptorType ? "" : "no ") + "descriptorType";

DescriptorSupport ds = new DescriptorSupport(fs);

if (ds.isValid()) {

System.out.println("INCORRECTLY ACCEPTED: " + what);

ok = false;

} else

System.out.println("OK: rejected " + what);

}

for (int pass = 0; pass < 2; pass++) {

boolean shouldAccept = (pass == 0);

System.out.println("Trying out " +

(shouldAccept ? "correct" : "bogus") +

" DescriptorSupport fields");

Object[] fields = shouldAccept ? goodFields : badFields;

for (int i = 0; i < fields.length; i += 2) {

String[] names = {"name", "descriptorType"};

String[] values = {"some-name", "some-type"};

DescriptorSupport d = new DescriptorSupport(names, values);

final String name = (String) fields[i];

final Object value = fields[i + 1];

final String valueS =

(value instanceof String) ? ("\"" + value + "\"") :

(value == null) ? "null" : value.toString();

final String what =

"DescriptorSupport with " + name + " = " + valueS;

try {

d.setField(name, value);

if (shouldAccept)

System.out.println("OK: accepted " + what);

else {

System.out.println("INCORRECTLY ACCEPTED: " + what);

ok = false;

}

} catch (RuntimeOperationsException e) {

if (shouldAccept) {

System.out.println("INCORRECTLY REJECTED: " + what +

": " + e);

ok = false;

} else {

System.out.println("OK: rejected " + what);

// OK: this is what should happen

}

} catch (Exception e) {

System.out.println("WRONG EXCEPTION: " + what + ": " + e);

ok = false;

}

}

}

// 4894856: ModelMBeanInfoSupport.setDescriptor(d, "mbean") fails

System.out.println("Checking that setDescriptor(d, \"mbean\") works");

ModelMBeanInfo mmbi =

new ModelMBeanInfoSupport("x", "descr", null, null, null, null);

Descriptor d = mmbi.getDescriptor("x", "mbean");

try {

mmbi.setDescriptor(d, "mbean");

} catch (Exception e) {

System.out.println("Unexpected exception:");

e.printStackTrace(System.out);

ok = false;

}

// 5016685: DescriptorSupport forces field names to lower case

System.out.println("Checking that field name case is ignored " +

"but preserved");

ok &= caseTest(new DescriptorSupport(new String[] {"NAME=blah"}),

"DescriptorSupport(String[])");

ok &= caseTest(new DescriptorSupport(new String[] {"NAME"},

new String[] {"blah"}),

"DescriptorSupport(String[], Object[])");

DescriptorSupport d1 = new DescriptorSupport();

d1.setField("NAME", "blah");

ok &= caseTest(d1, "DescriptorSupport.setField");

d1 = new DescriptorSupport(new String[] {"NAME=blah"});

ok &= caseTest(new DescriptorSupport(d1),

"DescriptorSupport(Descriptor)");

d1 = new DescriptorSupport(new String[] {"NAME=blah"});

ok &= caseTest(new DescriptorSupport(d1.toXMLString()),

"DescriptorSupport(String)");

d1 = new DescriptorSupport(new String[] {"NAME=blah"});

ByteArrayOutputStream bos = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(bos);

oos.writeObject(d1);

oos.close();

bos.close();

ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());

ObjectInputStream ois = new ObjectInputStream(bis);

d1 = (DescriptorSupport) ois.readObject();

ok &= caseTest(d1, "serialized DescriptorSupport");

if (ok)

System.out.println("Test passed");

else {

System.out.println("TEST FAILED");

System.exit(1);

}

}

private static boolean caseTest(Descriptor d, String what) {

boolean ok = true;

System.out.println("..." + what);

String[] names = d.getFieldNames();

if (names.length != 1 || !names[0].equals("NAME")) {

ok = false;

System.out.println("...getFieldNames() fails: " +

Arrays.asList(names));

}

String[] fields = d.getFields();

if (fields.length != 1 || !fields[0].equals("NAME=blah")) {

ok = false;

System.out.println("...getFields() fails: " +

Arrays.asList(fields));

}

Object value = d.getFieldValue("namE");

if (!"blah".equals(value)) {

ok = false;

System.out.println("...getFieldValue(\"namE\") fails: " + value);

}

Object[] values = d.getFieldValues(new String[] {"namE"});

if (values.length != 1 || !"blah".equals(values[0])) {

ok = false;

System.out.println("...getFieldValues({\"namE\"}) fails: " +

Arrays.asList(values));

}

d.setField("namE", "newblah");

Object newblah = d.getFieldValue("Name");

if (!"newblah".equals(newblah)) {

ok = false;

System.out.println("...setField value not returned: " + newblah);

}

d.setFields(new String[] {"NaMe"}, new Object[] {"newerblah"});

Object newerblah = d.getFieldValue("naMe");

if (!"newerblah".equals(newerblah)) {

ok = false;

System.out.println("...setFields value not returned: " +

newerblah);

}

Descriptor d1 = (Descriptor) d.clone();

newerblah = d1.getFieldValue("NAMe");

if (!"newerblah".equals(newerblah)) {

ok = false;

System.out.println("...clone incorrect: " + newerblah);

}

d.removeField("NAme");

names = d.getFieldNames();

if (names.length != 0) {

ok = false;

System.out.println("...removeField failed: " +

Arrays.asList(names));

}

if (ok)

System.out.println("...succeeded");

return ok;

}

}