1 /*

     2  * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @bug 8058865

    27  * @summary Test all MXBeans available by default on the platform

    28  * @author Olivier Lagneau

    29  * @modules java.management

    30  * @library /lib/testlibrary

    31  * @run main/othervm/timeout=300 -DDEBUG_STANDARD MXBeanInteropTest1

    32  */

    33 

    34 import java.util.Arrays;

    35 import java.util.Iterator;

    36 import java.util.Map;

    37 import java.util.Set;

    38 

    39 import java.lang.management.ClassLoadingMXBean;

    40 import java.lang.management.CompilationMXBean;

    41 import java.lang.management.GarbageCollectorMXBean;

    42 import java.lang.management.ManagementFactory;

    43 import java.lang.management.MemoryMXBean;

    44 import java.lang.management.MemoryManagerMXBean;

    45 import java.lang.management.MemoryPoolMXBean;

    46 import java.lang.management.OperatingSystemMXBean;

    47 import java.lang.management.RuntimeMXBean;

    48 import java.lang.management.ThreadMXBean;

    49 

    50 import javax.management.JMX;

    51 import javax.management.MBeanAttributeInfo;

    52 import javax.management.MBeanConstructorInfo;

    53 import javax.management.MBeanServer;

    54 import javax.management.MBeanServerFactory;

    55 import javax.management.MBeanInfo;

    56 import javax.management.MBeanNotificationInfo;

    57 import javax.management.MBeanOperationInfo;

    58 import javax.management.MBeanServerConnection;

    59 import javax.management.ObjectName;

    60 import javax.management.remote.JMXConnector;

    61 import javax.management.remote.JMXConnectorFactory;

    62 import javax.management.remote.JMXConnectorServer;

    63 import javax.management.remote.JMXConnectorServerFactory;

    64 import javax.management.remote.JMXServiceURL;

    65 

    66 public class MXBeanInteropTest1 {

    67 

    68     /*

    69      * First Debug properties and arguments are collect in expected

    70      * map  (argName, value) format, then calls original test's run method.

    71      */

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

    73 

    74         System.out.println("=================================================");

    75 

    76         // Parses parameters

    77         Utils.parseDebugProperties();

    78         Map<String, Object> map = Utils.parseParameters(args) ;

    79 

    80         // Run test

    81         MXBeanInteropTest1 test = new MXBeanInteropTest1();

    82         test.run(map);

    83 

    84     }

    85 

    86     public void run(Map<String, Object> args) {

    87 

    88         System.out.println("MXBeanInteropTest1::run: Start") ;

    89         int errorCount = 0 ;

    90 

    91         try {

    92             // JMX MbeanServer used inside single VM as if remote.

    93             // MBeanServer mbs = MBeanServerFactory.newMBeanServer();

    94             MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

    95 

    96             JMXServiceURL url = new JMXServiceURL("rmi", null, 0);

    97             JMXConnectorServer cs =

    98                 JMXConnectorServerFactory.newJMXConnectorServer(url, null, mbs);

    99             cs.start();

   100 

   101             JMXServiceURL addr = cs.getAddress();

   102             JMXConnector cc = JMXConnectorFactory.connect(addr);

   103             MBeanServerConnection mbsc = cc.getMBeanServerConnection();

   104 

   105             // Print out registered java.lang.management MXBeans found

   106             // in the remote jvm.

   107             printMBeans(mbsc) ;

   108 

   109             // For each possible kind of JDK 5 defined MXBean, we retrieve its

   110             // MBeanInfo and print it and we call all getters and print

   111             // their output.

   112             errorCount += doClassLoadingMXBeanTest(mbsc) ;

   113             errorCount += doMemoryMXBeanTest(mbsc) ;

   114             errorCount += doThreadMXBeanTest(mbsc) ;

   115             errorCount += doRuntimeMXBeanTest(mbsc) ;

   116             errorCount += doOperatingSystemMXBeanTest(mbsc) ;

   117             errorCount += doCompilationMXBeanTest(mbsc) ;

   118             errorCount += doGarbageCollectorMXBeanTest(mbsc) ;

   119             errorCount += doMemoryManagerMXBeanTest(mbsc) ;

   120             errorCount += doMemoryPoolMXBeanTest(mbsc) ;

   121 

   122             // Terminate the JMX Client

   123             cc.close();

   124 

   125         } catch(Exception e) {

   126             Utils.printThrowable(e, true) ;

   127             throw new RuntimeException(e);

   128         }

   129 

   130         if ( errorCount == 0 ) {

   131             System.out.println("MXBeanInteropTest1::run: Done without any error") ;

   132         } else {

   133             System.out.println("MXBeanInteropTest1::run: Done with "

   134                     + errorCount

   135                     + " error(s)") ;

   136             throw new RuntimeException("errorCount = " + errorCount);

   137         }

   138     }

   139 

   140     /**

   141      * Prints all MBeans of domain java.lang.

   142      * They are MBeans related to the JSR 174 that defines

   143      * package java.lang.management.

   144      */

   145     private static void printMBeans(MBeanServerConnection mbsc) throws Exception {

   146         ObjectName filterName = new ObjectName("java.lang:*");

   147         Set<ObjectName> set = mbsc.queryNames(filterName, null);

   148 

   149         if ( set.size() == 0 ) {

   150             throw new RuntimeException("(ERROR) No MBean found with filter "

   151                     + filterName);

   152         }

   153 

   154         System.out.println("---- MBeans found in domain java.lang :");

   155 

   156         for (Iterator<ObjectName> iter = set.iterator(); iter.hasNext(); ) {

   157             System.out.println(iter.next().toString());

   158         }

   159 

   160         System.out.println("\n") ;

   161     }

   162 

   163 

   164     private final int doClassLoadingMXBeanTest(MBeanServerConnection mbsc) {

   165         int errorCount = 0 ;

   166         System.out.println("---- ClassLoadingMXBean") ;

   167 

   168         try {

   169             ObjectName classLoadingName =

   170                     new ObjectName(ManagementFactory.CLASS_LOADING_MXBEAN_NAME) ;

   171             MBeanInfo mbInfo = mbsc.getMBeanInfo(classLoadingName);

   172             errorCount += checkNonEmpty(mbInfo);

   173             System.out.println("getMBeanInfo\t\t"

   174                     + mbInfo);

   175             ClassLoadingMXBean classLoading = null;

   176 

   177             classLoading = JMX.newMXBeanProxy(mbsc,

   178                     classLoadingName,

   179                     ClassLoadingMXBean.class) ;

   180             System.out.println("getLoadedClassCount\t\t"

   181                     + classLoading.getLoadedClassCount());

   182             System.out.println("getTotalLoadedClassCount\t\t"

   183                     + classLoading.getTotalLoadedClassCount());

   184             System.out.println("getUnloadedClassCount\t\t"

   185                     + classLoading.getUnloadedClassCount());

   186             System.out.println("isVerbose\t\t"

   187                     + classLoading.isVerbose());

   188 

   189             System.out.println("---- OK\n") ;

   190 

   191         } catch (Exception e) {

   192             Utils.printThrowable(e, true) ;

   193             errorCount++ ;

   194             System.out.println("---- ERROR\n") ;

   195         }

   196 

   197         return errorCount ;

   198     }

   199 

   200 

   201     private final int doMemoryMXBeanTest(MBeanServerConnection mbsc) {

   202         int errorCount = 0 ;

   203         System.out.println("---- MemoryMXBean") ;

   204 

   205         try {

   206             ObjectName memoryName =

   207                     new ObjectName(ManagementFactory.MEMORY_MXBEAN_NAME) ;

   208             MBeanInfo mbInfo = mbsc.getMBeanInfo(memoryName);

   209             errorCount += checkNonEmpty(mbInfo);

   210             System.out.println("getMBeanInfo\t\t"

   211                     + mbInfo);

   212             MemoryMXBean memory = null ;

   213 

   214             memory =

   215                     JMX.newMXBeanProxy(mbsc,

   216                     memoryName,

   217                     MemoryMXBean.class,

   218                     true) ;

   219             System.out.println("getMemoryHeapUsage\t\t"

   220                     + memory.getHeapMemoryUsage());

   221             System.out.println("getNonHeapMemoryHeapUsage\t\t"

   222                     + memory.getNonHeapMemoryUsage());

   223             System.out.println("getObjectPendingFinalizationCount\t\t"

   224                     + memory.getObjectPendingFinalizationCount());

   225             System.out.println("isVerbose\t\t"

   226                     + memory.isVerbose());

   227 

   228             System.out.println("---- OK\n") ;

   229 

   230         } catch (Exception e) {

   231             Utils.printThrowable(e, true) ;

   232             errorCount++ ;

   233             System.out.println("---- ERROR\n") ;

   234         }

   235 

   236         return errorCount ;

   237     }

   238 

   239 

   240     private final int doThreadMXBeanTest(MBeanServerConnection mbsc) {

   241         int errorCount = 0 ;

   242         System.out.println("---- ThreadMXBean") ;

   243 

   244         try {

   245             ObjectName threadName =

   246                     new ObjectName(ManagementFactory.THREAD_MXBEAN_NAME) ;

   247             MBeanInfo mbInfo = mbsc.getMBeanInfo(threadName);

   248             errorCount += checkNonEmpty(mbInfo);

   249             System.out.println("getMBeanInfo\t\t" + mbInfo);

   250             ThreadMXBean thread = null ;

   251 

   252             thread =

   253                     JMX.newMXBeanProxy(mbsc,

   254                     threadName,

   255                     ThreadMXBean.class) ;

   256             System.out.println("findMonitorDeadlockedThreads\t\t"

   257                     + thread.findMonitorDeadlockedThreads());

   258             long[] threadIDs = thread.getAllThreadIds() ;

   259             System.out.println("getAllThreadIds\t\t"

   260                     + threadIDs);

   261 

   262             for ( long threadID : threadIDs ) {

   263                 System.out.println("getThreadInfo long\t\t"

   264                         + thread.getThreadInfo(threadID));

   265                 System.out.println("getThreadInfo long, int\t\t"

   266                         + thread.getThreadInfo(threadID, 2));

   267             }

   268 

   269             System.out.println("getThreadInfo long[]\t\t"

   270                     + thread.getThreadInfo(threadIDs));

   271             System.out.println("getThreadInfo long[], int\t\t"

   272                     + thread.getThreadInfo(threadIDs, 2));

   273             System.out.println("getDaemonThreadCount\t\t"

   274                     + thread.getDaemonThreadCount());

   275             System.out.println("getPeakThreadCount\t\t"

   276                     + thread.getPeakThreadCount());

   277             System.out.println("getThreadCount\t\t"

   278                     + thread.getThreadCount());

   279             System.out.println("getTotalStartedThreadCount\t\t"

   280                     + thread.getTotalStartedThreadCount());

   281             boolean supported = thread.isThreadContentionMonitoringSupported() ;

   282             System.out.println("isThreadContentionMonitoringSupported\t\t"

   283                     + supported);

   284 

   285             if ( supported ) {

   286                 System.out.println("isThreadContentionMonitoringEnabled\t\t"

   287                         + thread.isThreadContentionMonitoringEnabled());

   288             }

   289 

   290             supported = thread.isThreadCpuTimeSupported() ;

   291             System.out.println("isThreadCpuTimeSupported\t\t"

   292                     + supported);

   293 

   294             if ( supported ) {

   295                 System.out.println("isThreadCpuTimeEnabled\t\t"

   296                         + thread.isThreadCpuTimeEnabled());

   297 

   298                 for (long id : threadIDs) {

   299                     System.out.println("getThreadCpuTime(" + id + ")\t\t"

   300                             + thread.getThreadCpuTime(id));

   301                     System.out.println("getThreadUserTime(" + id + ")\t\t"

   302                             + thread.getThreadUserTime(id));

   303                 }

   304             }

   305 

   306             supported = thread.isCurrentThreadCpuTimeSupported() ;

   307             System.out.println("isCurrentThreadCpuTimeSupported\t\t"

   308                     + supported);

   309 

   310             if ( supported ) {

   311                 System.out.println("getCurrentThreadCpuTime\t\t"

   312                         + thread.getCurrentThreadCpuTime());

   313                 System.out.println("getCurrentThreadUserTime\t\t"

   314                         + thread.getCurrentThreadUserTime());

   315             }

   316 

   317             thread.resetPeakThreadCount() ;

   318 

   319             System.out.println("---- OK\n") ;

   320         } catch (Exception e) {

   321             Utils.printThrowable(e, true) ;

   322             errorCount++ ;

   323             System.out.println("---- ERROR\n") ;

   324         }

   325 

   326         return errorCount ;

   327     }

   328 

   329 

   330     private final int doRuntimeMXBeanTest(MBeanServerConnection mbsc) {

   331         int errorCount = 0 ;

   332         System.out.println("---- RuntimeMXBean") ;

   333 

   334         try {

   335             ObjectName runtimeName =

   336                     new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME) ;

   337             MBeanInfo mbInfo = mbsc.getMBeanInfo(runtimeName);

   338             errorCount += checkNonEmpty(mbInfo);

   339             System.out.println("getMBeanInfo\t\t" + mbInfo);

   340             RuntimeMXBean runtime = null;

   341 

   342             runtime =

   343                     JMX.newMXBeanProxy(mbsc,

   344                     runtimeName,

   345                     RuntimeMXBean.class) ;

   346             System.out.println("getClassPath\t\t"

   347                     + runtime.getClassPath());

   348             System.out.println("getInputArguments\t\t"

   349                     + runtime.getInputArguments());

   350             System.out.println("getLibraryPath\t\t"

   351                     + runtime.getLibraryPath());

   352             System.out.println("getManagementSpecVersion\t\t"

   353                     + runtime.getManagementSpecVersion());

   354             System.out.println("getName\t\t"

   355                     + runtime.getName());

   356             System.out.println("getSpecName\t\t"

   357                     + runtime.getSpecName());

   358             System.out.println("getSpecVendor\t\t"

   359                     + runtime.getSpecVendor());

   360             System.out.println("getSpecVersion\t\t"

   361                     + runtime.getSpecVersion());

   362             System.out.println("getStartTime\t\t"

   363                     + runtime.getStartTime());

   364             System.out.println("getSystemProperties\t\t"

   365                     + runtime.getSystemProperties());

   366             System.out.println("getUptime\t\t"

   367                     + runtime.getUptime());

   368             System.out.println("getVmName\t\t"

   369                     + runtime.getVmName());

   370             System.out.println("getVmVendor\t\t"

   371                     + runtime.getVmVendor());

   372             System.out.println("getVmVersion\t\t"

   373                     + runtime.getVmVersion());

   374             boolean supported = runtime.isBootClassPathSupported() ;

   375             System.out.println("isBootClassPathSupported\t\t"

   376                     + supported);

   377 

   378             if ( supported ) {

   379                 System.out.println("getBootClassPath\t\t"

   380                         + runtime.getBootClassPath());

   381             }

   382 

   383             System.out.println("---- OK\n") ;

   384         } catch (Exception e) {

   385             Utils.printThrowable(e, true) ;

   386             errorCount++ ;

   387             System.out.println("---- ERROR\n") ;

   388         }

   389 

   390         return errorCount ;

   391     }

   392 

   393 

   394     private final int doOperatingSystemMXBeanTest(MBeanServerConnection mbsc) {

   395         int errorCount = 0 ;

   396         System.out.println("---- OperatingSystemMXBean") ;

   397 

   398         try {

   399             ObjectName operationName =

   400                     new ObjectName(ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME) ;

   401             MBeanInfo mbInfo = mbsc.getMBeanInfo(operationName);

   402             errorCount += checkNonEmpty(mbInfo);

   403             System.out.println("getMBeanInfo\t\t" + mbInfo);

   404             OperatingSystemMXBean operation = null ;

   405 

   406             operation =

   407                     JMX.newMXBeanProxy(mbsc,

   408                     operationName,

   409                     OperatingSystemMXBean.class) ;

   410             System.out.println("getArch\t\t"

   411                     + operation.getArch());

   412             System.out.println("getAvailableProcessors\t\t"

   413                     + operation.getAvailableProcessors());

   414             System.out.println("getName\t\t"

   415                     + operation.getName());

   416             System.out.println("getVersion\t\t"

   417                     + operation.getVersion());

   418 

   419             System.out.println("---- OK\n") ;

   420         } catch (Exception e) {

   421             Utils.printThrowable(e, true) ;

   422             errorCount++ ;

   423             System.out.println("---- ERROR\n") ;

   424         }

   425 

   426         return errorCount ;

   427     }

   428 

   429 

   430     private final int doCompilationMXBeanTest(MBeanServerConnection mbsc) {

   431         int errorCount = 0 ;

   432         System.out.println("---- CompilationMXBean") ;

   433 

   434         try {

   435             ObjectName compilationName =

   436                     new ObjectName(ManagementFactory.COMPILATION_MXBEAN_NAME);

   437 

   438             if ( mbsc.isRegistered(compilationName) ) {

   439                 MBeanInfo mbInfo = mbsc.getMBeanInfo(compilationName);

   440                 errorCount += checkNonEmpty(mbInfo);

   441                 System.out.println("getMBeanInfo\t\t" + mbInfo);

   442                 CompilationMXBean compilation = null ;

   443 

   444                 compilation =

   445                         JMX.newMXBeanProxy(mbsc,

   446                         compilationName,

   447                         CompilationMXBean.class) ;

   448                 System.out.println("getName\t\t"

   449                         + compilation.getName());

   450                 boolean supported =

   451                         compilation.isCompilationTimeMonitoringSupported() ;

   452                 System.out.println("isCompilationTimeMonitoringSupported\t\t"

   453                         + supported);

   454 

   455                 if ( supported ) {

   456                     System.out.println("getTotalCompilationTime\t\t"

   457                             + compilation.getTotalCompilationTime());

   458                 }

   459             }

   460 

   461             System.out.println("---- OK\n") ;

   462         } catch (Exception e) {

   463             Utils.printThrowable(e, true) ;

   464             errorCount++ ;

   465             System.out.println("---- ERROR\n") ;

   466         }

   467 

   468         return errorCount ;

   469     }

   470 

   471 

   472     private final int doGarbageCollectorMXBeanTest(MBeanServerConnection mbsc) {

   473         int errorCount = 0 ;

   474         System.out.println("---- GarbageCollectorMXBean") ;

   475 

   476         try {

   477             ObjectName filterName =

   478                     new ObjectName(ManagementFactory.GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE

   479                     + ",*");

   480             Set<ObjectName> onSet = mbsc.queryNames(filterName, null);

   481 

   482             for (Iterator<ObjectName> iter = onSet.iterator(); iter.hasNext(); ) {

   483                 ObjectName garbageName = iter.next() ;

   484                 System.out.println("-------- " + garbageName) ;

   485                 MBeanInfo mbInfo = mbsc.getMBeanInfo(garbageName);

   486                 errorCount += checkNonEmpty(mbInfo);

   487                 System.out.println("getMBeanInfo\t\t" + mbInfo);

   488                 GarbageCollectorMXBean garbage = null ;

   489 

   490                 garbage =

   491                         JMX.newMXBeanProxy(mbsc,

   492                         garbageName,

   493                         GarbageCollectorMXBean.class) ;

   494                 System.out.println("getCollectionCount\t\t"

   495                         + garbage.getCollectionCount());

   496                 System.out.println("getCollectionTime\t\t"

   497                         + garbage.getCollectionTime());

   498             }

   499 

   500             System.out.println("---- OK\n") ;

   501         } catch (Exception e) {

   502             Utils.printThrowable(e, true) ;

   503             errorCount++ ;

   504             System.out.println("---- ERROR\n") ;

   505         }

   506 

   507         return errorCount ;

   508     }

   509 

   510 

   511     private final int doMemoryManagerMXBeanTest(MBeanServerConnection mbsc) {

   512         int errorCount = 0 ;

   513         System.out.println("---- MemoryManagerMXBean") ;

   514 

   515         try {

   516             ObjectName filterName =

   517                     new ObjectName(ManagementFactory.MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE

   518                     + ",*");

   519             Set<ObjectName> onSet = mbsc.queryNames(filterName, null);

   520 

   521             for (Iterator<ObjectName> iter = onSet.iterator(); iter.hasNext(); ) {

   522                 ObjectName memoryManagerName = iter.next() ;

   523                 System.out.println("-------- " + memoryManagerName) ;

   524                 MBeanInfo mbInfo = mbsc.getMBeanInfo(memoryManagerName);

   525                 System.out.println("getMBeanInfo\t\t" + mbInfo);

   526                 errorCount += checkNonEmpty(mbInfo);

   527                 MemoryManagerMXBean memoryManager = null;

   528 

   529                 memoryManager =

   530                         JMX.newMXBeanProxy(mbsc,

   531                         memoryManagerName,

   532                         MemoryManagerMXBean.class) ;

   533                 System.out.println("getMemoryPoolNames\t\t"

   534                         + Arrays.deepToString(memoryManager.getMemoryPoolNames()));

   535                 System.out.println("getName\t\t"

   536                         + memoryManager.getName());

   537                 System.out.println("isValid\t\t"

   538                         + memoryManager.isValid());

   539             }

   540 

   541             System.out.println("---- OK\n") ;

   542         } catch (Exception e) {

   543             Utils.printThrowable(e, true) ;

   544             errorCount++ ;

   545             System.out.println("---- ERROR\n") ;

   546         }

   547 

   548         return errorCount ;

   549     }

   550 

   551 

   552     private final int doMemoryPoolMXBeanTest(MBeanServerConnection mbsc) {

   553         int errorCount = 0 ;

   554         System.out.println("---- MemoryPoolMXBean") ;

   555 

   556         try {

   557             ObjectName filterName =

   558                     new ObjectName(ManagementFactory.MEMORY_POOL_MXBEAN_DOMAIN_TYPE

   559                     + ",*");

   560             Set<ObjectName> onSet = mbsc.queryNames(filterName, null);

   561 

   562             for (Iterator<ObjectName> iter = onSet.iterator(); iter.hasNext(); ) {

   563                 ObjectName memoryPoolName = iter.next() ;

   564                 System.out.println("-------- " + memoryPoolName) ;

   565                 MBeanInfo mbInfo = mbsc.getMBeanInfo(memoryPoolName);

   566                 errorCount += checkNonEmpty(mbInfo);

   567                 System.out.println("getMBeanInfo\t\t" + mbInfo);

   568                 MemoryPoolMXBean memoryPool = null;

   569 

   570                 memoryPool =

   571                         JMX.newMXBeanProxy(mbsc,

   572                         memoryPoolName,

   573                         MemoryPoolMXBean.class,

   574                         true) ;

   575                 System.out.println("getCollectionUsage\t\t"

   576                         + memoryPool.getCollectionUsage());

   577                 System.out.println("getMemoryManagerNames\t\t"

   578                         + Arrays.deepToString(memoryPool.getMemoryManagerNames()));

   579                 System.out.println("getName\t\t"

   580                         + memoryPool.getName());

   581                 System.out.println("getPeakUsage\t\t"

   582                         + memoryPool.getPeakUsage());

   583                 System.out.println("getType\t\t"

   584                         + memoryPool.getType());

   585                 System.out.println("getUsage\t\t"

   586                         + memoryPool.getUsage());

   587                 System.out.println("isValid\t\t"

   588                         + memoryPool.isValid());

   589                 boolean supported = memoryPool.isUsageThresholdSupported() ;

   590                 System.out.println("isUsageThresholdSupported\t\t"

   591                         + supported);

   592 

   593                 if ( supported ) {

   594                     System.out.println("getUsageThreshold\t\t"

   595                             + memoryPool.getUsageThreshold());

   596                     System.out.println("isUsageThresholdExceeded\t\t"

   597                             + memoryPool.isUsageThresholdExceeded());

   598                     System.out.println("getUsageThresholdCount\t\t"

   599                             + memoryPool.getUsageThresholdCount());

   600                 }

   601 

   602                 supported = memoryPool.isCollectionUsageThresholdSupported() ;

   603                 System.out.println("isCollectionUsageThresholdSupported\t\t"

   604                         + supported);

   605 

   606                 if ( supported ) {

   607                     System.out.println("getCollectionUsageThreshold\t\t"

   608                             + memoryPool.getCollectionUsageThreshold());

   609                     System.out.println("getCollectionUsageThresholdCount\t\t"

   610                             + memoryPool.getCollectionUsageThresholdCount());

   611                     System.out.println("isCollectionUsageThresholdExceeded\t\t"

   612                             + memoryPool.isCollectionUsageThresholdExceeded());

   613                 }

   614 

   615                 memoryPool.resetPeakUsage();

   616             }

   617 

   618             System.out.println("---- OK\n") ;

   619         } catch (Exception e) {

   620             Utils.printThrowable(e, true) ;

   621             errorCount++ ;

   622             System.out.println("---- ERROR\n") ;

   623         }

   624 

   625         return errorCount ;

   626     }

   627 

   628 

   629     private int checkNonEmpty(MBeanInfo mbi) {

   630         if ( mbi.toString().length() == 0 ) {

   631             System.out.println("(ERROR) MBeanInfo is empty !");

   632             return 1;

   633         } else {

   634             return 0;

   635         }

   636     }

   637 

   638 }