/*
 * Copyright 2007-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 QueryNotifFilterTest
 * @bug 6610917
 * @summary Test the QueryNotificationFilter class
 * @author Eamonn McManus
 */

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.management.Attribute;
import javax.management.AttributeChangeNotification;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanInfo;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.Notification;
import javax.management.NotificationFilter;
import javax.management.ObjectInstance;
import javax.management.ObjectName;
import javax.management.Query;
import javax.management.QueryEval;
import javax.management.QueryExp;
import javax.management.QueryNotificationFilter;

public class QueryNotifFilterTest {
    private static class Case {
        final Notification notif;
        final QueryExp query;
        final boolean expect;
        final Class<? extends Notification> notifClass;
        Case(Notification notif, String query, boolean expect) {
            this(notif, query, notif.getClass(), expect);
        }
        Case(Notification notif, String query,
                Class<? extends Notification> notifClass, boolean expect) {
            this(notif, Query.fromString(query), notifClass, expect);
        }
        Case(Notification notif, QueryExp query, boolean expect) {
            this(notif, query, notif.getClass(), expect);
        }
        Case(Notification notif, QueryExp query,
                Class<? extends Notification> notifClass, boolean expect) {
            this.notif = notif;
            this.query = query;
            this.expect = expect;
            this.notifClass = notifClass;
        }
    }

    /* In principle users can create their own implementations of QueryExp
     * and use them with QueryNotificationFilter.  If they do so, then
     * they can call any MBeanServer method.  Not all of those methods
     * will work with the special MBeanServer we concoct to analyze a
     * Notification, but some will, including some that are not called
     * by the standard queries.  So we check each of those cases too.
     */
    private static class ExoticCase {
        final Notification trueNotif;
        final Notification falseNotif;
        final QueryExp query;
        ExoticCase(Notification trueNotif, Notification falseNotif, QueryExp query) {
            this.trueNotif = trueNotif;
            this.falseNotif = falseNotif;
            this.query = query;
        }
    }

    private static abstract class ExoticQuery
            extends QueryEval implements QueryExp {
        private final String queryString;
        ExoticQuery(String queryString) {
            this.queryString = queryString;
        }
        abstract boolean apply(MBeanServer mbs, ObjectName name) throws Exception;
        @Override
        public boolean apply(ObjectName name) {
            try {
                return apply(getMBeanServer(), name);
            } catch (Exception e) {
                e.printStackTrace(System.out);
                return false;
            }
        }
        @Override
        public String toString() {
            return queryString;
        }
    }

    private static ObjectName makeObjectName(String s) {
        try {
            return new ObjectName(s);
        } catch (MalformedObjectNameException e) {
            throw new RuntimeException(e);
        }
    }

    public static class CustomNotification extends Notification {
        public CustomNotification(String type, Object source, long seqNo) {
            super(type, source, seqNo);
        }

        public String getName() {
            return "claude";
        }

        public boolean isInteresting() {
            return true;
        }
    }

    private static final Notification simpleNotif =
            new Notification("mytype", "source", 0L);
    private static final Notification attrChangeNotif =
            new AttributeChangeNotification(
                    "x", 0L, 0L, "msg", "AttrName", "int", 2, 3);
    private static final ObjectName testObjectName = makeObjectName("a:b=c");
    private static final Notification sourcedNotif =
            new Notification("mytype", testObjectName, 0L);
    private static final Notification customNotif =
            new CustomNotification("mytype", testObjectName, 0L);

    private static final Case[] testCases = {
        new Case(simpleNotif, "Type = 'mytype'", true),
        new Case(simpleNotif, "Type = 'mytype'",
                Notification.class, true),
        new Case(simpleNotif, "Type = 'mytype'",
                AttributeChangeNotification.class, false),
        new Case(simpleNotif, "Type != 'mytype'", false),
        new Case(simpleNotif, "Type = 'somethingelse'", false),
        new Case(attrChangeNotif, "AttributeName = 'AttrName'", true),
        new Case(attrChangeNotif,
                "instanceof 'javax.management.AttributeChangeNotification'",
                true),
        new Case(attrChangeNotif,
                "instanceof 'javax.management.Notification'",
                true),
        new Case(attrChangeNotif,
                "instanceof 'javax.management.relation.MBeanServerNotification'",
                false),
        new Case(attrChangeNotif,
                "class = 'javax.management.AttributeChangeNotification'",
                true),
        new Case(attrChangeNotif,
                "javax.management.AttributeChangeNotification#AttributeName = 'AttrName'",
                true),
        new Case(sourcedNotif,
                testObjectName,
                true),
        new Case(sourcedNotif,
                makeObjectName("a*:b=*"),
                true),
        new Case(sourcedNotif,
                makeObjectName("a*:c=*"),
                false),
        new Case(customNotif, "Name = 'claude'", true),
        new Case(customNotif, "Name = 'tiddly'", false),
        new Case(customNotif, "Interesting = true", true),
        new Case(customNotif, "Interesting = false", false),
    };

