/*

 * 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 QueryDottedAttrTest

 * @bug 6602310

 * @summary Test that Query.attr can understand a.b etc.

 * @author Eamonn McManus

 */

import java.beans.ConstructorProperties;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.util.Collections;

import java.util.Set;

import javax.management.AttributeNotFoundException;

import javax.management.MBeanException;

import javax.management.MBeanServer;

import javax.management.MBeanServerFactory;

import javax.management.ObjectName;

import javax.management.Query;

import javax.management.QueryExp;

import javax.management.ReflectionException;

import javax.management.StandardMBean;

public class QueryDottedAttrTest {

    public static class Complex {

        private final double re, im;

        @ConstructorProperties({"real", "imaginary"})

        public Complex(double re, double im) {

            this.re = re;

            this.im = im;

        }

        public double getRe() {

            return re;

        }

        public double getIm() {

            return im;

        }

    }

    public static interface Intf {

        Complex getComplex();

        int[] getIntArray();

        String[] getStringArray();

    }

    public static class Impl implements Intf {

        public Complex getComplex() {

            return new Complex(1.0, 1.0);

        }

        public int[] getIntArray() {

            return new int[] {1, 2, 3};

        }

        public String[] getStringArray() {

            return new String[] {"one", "two", "three"};

        }

    }

    public static interface TestMBean extends Intf {}

    public static class Test extends Impl implements TestMBean {}

    public static interface TestMXBean extends Intf {}

    public static class TestMX extends Impl implements TestMXBean {}

    public static class AttrWithDot extends StandardMBean {

        public <T> AttrWithDot(Object impl, Class<T> intf) {

            super(intf.cast(impl), intf, (intf == TestMXBean.class));

        }

        public Object getAttribute(String attribute)

        throws AttributeNotFoundException, MBeanException, ReflectionException {

            if (attribute.equals("Complex.re"))

                return 2.0;

            else

                return super.getAttribute(attribute);

        }

    }

    private static final boolean[] booleans = {false, true};

    private static final QueryExp[] alwaysTrueQueries = {

        Query.eq(Query.attr("IntArray.length"), Query.value(3)),

        Query.eq(Query.attr("StringArray.length"), Query.value(3)),

        Query.eq(Query.attr("Complex.im"), Query.value(1.0)),

    };

    private static final QueryExp[] alwaysFalseQueries = {

        Query.eq(Query.attr("IntArray.length"), Query.value("3")),

        Query.eq(Query.attr("IntArray.length"), Query.value(2)),

        Query.eq(Query.attr("Complex.im"), Query.value(-1.0)),

        Query.eq(Query.attr("Complex.xxx"), Query.value(0)),

    };

    private static final QueryExp[] attrWithDotTrueQueries = {

        Query.eq(Query.attr("Complex.re"), Query.value(2.0)),

    };

    private static final QueryExp[] attrWithDotFalseQueries = {

        Query.eq(Query.attr("Complex.re"), Query.value(1.0)),

    };

    private static String failure;

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

        ObjectName name = new ObjectName("a:b=c");

        for (boolean attrWithDot : booleans) {

            for (boolean mx : booleans) {

                String what =

                        (mx ? "MXBean" : "Standard MBean") +

                        (attrWithDot ? " having attribute with dot in its name" : "");

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

                Class<?> intf = mx ? TestMXBean.class : TestMBean.class;

                Object impl = mx ? new TestMX() : new Test();

                if (attrWithDot)

                    impl = new AttrWithDot(impl, intf);

                MBeanServer mbs = MBeanServerFactory.newMBeanServer();

                mbs.registerMBean(impl, name);

                boolean ismx = "true".equals(

                        mbs.getMBeanInfo(name).getDescriptor().getFieldValue("mxbean"));

                if (mx != ismx)

                    fail("MBean should " + (mx ? "" : "not ") + "be MXBean");

                test(mbs, name, alwaysTrueQueries, true);

                test(mbs, name, alwaysFalseQueries, false);

                test(mbs, name, attrWithDotTrueQueries, attrWithDot);

                test(mbs, name, attrWithDotFalseQueries, !attrWithDot);

            }

        }

        if (failure != null)

            throw new Exception("TEST FAILED: " + failure);

    }

    private static void test(

            MBeanServer mbs, ObjectName name, QueryExp[] queries, boolean expect)

            throws Exception {

        for (QueryExp query : queries) {

            // Serialize and deserialize the query to ensure that its

            // serialization is correct

            ByteArrayOutputStream bout = new ByteArrayOutputStream();

            ObjectOutputStream oout = new ObjectOutputStream(bout);

            oout.writeObject(query);

            oout.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());

            ObjectInputStream oin = new ObjectInputStream(bin);

            query = (QueryExp) oin.readObject();

            Set<ObjectName> names = mbs.queryNames(null, query);

            if (names.isEmpty()) {

                if (expect)

                    fail("Query is false but should be true: " + query);

            } else if (names.equals(Collections.singleton(name))) {

                if (!expect)

                    fail("Query is true but should be false: " + query);

            } else {

                fail("Query returned unexpected set: " + names);

            }

        }

    }

    private static void fail(String msg) {

        failure = msg;

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

    }

}