test/jdk/javax/management/generified/GenericTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2004, 2020, 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 4847959 6191402
  * @summary Test newly-generified APIs
  * @author Eamonn McManus
  *
  * @run clean GenericTest
  * @run build GenericTest
  * @run main GenericTest
  */

 import java.lang.management.ManagementFactory;
 import java.lang.reflect.*;
 import java.util.*;
 import java.util.stream.Stream;
 import javax.management.*;
 import javax.management.openmbean.*;
 import javax.management.relation.*;
 import javax.management.timer.Timer;
 import javax.management.timer.TimerMBean;

 public class GenericTest {
     private static int failures;

     public static void main(String[] args) throws Exception {
         MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

         // Check we are really using the generified version
         boolean generic;
         Method findmbs = MBeanServerFactory.class.getMethod("findMBeanServer",
                                                             String.class);
         Type findmbstype = findmbs.getGenericReturnType();
         if (!(findmbstype instanceof ParameterizedType)) {
             System.out.println("FAILURE: API NOT GENERIC!");
             System.out.println("  MBeanServerFactory.findMBeanServer -> " +
                                findmbstype);
             failures++;
             generic = false;
         } else {
             System.out.println("OK: this API is generic");
             generic = true;
         }

         ArrayList<MBeanServer> mbsList1 =
             MBeanServerFactory.findMBeanServer(null);
         checked(mbsList1, MBeanServer.class);
         ArrayList mbsList2 = MBeanServerFactory.findMBeanServer(null);
         check("ArrayList<MBeanServer> findMBeanServer", mbsList1.size() == 1);
         check("ArrayList findMBeanServer", mbsList1.equals(mbsList2));

         boolean isSecondAttempt = false;
         Set<ObjectName> names1 = null;
         while (true) {
             names1 = checked(mbs.queryNames(null, null), ObjectName.class);
             Set names2 = mbs.queryNames(null, null);
             Set<ObjectName> names3 =
                     checked(((MBeanServerConnection) mbs).queryNames(null, null),
                             ObjectName.class);
             // If new MBean (e.g. Graal MBean) is registered while the test is running, names1,
             // names2, and names3 will have different sizes. Repeat the test in this case.
             if (sameSize(names1, names2, names3) || isSecondAttempt) {
                 check("Set<ObjectName> MBeanServer.queryNames", names1.size() >= 1);
                 check("Set MBeanServer.queryNames", names2.size() >= 1);
                 check("Set<ObjectName> MBeanServerConnection.queryNames",
                         names3.size() >= 1);
                 check("queryNames sets same",
                         names1.equals(names2) && names2.equals(names3));
                 break;
             }
             isSecondAttempt = true;
             System.out.println("queryNames sets have different size, retrying...");
         }

         isSecondAttempt = false;
         while (true) {
             Set<ObjectInstance> mbeans1 =
                     checked(mbs.queryMBeans(null, null), ObjectInstance.class);
             Set mbeans2 = mbs.queryMBeans(null, null);
             Set<ObjectInstance> mbeans3 =
                     checked(((MBeanServerConnection) mbs).queryMBeans(null, null),
                             ObjectInstance.class);
             // If new MBean (e.g. Graal MBean) is registered while the test is running, mbeans1,
             // mbeans2, and mbeans3 will have different sizes. Repeat the test in this case.
             if (sameSize(mbeans1, mbeans2, mbeans3) || isSecondAttempt) {
                 check("Set<ObjectInstance> MBeanServer.queryMBeans",
                         mbeans1.size() >= 1);
                 check("Set MBeanServer.queryMBeans", mbeans2.size() >= 1);
                 check("Set<ObjectInstance> MBeanServerConnection.queryMBeans",
                         mbeans3.size() >= 1);
                 check("queryMBeans sets same",
                         mbeans1.equals(mbeans2) && mbeans2.equals(mbeans3));
                 break;
             }
             isSecondAttempt = true;
             System.out.println("queryMBeans sets have different size, retrying...");
         }

         AttributeChangeNotificationFilter acnf =
             new AttributeChangeNotificationFilter();
         acnf.enableAttribute("foo");
         Vector<String> acnfs = acnf.getEnabledAttributes();
         checked(acnfs, String.class);
         check("Vector<String> AttributeChangeNotificationFilter.getEnabled" +
               "Attributes", acnfs.equals(Arrays.asList(new String[] {"foo"})));

         if (generic) {
             Attribute a = new Attribute("foo", "bar");
             AttributeList al1 = new AttributeList();
             al1.add(a);
             AttributeList al2 =
                 new AttributeList(Arrays.asList(new Attribute[] {a}));
             check("new AttributeList(List<Attribute>)", al1.equals(al2));
             List<Attribute> al3 = checked(al1.asList(), Attribute.class);
             al3.remove(a);
             check("List<Attribute> AttributeList.asList()",
                   al1.equals(al3) && al1.isEmpty());
         }

         List<ObjectName> namelist1 = new ArrayList<ObjectName>(names1);
         Role role = new Role("rolename", namelist1);
         List<ObjectName> namelist2 =
             checked(role.getRoleValue(), ObjectName.class);
         check("new Role(String,List<ObjectName>).getRoleValue() -> " +
               "List<ObjectName>", namelist1.equals(namelist2));

         RoleList rl1 = new RoleList();
         rl1.add(role);
         RoleList rl2 = new RoleList(Arrays.asList(new Role[] {role}));
         check("new RoleList(List<Role>)", rl1.equals(rl2));
         if (generic) {
             List<Role> rl3 = checked(rl1.asList(), Role.class);
             rl3.remove(role);
             check("List<Role> RoleList.asList()",
                   rl1.equals(rl3) && rl1.isEmpty());
         }

         RoleUnresolved ru =
             new RoleUnresolved("rolename", namelist1,
                                RoleStatus.LESS_THAN_MIN_ROLE_DEGREE);
         List<ObjectName> namelist3 =
             checked(ru.getRoleValue(), ObjectName.class);
         check("new RoleUnresolved(...List<ObjectName>...).getRoleValue() -> " +
               "List<ObjectName>", namelist1.equals(namelist3));

         RoleUnresolvedList rul1 = new RoleUnresolvedList();
         rul1.add(ru);
         RoleUnresolvedList rul2 =
             new RoleUnresolvedList(Arrays.asList(new RoleUnresolved[] {ru}));
         check("new RoleUnresolvedList(List<RoleUnresolved>", rul1.equals(rul2));
         if (generic) {
             List<RoleUnresolved> rul3 =
                 checked(rul1.asList(), RoleUnresolved.class);
             rul3.remove(ru);
             check("List<RoleUnresolved> RoleUnresolvedList.asList()",
                   rul1.equals(rul3) && rul1.isEmpty());
         }

         // This case basically just tests that we can compile this sort of thing
         OpenMBeanAttributeInfo ombai1 =
             new OpenMBeanAttributeInfoSupport("a", "a descr",
                                                 SimpleType.INTEGER,
                                                 true, true, false);
         CompositeType ct =
             new CompositeType("ct", "ct descr", new String[] {"item1"},
                               new String[] {"item1 descr"},
                               new OpenType[] {SimpleType.INTEGER});
         OpenMBeanAttributeInfo ombai2 =
             new OpenMBeanAttributeInfoSupport("a", "a descr",
                                                       ct, true, true, false);
         TabularType tt =
             new TabularType("tt", "tt descr", ct, new String[] {"item1"});
         OpenMBeanAttributeInfo ombai3 =
             new OpenMBeanAttributeInfoSupport("a", "a descr",
                                                     tt, true, true, false);
         ArrayType<String[][]> at =
             new ArrayType<String[][]>(2, SimpleType.STRING);
         OpenMBeanAttributeInfo ombai4 =
             new OpenMBeanAttributeInfoSupport("a", "a descr",
                                                    at, true, true, false);
         OpenMBeanAttributeInfo ombai4a =
             new OpenMBeanAttributeInfoSupport("a", "a descr",
                                               (ArrayType) at,
                                               true, true, false);
         OpenMBeanAttributeInfo ombai5 =
             new OpenMBeanAttributeInfoSupport("a", "a descr",
                                                        SimpleType.INTEGER,
                                                        true, true, false,
                                                        5, 1, 9);
         OpenMBeanAttributeInfo ombai6 =
             new OpenMBeanAttributeInfoSupport("a", "a descr",
                                                        SimpleType.INTEGER,
                                                        true, true, false,
                                                        5, new Integer[] {1, 5});

         OpenMBeanInfo ombi =
             new OpenMBeanInfoSupport("a.a", "a.a descr",
                                      new OpenMBeanAttributeInfo[] {
                                          ombai1, ombai2, ombai3, ombai4,
                                          ombai5, ombai6,
                                      },
                                      null, null, null);

         Map<String,Integer> itemMap =
             checked(singletonMap("item1", 5),
                     String.class, Integer.class);
         CompositeData cd =
             new CompositeDataSupport(ct, itemMap);
         check("CompositeDataSupport(CompositeType, Map<String,?>",
               cd.get("item1").equals(5));

         Set<String> ctkeys = checked(ct.keySet(), String.class);
         check("Set<String> CompositeType.keySet()",
               ctkeys.equals(singleton("item1")));

         List<String> ttindex = checked(tt.getIndexNames(), String.class);
         check("Set<String> TabularType.getIndexNames()",
               ttindex.equals(singletonList("item1")));

         TabularData td = new TabularDataSupport(tt);
         td.putAll(new CompositeData[] {cd});
         List<Integer> tdkey = checked(singletonList(5), Integer.class);
         Set<List<Integer>> tdkeys = checked(singleton(tdkey),
             (Class<List<Integer>>) tdkey.getClass());
         Collection<CompositeData> tdvalues = checked(singleton(cd),
             CompositeData.class);
         check("Set<List<?>> TabularDataSupport.keySet()",
               td.keySet().equals(tdkeys));
         check("Collection<CompositeData> TabularDataSupport.values()",
               td.values().iterator().next().equals(tdvalues.iterator().next()));

         ObjectName stupidName = new ObjectName("stupid:a=b");
         mbs.registerMBean(new Stupid(), stupidName);
         StupidMBean proxy =
             MBeanServerInvocationHandler.newProxyInstance(mbs,
                                                           stupidName,
                                                           StupidMBean.class,
                                                           false);
         check("MBeanServerInvocationHandler.newProxyInstance",
               proxy.getFive() == 5);
         mbs.unregisterMBean(stupidName);

         mbs.registerMBean(new StandardMBean(new Stupid(), StupidMBean.class),
                           stupidName);
         check("<T> StandardMBean(T impl, Class<T> intf)",
               proxy.getFive() == 5);

         // Following is based on the package.html for javax.management.relation
         // Create the Relation Service MBean
         ObjectName relSvcName = new ObjectName(":type=RelationService");
         RelationService relSvcObject = new RelationService(true);
         mbs.registerMBean(relSvcObject, relSvcName);

         // Create an MBean proxy for easier access to the Relation Service
         RelationServiceMBean relSvc =
         MBeanServerInvocationHandler.newProxyInstance(mbs, relSvcName,
                                                       RelationServiceMBean.class,
                                                       false);

         // Define the DependsOn relation type
         RoleInfo[] dependsOnRoles = {
             new RoleInfo("dependent", Module.class.getName()),
             new RoleInfo("dependedOn", Module.class.getName())
         };
         relSvc.createRelationType("DependsOn", dependsOnRoles);

         // Now define a relation instance "moduleA DependsOn moduleB"

         ObjectName moduleA = new ObjectName(":type=Module,name=A");
         ObjectName moduleB = new ObjectName(":type=Module,name=B");

         // Following two lines added to example:
         mbs.registerMBean(new Module(), moduleA);
         mbs.registerMBean(new Module(), moduleB);

         Role dependent = new Role("dependent", singletonList(moduleA));
         Role dependedOn = new Role("dependedOn", singletonList(moduleB));
         Role[] roleArray = {dependent, dependedOn};
         RoleList roles = new RoleList(Arrays.asList(roleArray));
         relSvc.createRelation("A-DependsOn-B", "DependsOn", roles);

         // Query the Relation Service to find what modules moduleA depends on
         Map<ObjectName,List<String>> dependentAMap =
         relSvc.findAssociatedMBeans(moduleA, "DependsOn", "dependent");
         Set<ObjectName> dependentASet = dependentAMap.keySet();
         dependentASet = checked(dependentASet, ObjectName.class);
         // Set of ObjectName containing moduleB
         check("Map<ObjectName,List<String>> RelationService.findAssociatedMBeans",
               dependentAMap.size() == 1 &&
               dependentASet.equals(singleton(moduleB)));

         Map<String,List<String>> refRels =
             relSvc.findReferencingRelations(moduleA, "DependsOn", "dependent");
         List<String> refRoles =
             checked(refRels.get("A-DependsOn-B"), String.class);
         check("Map<String,List<String>> RelationService.findReferencingRelations",
               refRoles.equals(singletonList("dependent")));

         List<String> relsOfType = relSvc.findRelationsOfType("DependsOn");
         relsOfType = checked(relsOfType, String.class);
         check("List<String> RelationService.findRelationsOfType",
               relsOfType.equals(singletonList("A-DependsOn-B")));

         List<String> allRelIds = relSvc.getAllRelationIds();
         allRelIds = checked(allRelIds, String.class);
         check("List<String> RelationService.getAllRelationIds()",
               allRelIds.equals(singletonList("A-DependsOn-B")));

         List<String> allRelTypes = relSvc.getAllRelationTypeNames();
         allRelTypes = checked(allRelTypes, String.class);
         check("List<String> RelationService.getAllRelationTypeNames",
               allRelTypes.equals(singletonList("DependsOn")));

         Map<ObjectName,List<String>> refdMBeans =
             relSvc.getReferencedMBeans("A-DependsOn-B");
         check("Map<ObjectName,List<String>> RelationService.getReferencedMBeans",
               refdMBeans.get(moduleA).equals(singletonList("dependent")) &&
               refdMBeans.get(moduleB).equals(singletonList("dependedOn")));

         List<ObjectName> roleContents =
             checked(relSvc.getRole("A-DependsOn-B", "dependent"),
                     ObjectName.class);
         check("List<ObjectName> RelationService.getRole",
               roleContents.equals(singletonList(moduleA)));

         RoleInfo roleInfoDependent =
             relSvc.getRoleInfo("DependsOn", "dependent");
         RoleInfo roleInfoDependedOn =
             relSvc.getRoleInfo("DependsOn", "dependedOn");
         List<RoleInfo> expectedRoleInfos =
             Arrays.asList(new RoleInfo[] {roleInfoDependent, roleInfoDependedOn});
         List<RoleInfo> roleInfos =
             checked(relSvc.getRoleInfos("DependsOn"), RoleInfo.class);
         check("List<RoleInfo> RelationService.getRoleInfos",
               equalListContents(expectedRoleInfos, roleInfos));

         RelationType relType =
             new RelationTypeSupport("DependsOn", dependsOnRoles);
         List<RoleInfo> relTypeRoleInfos =
             checked(relType.getRoleInfos(), RoleInfo.class);
         // Since there's no RoleInfo.equals and since the RelationTypeSupport
         // constructor clones the RoleInfos passed to it, it's tricky to
         // test equality here so we check type and size and have done with it
         check("List<RoleInfo> RelationType.getRoleInfos",
               relTypeRoleInfos.size() == 2);

         MBeanServerNotificationFilter mbsnf =
             new MBeanServerNotificationFilter();
         mbsnf.enableObjectName(moduleA);
         check("Vector<ObjectName> MBeanServerNotificationFilter." +
               "getEnabledObjectNames",
               mbsnf.getEnabledObjectNames().equals(Arrays.asList(moduleA)));
         mbsnf.enableAllObjectNames();
         mbsnf.disableObjectName(moduleB);
         check("Vector<ObjectName> MBeanServerNotificationFilter." +
               "getDisabledObjectNames",
               mbsnf.getDisabledObjectNames().equals(Arrays.asList(moduleB)));

         RelationService unusedRelSvc = new RelationService(false);
         RelationNotification rn1 =
             new RelationNotification(RelationNotification.RELATION_MBEAN_REMOVAL,
                                      unusedRelSvc, 0L, 0L, "yo!",
                                      "A-DependsOn-B", "DependsOn", null,
                                      singletonList(moduleA));
         List<ObjectName> toUnreg =
             checked(rn1.getMBeansToUnregister(), ObjectName.class);
         check("List<ObjectName> RelationNotification.getMBeansToUnregister",
               toUnreg.equals(singletonList(moduleA)));

         RelationNotification rn2 =
             new RelationNotification(RelationNotification.RELATION_MBEAN_UPDATE,
                                      unusedRelSvc, 0L, 0L, "yo!",
                                      "A-DependsOn-B", "DependsOn", null,
                                      "dependent", singletonList(moduleA),
                                      singletonList(moduleB));
         check("List<ObjectName> RelationNotification.getOldRoleValue",
               checked(rn2.getOldRoleValue(), ObjectName.class)
               .equals(singletonList(moduleB)));
         check("List<ObjectName> RelationNotification.getNewRoleValue",
               checked(rn2.getNewRoleValue(), ObjectName.class)
               .equals(singletonList(moduleA)));

         ObjectName timerName = new ObjectName(":type=timer");
         mbs.registerMBean(new Timer(), timerName);
         TimerMBean timer =
             MBeanServerInvocationHandler.newProxyInstance(mbs,
                                                           timerName,
                                                           TimerMBean.class,
                                                           false);
         Date doomsday = new Date(Long.MAX_VALUE);
         int timer1 = timer.addNotification("one", "one", null, doomsday);
         int timer2 = timer.addNotification("two", "two", null, doomsday);
         Vector<Integer> idsOne = timer.getNotificationIDs("one");
         check("Vector<Integer> TimerMBean.getNotificationIDs",
               idsOne.equals(singletonList(timer1)));
         Vector<Integer> allIds = timer.getAllNotificationIDs();
         check("Vector<Integer> TimerMBean.getAllNotificationIDs",
               equalListContents(allIds,
                                 Arrays.asList(new Integer[]{timer1, timer2})));

         // ADD NEW TEST CASES ABOVE THIS COMMENT

         if (failures == 0)
             System.out.println("All tests passed");
         else {
             System.out.println("TEST FAILURES: " + failures);
             System.exit(1);
         }

         // DO NOT ADD NEW TEST CASES HERE, ADD THEM ABOVE THE PREVIOUS COMMENT
     }

     public static interface StupidMBean {
         public int getFive();
     }

     public static class Stupid implements StupidMBean {
         public int getFive() {
             return 5;
         }
     }

     public static class Module extends StandardMBean implements StupidMBean {
         public Module() throws NotCompliantMBeanException {
             super(StupidMBean.class);
         }

         public int getFive() {
             return 5;
         }
     }

     private static <E> List<E> singletonList(E value) {
         return Collections.singletonList(value);
     }

     private static <E> Set<E> singleton(E value) {
         return Collections.singleton(value);
     }

     private static <K,V> Map<K,V> singletonMap(K key, V value) {
         return Collections.singletonMap(key, value);
     }

     private static <E> List<E> checked(List<E> c, Class<E> type) {
         List<E> unchecked = new ArrayList<E>();
         List<E> checked = Collections.checkedList(unchecked, type);
         checked.addAll(c);
         return Collections.checkedList(c, type);
     }

     private static <E> Set<E> checked(Set<E> c, Class<E> type) {
         Set<E> unchecked = new HashSet<E>();
         Set<E> checked = Collections.checkedSet(unchecked, type);
         checked.addAll(c);
         return Collections.checkedSet(c, type);
     }

     private static <K,V> Map<K,V> checked(Map<K,V> m,
                                           Class<K> keyType,
                                           Class<V> valueType) {
         Map<K,V> unchecked = new HashMap<K,V>();
         Map<K,V> checked = Collections.checkedMap(unchecked, keyType, valueType);
         checked.putAll(m);
         return Collections.checkedMap(m, keyType, valueType);
     }

     /* The fact that we have to call this method is a clear signal that
      * the API says List where it means Set.
      */
     private static <E> boolean equalListContents(List<E> l1, List<E> l2) {
         return new HashSet<E>(l1).equals(new HashSet<E>(l2));
     }

     private static void check(String what, boolean cond) {
         if (cond)
             System.out.println("OK: " + what);
         else {
             System.out.println("FAILED: " + what);
             failures++;
         }
     }

     private static boolean sameSize(Set ... sets) {
         return Stream.of(sets).map(s -> s.size()).distinct().count() == 1;
     }
 }
	/*
	* Copyright (c) 2004, 2020, 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 4847959 6191402
	* @summary Test newly-generified APIs
	* @author Eamonn McManus
	*
	* @run clean GenericTest
	* @run build GenericTest
	* @run main GenericTest
	*/

	import java.lang.management.ManagementFactory;
	import java.lang.reflect.*;
	import java.util.*;
	import java.util.stream.Stream;
	import javax.management.*;
	import javax.management.openmbean.*;
	import javax.management.relation.*;
	import javax.management.timer.Timer;
	import javax.management.timer.TimerMBean;

	public class GenericTest {
	private static int failures;

	public static void main(String[] args) throws Exception {
	MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

	// Check we are really using the generified version
	boolean generic;
	Method findmbs = MBeanServerFactory.class.getMethod("findMBeanServer",
	String.class);
	Type findmbstype = findmbs.getGenericReturnType();
	if (!(findmbstype instanceof ParameterizedType)) {
	System.out.println("FAILURE: API NOT GENERIC!");
	System.out.println(" MBeanServerFactory.findMBeanServer -> " +
	findmbstype);
	failures++;
	generic = false;
	} else {
	System.out.println("OK: this API is generic");
	generic = true;
	}

	ArrayList<MBeanServer> mbsList1 =
	MBeanServerFactory.findMBeanServer(null);
	checked(mbsList1, MBeanServer.class);
	ArrayList mbsList2 = MBeanServerFactory.findMBeanServer(null);
	check("ArrayList<MBeanServer> findMBeanServer", mbsList1.size() == 1);
	check("ArrayList findMBeanServer", mbsList1.equals(mbsList2));

	boolean isSecondAttempt = false;
	Set<ObjectName> names1 = null;
	while (true) {
	names1 = checked(mbs.queryNames(null, null), ObjectName.class);
	Set names2 = mbs.queryNames(null, null);
	Set<ObjectName> names3 =
	checked(((MBeanServerConnection) mbs).queryNames(null, null),
	ObjectName.class);
	// If new MBean (e.g. Graal MBean) is registered while the test is running, names1,
	// names2, and names3 will have different sizes. Repeat the test in this case.
	if (sameSize(names1, names2, names3) \|\| isSecondAttempt) {
	check("Set<ObjectName> MBeanServer.queryNames", names1.size() >= 1);
	check("Set MBeanServer.queryNames", names2.size() >= 1);
	check("Set<ObjectName> MBeanServerConnection.queryNames",
	names3.size() >= 1);
	check("queryNames sets same",
	names1.equals(names2) && names2.equals(names3));
	break;
	}
	isSecondAttempt = true;
	System.out.println("queryNames sets have different size, retrying...");
	}

	isSecondAttempt = false;
	while (true) {
	Set<ObjectInstance> mbeans1 =
	checked(mbs.queryMBeans(null, null), ObjectInstance.class);
	Set mbeans2 = mbs.queryMBeans(null, null);
	Set<ObjectInstance> mbeans3 =
	checked(((MBeanServerConnection) mbs).queryMBeans(null, null),
	ObjectInstance.class);
	// If new MBean (e.g. Graal MBean) is registered while the test is running, mbeans1,
	// mbeans2, and mbeans3 will have different sizes. Repeat the test in this case.
	if (sameSize(mbeans1, mbeans2, mbeans3) \|\| isSecondAttempt) {
	check("Set<ObjectInstance> MBeanServer.queryMBeans",
	mbeans1.size() >= 1);
	check("Set MBeanServer.queryMBeans", mbeans2.size() >= 1);
	check("Set<ObjectInstance> MBeanServerConnection.queryMBeans",
	mbeans3.size() >= 1);
	check("queryMBeans sets same",
	mbeans1.equals(mbeans2) && mbeans2.equals(mbeans3));
	break;
	}
	isSecondAttempt = true;
	System.out.println("queryMBeans sets have different size, retrying...");
	}

	AttributeChangeNotificationFilter acnf =
	new AttributeChangeNotificationFilter();
	acnf.enableAttribute("foo");
	Vector<String> acnfs = acnf.getEnabledAttributes();
	checked(acnfs, String.class);
	check("Vector<String> AttributeChangeNotificationFilter.getEnabled" +
	"Attributes", acnfs.equals(Arrays.asList(new String[] {"foo"})));

	if (generic) {
	Attribute a = new Attribute("foo", "bar");
	AttributeList al1 = new AttributeList();
	al1.add(a);
	AttributeList al2 =
	new AttributeList(Arrays.asList(new Attribute[] {a}));
	check("new AttributeList(List<Attribute>)", al1.equals(al2));
	List<Attribute> al3 = checked(al1.asList(), Attribute.class);
	al3.remove(a);
	check("List<Attribute> AttributeList.asList()",
	al1.equals(al3) && al1.isEmpty());
	}

	List<ObjectName> namelist1 = new ArrayList<ObjectName>(names1);
	Role role = new Role("rolename", namelist1);
	List<ObjectName> namelist2 =
	checked(role.getRoleValue(), ObjectName.class);
	check("new Role(String,List<ObjectName>).getRoleValue() -> " +
	"List<ObjectName>", namelist1.equals(namelist2));

	RoleList rl1 = new RoleList();
	rl1.add(role);
	RoleList rl2 = new RoleList(Arrays.asList(new Role[] {role}));
	check("new RoleList(List<Role>)", rl1.equals(rl2));
	if (generic) {
	List<Role> rl3 = checked(rl1.asList(), Role.class);
	rl3.remove(role);
	check("List<Role> RoleList.asList()",
	rl1.equals(rl3) && rl1.isEmpty());
	}

	RoleUnresolved ru =
	new RoleUnresolved("rolename", namelist1,
	RoleStatus.LESS_THAN_MIN_ROLE_DEGREE);
	List<ObjectName> namelist3 =
	checked(ru.getRoleValue(), ObjectName.class);
	check("new RoleUnresolved(...List<ObjectName>...).getRoleValue() -> " +
	"List<ObjectName>", namelist1.equals(namelist3));

	RoleUnresolvedList rul1 = new RoleUnresolvedList();
	rul1.add(ru);
	RoleUnresolvedList rul2 =
	new RoleUnresolvedList(Arrays.asList(new RoleUnresolved[] {ru}));
	check("new RoleUnresolvedList(List<RoleUnresolved>", rul1.equals(rul2));
	if (generic) {
	List<RoleUnresolved> rul3 =
	checked(rul1.asList(), RoleUnresolved.class);
	rul3.remove(ru);
	check("List<RoleUnresolved> RoleUnresolvedList.asList()",
	rul1.equals(rul3) && rul1.isEmpty());
	}

	// This case basically just tests that we can compile this sort of thing
	OpenMBeanAttributeInfo ombai1 =
	new OpenMBeanAttributeInfoSupport("a", "a descr",
	SimpleType.INTEGER,
	true, true, false);
	CompositeType ct =
	new CompositeType("ct", "ct descr", new String[] {"item1"},
	new String[] {"item1 descr"},
	new OpenType[] {SimpleType.INTEGER});
	OpenMBeanAttributeInfo ombai2 =
	new OpenMBeanAttributeInfoSupport("a", "a descr",
	ct, true, true, false);
	TabularType tt =
	new TabularType("tt", "tt descr", ct, new String[] {"item1"});
	OpenMBeanAttributeInfo ombai3 =
	new OpenMBeanAttributeInfoSupport("a", "a descr",
	tt, true, true, false);
	ArrayType<String[][]> at =
	new ArrayType<String[][]>(2, SimpleType.STRING);
	OpenMBeanAttributeInfo ombai4 =
	new OpenMBeanAttributeInfoSupport("a", "a descr",
	at, true, true, false);
	OpenMBeanAttributeInfo ombai4a =
	new OpenMBeanAttributeInfoSupport("a", "a descr",
	(ArrayType) at,
	true, true, false);
	OpenMBeanAttributeInfo ombai5 =
	new OpenMBeanAttributeInfoSupport("a", "a descr",
	SimpleType.INTEGER,
	true, true, false,
	5, 1, 9);
	OpenMBeanAttributeInfo ombai6 =
	new OpenMBeanAttributeInfoSupport("a", "a descr",
	SimpleType.INTEGER,
	true, true, false,
	5, new Integer[] {1, 5});

	OpenMBeanInfo ombi =
	new OpenMBeanInfoSupport("a.a", "a.a descr",
	new OpenMBeanAttributeInfo[] {
	ombai1, ombai2, ombai3, ombai4,
	ombai5, ombai6,
	},
	null, null, null);

	Map<String,Integer> itemMap =
	checked(singletonMap("item1", 5),
	String.class, Integer.class);
	CompositeData cd =
	new CompositeDataSupport(ct, itemMap);
	check("CompositeDataSupport(CompositeType, Map<String,?>",
	cd.get("item1").equals(5));

	Set<String> ctkeys = checked(ct.keySet(), String.class);
	check("Set<String> CompositeType.keySet()",
	ctkeys.equals(singleton("item1")));

	List<String> ttindex = checked(tt.getIndexNames(), String.class);
	check("Set<String> TabularType.getIndexNames()",
	ttindex.equals(singletonList("item1")));

	TabularData td = new TabularDataSupport(tt);
	td.putAll(new CompositeData[] {cd});
	List<Integer> tdkey = checked(singletonList(5), Integer.class);
	Set<List<Integer>> tdkeys = checked(singleton(tdkey),
	(Class<List<Integer>>) tdkey.getClass());
	Collection<CompositeData> tdvalues = checked(singleton(cd),
	CompositeData.class);
	check("Set<List<?>> TabularDataSupport.keySet()",
	td.keySet().equals(tdkeys));
	check("Collection<CompositeData> TabularDataSupport.values()",
	td.values().iterator().next().equals(tdvalues.iterator().next()));

	ObjectName stupidName = new ObjectName("stupid:a=b");
	mbs.registerMBean(new Stupid(), stupidName);
	StupidMBean proxy =
	MBeanServerInvocationHandler.newProxyInstance(mbs,
	stupidName,
	StupidMBean.class,
	false);
	check("MBeanServerInvocationHandler.newProxyInstance",
	proxy.getFive() == 5);
	mbs.unregisterMBean(stupidName);

	mbs.registerMBean(new StandardMBean(new Stupid(), StupidMBean.class),
	stupidName);
	check("<T> StandardMBean(T impl, Class<T> intf)",
	proxy.getFive() == 5);

	// Following is based on the package.html for javax.management.relation
	// Create the Relation Service MBean
	ObjectName relSvcName = new ObjectName(":type=RelationService");
	RelationService relSvcObject = new RelationService(true);
	mbs.registerMBean(relSvcObject, relSvcName);

	// Create an MBean proxy for easier access to the Relation Service
	RelationServiceMBean relSvc =
	MBeanServerInvocationHandler.newProxyInstance(mbs, relSvcName,
	RelationServiceMBean.class,
	false);

	// Define the DependsOn relation type
	RoleInfo[] dependsOnRoles = {
	new RoleInfo("dependent", Module.class.getName()),
	new RoleInfo("dependedOn", Module.class.getName())
	};
	relSvc.createRelationType("DependsOn", dependsOnRoles);

	// Now define a relation instance "moduleA DependsOn moduleB"

	ObjectName moduleA = new ObjectName(":type=Module,name=A");
	ObjectName moduleB = new ObjectName(":type=Module,name=B");

	// Following two lines added to example:
	mbs.registerMBean(new Module(), moduleA);
	mbs.registerMBean(new Module(), moduleB);

	Role dependent = new Role("dependent", singletonList(moduleA));
	Role dependedOn = new Role("dependedOn", singletonList(moduleB));
	Role[] roleArray = {dependent, dependedOn};
	RoleList roles = new RoleList(Arrays.asList(roleArray));
	relSvc.createRelation("A-DependsOn-B", "DependsOn", roles);

	// Query the Relation Service to find what modules moduleA depends on
	Map<ObjectName,List<String>> dependentAMap =
	relSvc.findAssociatedMBeans(moduleA, "DependsOn", "dependent");
	Set<ObjectName> dependentASet = dependentAMap.keySet();
	dependentASet = checked(dependentASet, ObjectName.class);
	// Set of ObjectName containing moduleB
	check("Map<ObjectName,List<String>> RelationService.findAssociatedMBeans",
	dependentAMap.size() == 1 &&
	dependentASet.equals(singleton(moduleB)));

	Map<String,List<String>> refRels =
	relSvc.findReferencingRelations(moduleA, "DependsOn", "dependent");
	List<String> refRoles =
	checked(refRels.get("A-DependsOn-B"), String.class);
	check("Map<String,List<String>> RelationService.findReferencingRelations",
	refRoles.equals(singletonList("dependent")));

	List<String> relsOfType = relSvc.findRelationsOfType("DependsOn");
	relsOfType = checked(relsOfType, String.class);
	check("List<String> RelationService.findRelationsOfType",
	relsOfType.equals(singletonList("A-DependsOn-B")));

	List<String> allRelIds = relSvc.getAllRelationIds();
	allRelIds = checked(allRelIds, String.class);
	check("List<String> RelationService.getAllRelationIds()",
	allRelIds.equals(singletonList("A-DependsOn-B")));

	List<String> allRelTypes = relSvc.getAllRelationTypeNames();
	allRelTypes = checked(allRelTypes, String.class);
	check("List<String> RelationService.getAllRelationTypeNames",
	allRelTypes.equals(singletonList("DependsOn")));

	Map<ObjectName,List<String>> refdMBeans =
	relSvc.getReferencedMBeans("A-DependsOn-B");
	check("Map<ObjectName,List<String>> RelationService.getReferencedMBeans",
	refdMBeans.get(moduleA).equals(singletonList("dependent")) &&
	refdMBeans.get(moduleB).equals(singletonList("dependedOn")));

	List<ObjectName> roleContents =
	checked(relSvc.getRole("A-DependsOn-B", "dependent"),
	ObjectName.class);
	check("List<ObjectName> RelationService.getRole",
	roleContents.equals(singletonList(moduleA)));

	RoleInfo roleInfoDependent =
	relSvc.getRoleInfo("DependsOn", "dependent");
	RoleInfo roleInfoDependedOn =
	relSvc.getRoleInfo("DependsOn", "dependedOn");
	List<RoleInfo> expectedRoleInfos =
	Arrays.asList(new RoleInfo[] {roleInfoDependent, roleInfoDependedOn});
	List<RoleInfo> roleInfos =
	checked(relSvc.getRoleInfos("DependsOn"), RoleInfo.class);
	check("List<RoleInfo> RelationService.getRoleInfos",
	equalListContents(expectedRoleInfos, roleInfos));

	RelationType relType =
	new RelationTypeSupport("DependsOn", dependsOnRoles);
	List<RoleInfo> relTypeRoleInfos =
	checked(relType.getRoleInfos(), RoleInfo.class);
	// Since there's no RoleInfo.equals and since the RelationTypeSupport
	// constructor clones the RoleInfos passed to it, it's tricky to
	// test equality here so we check type and size and have done with it
	check("List<RoleInfo> RelationType.getRoleInfos",
	relTypeRoleInfos.size() == 2);

	MBeanServerNotificationFilter mbsnf =
	new MBeanServerNotificationFilter();
	mbsnf.enableObjectName(moduleA);
	check("Vector<ObjectName> MBeanServerNotificationFilter." +
	"getEnabledObjectNames",
	mbsnf.getEnabledObjectNames().equals(Arrays.asList(moduleA)));
	mbsnf.enableAllObjectNames();
	mbsnf.disableObjectName(moduleB);
	check("Vector<ObjectName> MBeanServerNotificationFilter." +
	"getDisabledObjectNames",
	mbsnf.getDisabledObjectNames().equals(Arrays.asList(moduleB)));

	RelationService unusedRelSvc = new RelationService(false);
	RelationNotification rn1 =
	new RelationNotification(RelationNotification.RELATION_MBEAN_REMOVAL,
	unusedRelSvc, 0L, 0L, "yo!",
	"A-DependsOn-B", "DependsOn", null,
	singletonList(moduleA));
	List<ObjectName> toUnreg =
	checked(rn1.getMBeansToUnregister(), ObjectName.class);
	check("List<ObjectName> RelationNotification.getMBeansToUnregister",
	toUnreg.equals(singletonList(moduleA)));

	RelationNotification rn2 =
	new RelationNotification(RelationNotification.RELATION_MBEAN_UPDATE,
	unusedRelSvc, 0L, 0L, "yo!",
	"A-DependsOn-B", "DependsOn", null,
	"dependent", singletonList(moduleA),
	singletonList(moduleB));
	check("List<ObjectName> RelationNotification.getOldRoleValue",
	checked(rn2.getOldRoleValue(), ObjectName.class)
	.equals(singletonList(moduleB)));
	check("List<ObjectName> RelationNotification.getNewRoleValue",
	checked(rn2.getNewRoleValue(), ObjectName.class)
	.equals(singletonList(moduleA)));

	ObjectName timerName = new ObjectName(":type=timer");
	mbs.registerMBean(new Timer(), timerName);
	TimerMBean timer =
	MBeanServerInvocationHandler.newProxyInstance(mbs,
	timerName,
	TimerMBean.class,
	false);
	Date doomsday = new Date(Long.MAX_VALUE);
	int timer1 = timer.addNotification("one", "one", null, doomsday);
	int timer2 = timer.addNotification("two", "two", null, doomsday);
	Vector<Integer> idsOne = timer.getNotificationIDs("one");
	check("Vector<Integer> TimerMBean.getNotificationIDs",
	idsOne.equals(singletonList(timer1)));
	Vector<Integer> allIds = timer.getAllNotificationIDs();
	check("Vector<Integer> TimerMBean.getAllNotificationIDs",
	equalListContents(allIds,
	Arrays.asList(new Integer[]{timer1, timer2})));

	// ADD NEW TEST CASES ABOVE THIS COMMENT

	if (failures == 0)
	System.out.println("All tests passed");
	else {
	System.out.println("TEST FAILURES: " + failures);
	System.exit(1);
	}

	// DO NOT ADD NEW TEST CASES HERE, ADD THEM ABOVE THE PREVIOUS COMMENT
	}

	public static interface StupidMBean {
	public int getFive();
	}

	public static class Stupid implements StupidMBean {
	public int getFive() {
	return 5;
	}
	}

	public static class Module extends StandardMBean implements StupidMBean {
	public Module() throws NotCompliantMBeanException {
	super(StupidMBean.class);
	}

	public int getFive() {
	return 5;
	}
	}

	private static <E> List<E> singletonList(E value) {
	return Collections.singletonList(value);
	}

	private static <E> Set<E> singleton(E value) {
	return Collections.singleton(value);
	}

	private static <K,V> Map<K,V> singletonMap(K key, V value) {
	return Collections.singletonMap(key, value);
	}

	private static <E> List<E> checked(List<E> c, Class<E> type) {
	List<E> unchecked = new ArrayList<E>();
	List<E> checked = Collections.checkedList(unchecked, type);
	checked.addAll(c);
	return Collections.checkedList(c, type);
	}

	private static <E> Set<E> checked(Set<E> c, Class<E> type) {
	Set<E> unchecked = new HashSet<E>();
	Set<E> checked = Collections.checkedSet(unchecked, type);
	checked.addAll(c);
	return Collections.checkedSet(c, type);
	}

	private static <K,V> Map<K,V> checked(Map<K,V> m,
	Class<K> keyType,
	Class<V> valueType) {
	Map<K,V> unchecked = new HashMap<K,V>();
	Map<K,V> checked = Collections.checkedMap(unchecked, keyType, valueType);
	checked.putAll(m);
	return Collections.checkedMap(m, keyType, valueType);
	}

	/* The fact that we have to call this method is a clear signal that
	* the API says List where it means Set.
	*/
	private static <E> boolean equalListContents(List<E> l1, List<E> l2) {
	return new HashSet<E>(l1).equals(new HashSet<E>(l2));
	}

	private static void check(String what, boolean cond) {
	if (cond)
	System.out.println("OK: " + what);
	else {
	System.out.println("FAILED: " + what);
	failures++;
	}
	}

	private static boolean sameSize(Set ... sets) {
	return Stream.of(sets).map(s -> s.size()).distinct().count() == 1;
	}
	}