    private static final ExoticCase[] exoticTestCases = {
        new ExoticCase(
                simpleNotif, new Notification("notmytype", "source", 0L),
                new ExoticQuery("getAttributes") {
                    boolean apply(MBeanServer mbs, ObjectName name)
                            throws Exception {
                        List<Attribute> attrs = mbs.getAttributes(
                                name, new String[] {"Type", "Source"}).asList();
                        return (attrs.get(0).equals(new Attribute("Type", "mytype")) &&
                                attrs.get(1).equals(new Attribute("Source", "source")));
                    }
                }),
        new ExoticCase(
                new Notification("mytype", "source", 0L) {},
                simpleNotif,
                new ExoticQuery("getClassLoaderFor") {
                    boolean apply(MBeanServer mbs, ObjectName name)
                            throws Exception {
                        return (mbs.getClassLoaderFor(name) ==
                                this.getClass().getClassLoader());
                    }
                }),
        new ExoticCase(
                sourcedNotif, simpleNotif,
                new ExoticQuery("getDomains") {
                    boolean apply(MBeanServer mbs, ObjectName name)
                            throws Exception {
                        return Arrays.equals(mbs.getDomains(),
                                new String[] {testObjectName.getDomain()});
                    }
                }),
        new ExoticCase(
                simpleNotif, attrChangeNotif,
                new ExoticQuery("getMBeanInfo") {
                    boolean apply(MBeanServer mbs, ObjectName name)
                            throws Exception {
                        MBeanInfo mbi = mbs.getMBeanInfo(name);
                        // If we ever add a constructor to Notification then
                        // we will have to change the 4 below.
                        if (mbi.getOperations().length > 0 ||
                                mbi.getConstructors().length != 4 ||
                                mbi.getNotifications().length > 0)
                            return false;
                        Set<String> expect = new HashSet<String>(
                            Arrays.asList(
                                "Class", "Message", "SequenceNumber", "Source",
                                "TimeStamp", "Type", "UserData"));
                        Set<String> actual = new HashSet<String>();
                        for (MBeanAttributeInfo mbai : mbi.getAttributes())
                            actual.add(mbai.getName());
                        return actual.equals(expect);
                    }
                }),
        new ExoticCase(
                simpleNotif, attrChangeNotif,
                new ExoticQuery("getObjectInstance") {
                    boolean apply(MBeanServer mbs, ObjectName name)
                            throws Exception {
                        ObjectInstance oi = mbs.getObjectInstance(name);
                        return oi.getClassName().equals(Notification.class.getName());
                    }
                }),
        new ExoticCase(
                sourcedNotif, simpleNotif,
                new ExoticQuery("queryNames") {
                    boolean apply(MBeanServer mbs, ObjectName name)
                            throws Exception {
                        Set<ObjectName> names = mbs.queryNames(null,
                                Query.eq(Query.attr("Type"), Query.value("mytype")));
                        return names.equals(Collections.singleton(testObjectName));
                    }
                }),
        new ExoticCase(
                sourcedNotif, simpleNotif,
                new ExoticQuery("queryMBeans") {
                    boolean apply(MBeanServer mbs, ObjectName name)
                            throws Exception {
                        Set<ObjectInstance> insts = mbs.queryMBeans(null,
                                Query.eq(Query.attr("Type"), Query.value("mytype")));
                        if (insts.size() != 1)
                            return false;
                        ObjectInstance inst = insts.iterator().next();
                        return (inst.getObjectName().equals(testObjectName) &&
                                inst.getClassName().equals(Notification.class.getName()));
                    }
                }),
    };

    private static enum Test {
        QUERY_EXP("query"), STRING("string"), STRING_PLUS_CLASS("string with class");
        private final String name;
        Test(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return name;
        }
    }

    public static void main(String[] args) throws Exception {
        boolean allok = true;
        for (Case testCase : testCases) {
            for (Test test : Test.values()) {
                QueryNotificationFilter nf;
                String queryString;
                switch (test) {
                case QUERY_EXP: {
                    QueryExp inst = Query.isInstanceOf(
                            Query.value(testCase.notifClass.getName()));
                    QueryExp and = Query.and(inst, testCase.query);
                    queryString = Query.toString(and);
                    nf = new QueryNotificationFilter(and);
                    break;
                }
                case STRING: {
                    String s = "instanceof '" + testCase.notifClass.getName() + "'";
                    queryString = s + " and " + Query.toString(testCase.query);
                    nf = new QueryNotificationFilter(queryString);
                    break;
                }
                case STRING_PLUS_CLASS:
                    queryString = null;
                    nf = new QueryNotificationFilter(
                            testCase.notifClass, Query.toString(testCase.query));
                    break;
                default:
                    throw new AssertionError();
                }
                boolean accept = nf.isNotificationEnabled(testCase.notif);
                if (queryString != null) {
                    queryString = Query.toString(Query.fromString(queryString));
                    if (!queryString.equals(Query.toString(nf.getQuery()))) {
                        System.out.println("FAIL: query string mismatch: expected " +
                                "\"" + queryString + "\", got \"" +
                                Query.toString(nf.getQuery()));
                        allok = false;
                    }
                }
                boolean ok = (accept == testCase.expect);
                System.out.println((ok ? "pass" : "FAIL") + ": " +
                        testCase.query + " (" + test + ")");
                allok &= ok;
            }
        }
        for (ExoticCase testCase : exoticTestCases) {
            NotificationFilter nf = new QueryNotificationFilter(testCase.query);
            for (boolean expect : new boolean[] {true, false}) {
                Notification n = expect ? testCase.trueNotif : testCase.falseNotif;
                boolean accept = nf.isNotificationEnabled(n);
                boolean ok = (accept == expect);
                System.out.println((ok ? "pass" : "FAIL") + ": " +
                        testCase.query + ": " + n);
                allok &= ok;
            }
        }
        if (!allok)
            throw new Exception("TEST FAILED");
    }
}