--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/javax/management/monitor/DerivedGaugeMonitorTest.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) 2008, 2015, 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 6683213
+ * @summary Test that the initial derived gauge is (Integer)0
+ * @author Daniel Fuchs
+ *
+ * @run clean DerivedGaugeMonitorTest
+ * @run build DerivedGaugeMonitorTest
+ * @run main DerivedGaugeMonitorTest
+ */
+
+import java.io.Serializable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import javax.management.MBeanServer;
+import javax.management.MBeanServerFactory;
+import javax.management.ObjectName;
+import javax.management.monitor.CounterMonitor;
+import javax.management.monitor.GaugeMonitor;
+
+public class DerivedGaugeMonitorTest {
+
+ public static interface Things {
+ public long getALong();
+ public int getAnInt();
+ public double getADouble();
+ public short getAShort();
+ public byte getAByte();
+ public float getAFloat();
+ }
+ public static interface MyMBean extends Things {
+ public Things getAThing();
+ }
+
+ public static class MyThings implements Things, Serializable {
+ private static final long serialVersionUID = -4333982919572564126L;
+
+ private volatile long along = 0;
+ private volatile int anint = 0;
+ private volatile short ashort = 0;
+ private volatile byte abyte = 0;
+ private volatile float afloat = 0;
+ private volatile double adouble = 0;
+
+ private volatile transient boolean mutable;
+
+ public MyThings() {
+ this(false);
+ }
+
+ protected MyThings(boolean mutable) {
+ this.mutable=mutable;
+ }
+
+ public long getALong() {
+ return mutable?along++:along;
+ }
+
+ public int getAnInt() {
+ return mutable?anint++:anint;
+ }
+
+ public double getADouble() {
+ return mutable?adouble++:adouble;
+ }
+
+ public short getAShort() {
+ return mutable?ashort++:ashort;
+ }
+
+ public byte getAByte() {
+ return mutable?abyte++:abyte;
+ }
+
+ public float getAFloat() {
+ return mutable?afloat++:afloat;
+ }
+
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ final MyThings other = (MyThings)super.clone();
+ other.mutable=false;
+ return other;
+ }
+ }
+
+ public static class My implements MyMBean {
+
+ public final CountDownLatch cdl = new CountDownLatch(6);
+
+ private final MyThings things = new MyThings(true);
+ private volatile int count = 0;
+
+ public Things getAThing() {
+ count++;
+ cdl.countDown();
+ try {
+ return (Things) things.clone();
+ } catch (CloneNotSupportedException ex) {
+ return null;
+ }
+ }
+
+ public long getALong() {
+ count++;
+ cdl.countDown();
+ return things.getALong();
+ }
+
+ public int getAnInt() {
+ count++;
+ cdl.countDown();
+ return things.getAnInt();
+ }
+
+ public double getADouble() {
+ count++;
+ cdl.countDown();
+ return things.getADouble();
+ }
+
+ public short getAShort() {
+ count++;
+ cdl.countDown();
+ return things.getAShort();
+ }
+
+ public byte getAByte() {
+ count++;
+ cdl.countDown();
+ return things.getAByte();
+ }
+
+ public float getAFloat() {
+ count++;
+ cdl.countDown();
+ return things.getAFloat();
+ }
+
+ }
+
+
+ public static String[] attributes = {
+ "AByte","AShort","AnInt","ALong","AFloat","ADouble"
+ };
+ public static String[] things = {
+ "AThing.AByte","AThing.AShort","AThing.AnInt","AThing.ALong",
+ "AThing.AFloat","AThing.ADouble"
+ };
+
+ public static void check(String attr, MBeanServer server, ObjectName mon,
+ ObjectName mbean) throws Exception {
+ final Object obj = server.getAttribute(mon, "DerivedGauge");
+ check(attr,server,mon,mbean,obj);
+ }
+
+ public static void check(String attr, MBeanServer server, ObjectName mon,
+ ObjectName mbean, Object obj) throws Exception {
+ if (obj == null)
+ throw new Exception("Derived gauge for: " + attr +
+ " ["+mon+", "+mbean+"] is null!");
+ if (!Integer.valueOf(0).equals(obj))
+ throw new Exception("Derived gauge for: " + attr +
+ " ["+mon+", "+mbean+"] is "+obj);
+ }
+
+ public static void check(String attr, MBeanServer server, ObjectName mon,
+ ObjectName mbean, long start) throws Exception {
+ final Object obj = server.getAttribute(mon, "DerivedGauge");
+ final long now = System.currentTimeMillis();
+ final long gran = (Long)server.getAttribute(mon, "GranularityPeriod");
+ if (now > start +2*gran) {
+ throw new Exception(attr+": Can't verify test case: " +
+ "granularity period expired!");
+ }
+ check(attr,server,mon,mbean,obj);
+ }
+
+ public static void test(String attr) throws Exception {
+ System.err.println("Testing "+ attr);
+ final MBeanServer server = MBeanServerFactory.createMBeanServer();
+ final ObjectName mbean = new ObjectName("ugly:type=cr.p");
+ final My my = new My();
+ final GaugeMonitor mon2 = new GaugeMonitor();
+ final ObjectName mon2n = new ObjectName("mon1:type=GaugeMonitor");
+ final CounterMonitor mon1 = new CounterMonitor();
+ final ObjectName mon1n = new ObjectName("mon2:type=CounterMonitor");
+
+ server.registerMBean(my, mbean);
+ server.registerMBean(mon1, mon1n);
+ server.registerMBean(mon2, mon2n);
+
+ mon1.addObservedObject(mbean);
+ mon1.setGranularityPeriod(60000); // 60 sec...
+ mon1.setObservedAttribute(attr);
+ mon1.setDifferenceMode(true);
+ check(attr,server,mon1n,mbean);
+
+ mon2.addObservedObject(mbean);
+ mon2.setGranularityPeriod(60000); // 60 sec...
+ mon2.setObservedAttribute(attr);
+ mon2.setDifferenceMode(true);
+ check(attr,server,mon2n,mbean);
+
+ final long approxStart = System.currentTimeMillis();
+ mon1.start();
+ mon2.start();
+
+ try {
+ check(attr,server,mon1n,mbean,approxStart);
+ check(attr,server,mon2n,mbean,approxStart);
+ check(attr,server,mon1n,mbean,approxStart);
+ check(attr,server,mon2n,mbean,approxStart);
+
+
+ mon1.setGranularityPeriod(5);
+ mon2.setGranularityPeriod(5);
+
+ my.cdl.await(1000, TimeUnit.MILLISECONDS);
+ if (my.cdl.getCount() > 0)
+ throw new Exception(attr+": Count down not reached!");
+
+ // just check that we don't get an exception now...
+ System.err.println(attr+": [" + mon1n+
+ "] DerivedGauge is now "+
+ server.getAttribute(mon1n, "DerivedGauge"));
+ System.err.println(attr+": [" + mon2n+
+ "] DerivedGauge is now "+
+ server.getAttribute(mon2n, "DerivedGauge"));
+ } finally {
+ try {mon1.stop();} catch (Exception x) {}
+ try {mon2.stop();} catch (Exception x) {}
+ }
+ }
+
+
+
+
+ public static void main(String[] args) throws Exception {
+ for (String attr:attributes) {
+ test(attr);
+ }
+ for (String attr:things) {
+ test(attr);
+ }
+ }
+
+}