LeadingSeparatorsTest.java

/*
 * Copyright 2008 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */
/*
 * @test LeadingSeparatorsTest.java
 * @summary Test that the semantics of a leading // in ObjectName is respected.
 * @author Daniel Fuchs
 * @bug 5072476
 * @run clean LeadingSeparatorsTest Wombat WombatMBean
 * @compile -XDignore.symbol.file=true  LeadingSeparatorsTest.java
 * @run build LeadingSeparatorsTest Wombat WombatMBean
 * @run main LeadingSeparatorsTest
 */

import java.lang.management.ManagementFactory;
import java.util.Arrays;
import java.util.Set;
import java.util.HashSet;
import java.util.logging.Logger;
import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;
import javax.management.namespace.JMXNamespaces;
import javax.management.namespace.JMXRemoteNamespace;
import javax.management.namespace.JMXNamespace;
import javax.management.remote.JMXConnectorServer;
import javax.management.remote.JMXConnectorServerFactory;
import javax.management.remote.JMXServiceURL;

/**
 * Class LeadingSeparatorsTest
 * @author Sun Microsystems, 2005 - All rights reserved.
 */
public class LeadingSeparatorsTest {

    /**
     * A logger for this class.
     **/
    private static final Logger LOG =
            Logger.getLogger(LeadingSeparatorsTest.class.getName());

    /** Creates a new instance of NullObjectNameTest */
    public LeadingSeparatorsTest() {
    }

    public static interface MyWombatMBean extends WombatMBean {
        public Set<ObjectName> untrue(ObjectName pat) throws Exception;
    }
    public static class MyWombat
            extends Wombat implements MyWombatMBean {
        public MyWombat() throws NotCompliantMBeanException {
            super(MyWombatMBean.class);
        }

        public Set<ObjectName> untrue(ObjectName pat) throws Exception {
            final Set<ObjectName> res=listMatching(pat.withDomain("*"));
            final Set<ObjectName> untrue = new HashSet<ObjectName>();
            for (ObjectName a:res) {
                untrue.add(a.withDomain(pat.getDomain()+"//"+a.getDomain()));
            }
            return untrue;
        }
    }

    static String failure=null;

    public static void testRegister() throws Exception {
        final MBeanServer top = ManagementFactory.getPlatformMBeanServer();
        final MBeanServer sub = MBeanServerFactory.createMBeanServer();
        final JMXServiceURL url = new JMXServiceURL("rmi",null,0);
        final JMXConnectorServer srv =
                JMXConnectorServerFactory.newJMXConnectorServer(url,null,sub);
        srv.start();

        try {

            // Create a namespace rmi// that points to 'sub' and flows through
            // a JMXRemoteNamespace connected to 'srv'
            // The namespace rmi// will accept createMBean, but not registerMBean.
            //
            final JMXRemoteNamespace rmiHandler = JMXRemoteNamespace.
                    newJMXRemoteNamespace(srv.getAddress(),null);
            top.registerMBean(rmiHandler,
                    JMXNamespaces.getNamespaceObjectName("rmi"));
            top.invoke(JMXNamespaces.getNamespaceObjectName("rmi"),
                    "connect", null, null);

            // Create a namespace direct// that points to 'sub' and flows
            // through a direct reference to 'sub'.
            // The namespace direct// will accept createMBean, and registerMBean.
            //
            final JMXNamespace directHandler = new JMXNamespace(sub);
            top.registerMBean(directHandler,
                    JMXNamespaces.getNamespaceObjectName("direct"));

            final ObjectName n1 = new ObjectName("//direct//w:type=Wombat");
            final ObjectName n2 = new ObjectName("direct//w:type=Wombat");
            final ObjectName n3 = new ObjectName("//rmi//w:type=Wombat");
            final ObjectName n4 = new ObjectName("rmi//w:type=Wombat");

            // register wombat using an object name with a leading //
            final Object     obj = new MyWombat();
            // check that returned object name doesn't have the leading //
            assertEquals(n2,top.registerMBean(obj, n1).getObjectName());
            System.out.println(n1+" registered");

            // check that the registered Wombat can be accessed with all its
            // names.
            System.out.println(n2+" mood is: "+top.getAttribute(n2, "Mood"));
            System.out.println(n1+" mood is: "+top.getAttribute(n1, "Mood"));
            System.out.println(n4+" mood is: "+top.getAttribute(n4, "Mood"));
            System.out.println(n3+" mood is: "+top.getAttribute(n3, "Mood"));

            // call listMatching. The result should not contain any prefix.
            final Set<ObjectName> res = (Set<ObjectName>)
                    top.invoke(n3, "listMatching",
                    // remove rmi// from rmi//*:*
                    JMXNamespaces.deepReplaceHeadNamespace(
                    new Object[] {ObjectName.WILDCARD.withDomain("rmi//*")},
                    "rmi", ""), new String[] {ObjectName.class.getName()});

            // add rmi// prefix to all names in res.
            final Set<ObjectName> res1 =
                   JMXNamespaces.deepReplaceHeadNamespace(res, "", "rmi");
            System.out.println("got: "+res1);

            // compute expected result
            final Set<ObjectName> res2 = sub.queryNames(null,null);
            final Set<ObjectName> res3 = new HashSet<ObjectName>();
            for (ObjectName o:res2) {
               res3.add(o.withDomain("rmi//"+o.getDomain()));
            }
            System.out.println("expected: "+res3);
            assertEquals(res1, res3);

            // invoke "untrue(//niark//niark:*)"
            // should return a set were all ObjectNames begin with
            // //niark//niark//
            //
            final Set<ObjectName> res4 = (Set<ObjectName>)
                    top.invoke(n3, "untrue",
                    // remove niark//niark : should remove nothing since
                    // our ObjectName begins with a leading //
                    JMXNamespaces.deepReplaceHeadNamespace(
                    new Object[] {
                       ObjectName.WILDCARD.withDomain("//niark//niark")},
                    "niark//niark", ""),
                    new String[] {ObjectName.class.getName()});
            System.out.println("got: "+res4);

            // add rmi// should add nothing since the returned names have a
            // leading //
            //
            final Set<ObjectName> res5 =
                   JMXNamespaces.deepReplaceHeadNamespace(res4, "", "rmi");
            System.out.println("got#2: "+res5);

            // compute expected result
            final Set<ObjectName> res6 = new HashSet<ObjectName>();
            for (ObjectName o:res2) {
               res6.add(o.withDomain("//niark//niark//"+o.getDomain()));
            }
            System.out.println("expected: "+res6);

            // both res4 and res5 should be equals to the expected result.
            assertEquals(res4, res6);
            assertEquals(res5, res6);

        } finally {
            srv.stop();
        }

        if (failure != null)
            throw new Exception(failure);


    }
    private static void assertEquals(Object x, Object y) {
        if (!equal(x, y))
            failed("expected " + string(x) + "; got " + string(y));
    }

    private static boolean equal(Object x, Object y) {
        if (x == y)
            return true;
        if (x == null || y == null)
            return false;
        if (x.getClass().isArray())
            return Arrays.deepEquals(new Object[] {x}, new Object[] {y});
        return x.equals(y);
    }

    private static String string(Object x) {
        String s = Arrays.deepToString(new Object[] {x});
        return s.substring(1, s.length() - 1);
    }


    private static void failed(String why) {
        failure = why;
        new Throwable("FAILED: " + why).printStackTrace(System.out);
    }

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