/*

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

 */

package annotations.classfile;

import java.io.*;

import java.net.URL;

import com.sun.tools.classfile.*;

import com.sun.tools.classfile.ConstantPool.InvalidIndex;

import com.sun.tools.classfile.ConstantPool.UnexpectedEntry;

/**

 * A class providing utilities for writing tests that inspect class

 * files directly, looking for specific type annotations.

 *

 * Note: this framework does not currently handle repeating

 * annotations.

 */

public class ClassfileInspector {

    /**

     * A group of expected annotations to be found in a given class.

     * If the class name is null, then the template will be applied to

     * every class.

     */

    public static class Expected {

        /**

         * The name of the class.  If {@code null} this template will

         * apply to every class; otherwise, it will only be applied to

         * the named class.

         */

        public final String classname;

        /**

         * The expected class annotations.  These will be checked

         * against the class' attributes.

         */

        public final ExpectedAnnotation[] classAnnos;

        /**

         * The expected method annotations.  These will be checked

         * against all methods in the class.

         */

        public final ExpectedMethodAnnotation[] methodAnnos;

        /**

         * The expected method parameter annotations.  These will be checked

         * against all methods in the class.

         */

        public final ExpectedParameterAnnotation[] methodParamAnnos;

        /**

         * The expected field type annotations.  These will be checked

         * against all fields in the class.

         */

        public final ExpectedFieldAnnotation[] fieldAnnos;

        /**

         * The expected class type annotations.  These will be checked

         * against the class' attributes.

         */

        public final ExpectedTypeAnnotation[] classTypeAnnos;

        /**

         * The expected method type annotations.  These will be checked

         * against all methods in the class.

         */

        public final ExpectedMethodTypeAnnotation[] methodTypeAnnos;

        /**

         * The expected field type annotations.  These will be checked

         * against all fields in the class.

         */

        public final ExpectedFieldTypeAnnotation[] fieldTypeAnnos;

        /**

         * Create an {@code Expected} from all components.

         *

         * @param classname The name of the class to match, or {@code

         *                  null} for all classes.

         * @param classAnnos The expected class annotations.

         * @param methodAnnos The expected method annotations.

         * @param methodParamAnnos The expected method parameter annotations.

         * @param fieldAnnos The expected field annotations.

         * @param classTypeAnnos The expected class type annotations.

         * @param methodTypeAnnos The expected method type annotations.

         * @param fieldTypeAnnos The expected field type annotations.

         */

        public Expected(String classname,

                        ExpectedAnnotation[] classAnnos,

                        ExpectedMethodAnnotation[] methodAnnos,

                        ExpectedParameterAnnotation[] methodParamAnnos,

                        ExpectedFieldAnnotation[] fieldAnnos,

                        ExpectedTypeAnnotation[] classTypeAnnos,

                        ExpectedMethodTypeAnnotation[] methodTypeAnnos,

                        ExpectedFieldTypeAnnotation[] fieldTypeAnnos) {

            this.classname = classname;

            this.classAnnos = classAnnos;

            this.methodAnnos = methodAnnos;

            this.methodParamAnnos = methodParamAnnos;

            this.fieldAnnos = fieldAnnos;

            this.classTypeAnnos = classTypeAnnos;

            this.methodTypeAnnos = methodTypeAnnos;

            this.fieldTypeAnnos = fieldTypeAnnos;

        }

        /**

         * Create an {@code Expected} from regular annotation components.

         *

         * @param classname The name of the class to match, or {@code

         *                  null} for all classes.

         * @param classAnnos The expected class annotations.

         * @param methodAnnos The expected method annotations.

         * @param methodParamAnnos The expected method parameter annotations.

         * @param fieldAnnos The expected field annotations.

         */

        public Expected(String classname,

                        ExpectedAnnotation[] classAnnos,

                        ExpectedMethodAnnotation[] methodAnnos,

                        ExpectedParameterAnnotation[] methodParamAnnos,

                        ExpectedFieldAnnotation[] fieldAnnos) {

            this(classname, classAnnos, methodAnnos, methodParamAnnos,

                 fieldAnnos, null, null, null);

        }

        /**

         * Create an {@code Expected} from type annotation components.

         *

         * @param classname The name of the class to match, or {@code

         *                  null} for all classes.

         * @param classTypeAnnos The expected class type annotations.

         * @param methodTypeAnnos The expected method type annotations.

         * @param fieldTypeAnnos The expected field type annotations.

         */

        public Expected(String classname,

                        ExpectedTypeAnnotation[] classTypeAnnos,

                        ExpectedMethodTypeAnnotation[] methodTypeAnnos,

                        ExpectedFieldTypeAnnotation[] fieldTypeAnnos) {

            this(classname, null, null, null, null,

                 classTypeAnnos, methodTypeAnnos, fieldTypeAnnos);

        }

        @Override

        public String toString() {

            final StringBuilder sb = new StringBuilder();

            final String newline = System.lineSeparator();

            sb.append("Expected on class ").append(classname);

            if (null != classAnnos) {

                sb.append(newline).append("Class annotations:").append(newline);

                for(ExpectedAnnotation anno : classAnnos) {

                    sb.append(anno).append(newline);

                }

            }

            if (null != methodAnnos) {

                sb.append(newline).append("Method annotations:").append(newline);

                for(ExpectedAnnotation anno : methodAnnos) {

                    sb.append(anno).append(newline);

                }

            }

            if (null != methodParamAnnos) {

                sb.append(newline).append("Method param annotations:").append(newline);

                for(ExpectedAnnotation anno : methodParamAnnos) {

                    sb.append(anno).append(newline);

                }

            }

            if (null != fieldAnnos) {

                sb.append(newline).append("Field annotations:").append(newline);

                for(ExpectedAnnotation anno : fieldAnnos) {

                    sb.append(anno).append(newline);

                }

            }

            if (null != classTypeAnnos) {

                sb.append(newline).append("Class type annotations:").append(newline);

                for(ExpectedAnnotation anno : classTypeAnnos) {

                    sb.append(anno).append(newline);

                }

            }

            if (null != methodTypeAnnos) {

                sb.append(newline).append("Method type annotations:").append(newline);

                for(ExpectedAnnotation anno : methodTypeAnnos) {

                    sb.append(anno).append(newline);

                }

            }

            if (null != fieldTypeAnnos) {

                sb.append(newline).append("Field type annotations:").append(newline);

                for(ExpectedAnnotation anno : fieldTypeAnnos) {

                    sb.append(anno).append(newline);

                }

            }

            return sb.toString();

        }

        /**

         * See if this template applies to a class.

         *

         * @param classname The classname to check.

         * @return Whether or not this template should apply.

         */

        public boolean matchClassName(String classname) {

            return this.classname == null || this.classname.equals(classname);

        }

        /**

         * After applying the template to all classes, check to see if

         * any of the expected annotations weren't matched.

         *

         * @return The number of missed matches.

         */

        public int check() {

            int count = 0;

            if (classAnnos != null) {

                for(ExpectedAnnotation expected : classAnnos) {

                    if (!expected.check()) {

                        count++;

                    }

                }

            }

            if (methodAnnos != null) {

                for(ExpectedAnnotation expected : methodAnnos) {

                    if (!expected.check()) {

                        count++;

                    }

                }

            }

            if (methodParamAnnos != null) {

                for(ExpectedAnnotation expected : methodParamAnnos) {

                    if (!expected.check()) {

                        count++;

                    }

                }

            }

            if (fieldAnnos != null) {

                for(ExpectedAnnotation expected : fieldAnnos) {

                    if (!expected.check()) {

                        count++;

                    }

                }

            }

            if (classTypeAnnos != null) {

                for(ExpectedAnnotation expected : classTypeAnnos) {

                    if (!expected.check()) {

                        count++;

                    }

                }

            }

            if (methodTypeAnnos != null) {

                for(ExpectedAnnotation expected : methodTypeAnnos) {

                    if (!expected.check()) {

                        count++;

                    }

                }

            }

            if (fieldTypeAnnos != null) {

                for(ExpectedAnnotation expected : fieldTypeAnnos) {

                    if (!expected.check()) {

                        count++;

                    }

                }

            }

            return count;

        }

    }

    /**

     * An expected annotation.  This is both a superclass for

     * method, field, and type annotations, as well as a class for

     * annotations on a class.

     */

    public static class ExpectedAnnotation {

        protected int count = 0;

        protected final String expectedName;

        protected final int expectedCount;

        protected final boolean visibility;

        /**

         * Create an {@code ExpectedAnnotation} from its

         * components.  It is usually a better idea to use a {@code

         * Builder} to do this.

         *

         * @param expectedName The expected annotation name.

         * @param visibility Whether this annotation should be runtime-visible.

         * @param expectedCount The number of annotations that should

         *                      be seen.  If 0, this asserts that the

         *                      described annotation is not present.

         */

        public ExpectedAnnotation(String expectedName,

                                  boolean visibility,

                                  int expectedCount) {

            this.expectedName = expectedName;

            this.visibility = visibility;

            this.expectedCount = expectedCount;

        }

        @Override

        public String toString() {

            final StringBuilder sb = new StringBuilder();

            sb.append("Expected ");

            sb.append(expectedCount);

            sb.append(" annotation ");

            sb.append(expectedName);

            sb.append(visibility ? ", runtime visibile " : ", runtime invisibile ");

            return sb.toString();

        }

        /**

         * See if this template matches the given visibility.

         *

         * @param Whether or not the annotation is visible at runtime.

         * @return Whether or not this template matches the visibility.

         */

        public boolean matchVisibility(boolean visibility) {

            return this.visibility == visibility;

        }

        /**

         * Attempty to match this template against an annotation.  If

         * it does match, then the match count for the template will

         * be incremented.  Otherwise, nothing will be done.

         *

         * @param anno The annotation to attempt to match.

         */

        public void matchAnnotation(ConstantPool cpool,

                                    Annotation anno) {

            if (checkMatch(cpool, anno)) {

                count++;

            }

        }

        /**

         * Indicate whether an annotation matches this expected

         * annotation.

         *

         * @param ConstantPool The constant pool to use.

         * @param anno The annotation to check.

         * @return Whether the annotation matches.

         */

        protected boolean checkMatch(ConstantPool cpool,

                                     Annotation anno) {

            try {

                return cpool.getUTF8Info(anno.type_index).value.equals("L" + expectedName + ";");

            } catch (InvalidIndex | UnexpectedEntry e) {

                return false;

            }

        }

        /**

         * After all matching, check to see if the expected number of

         * matches equals the actual number.  If not, then print a

         * failure message and return {@code false}.

         *

         * @return Whether or not the expected number of matched

         *         equals the actual number.

         */

        public boolean check() {

            if (count != expectedCount) {

                System.err.println(this + ", but saw " + count);

                return false;

            } else {

                return true;

            }

        }

    }

    /**

     * An annotation found on a method.

     */

    public static class ExpectedMethodAnnotation extends ExpectedAnnotation {

        protected final String methodname;

        /**

         * Create an {@code ExpectedMethodAnnotation} from its

         * components.  It is usually a better idea to use a {@code

         * Builder} to do this.

         *

         * @param methodname The expected method name.

         * @param expectedName The expected annotation name.

         * @param visibility Whether this annotation should be runtime-visible.

         * @param expectedCount The number of annotations that should be seen.

         */

        public ExpectedMethodAnnotation(String methodname,

                                        String expectedName,

                                        boolean visibility,

                                        int expectedCount) {

            super(expectedName, visibility, expectedCount);

            this.methodname = methodname;

        }

        @Override

        public String toString() {

            final StringBuilder sb = new StringBuilder();

            sb.append("Expected ");

            sb.append(expectedCount);

            sb.append(" annotation ");

            sb.append(expectedName);

            sb.append(visibility ? ", runtime visibile " : ", runtime invisibile ");

            sb.append(" on method ");

            sb.append(methodname);

            return sb.toString();

        }

        /**

         * See if this template applies to a method.

         *

         * @param methodname The method name to check.

         * @return Whether or not this template should apply.

         */

        public boolean matchMethodName(String methodname) {

            return this.methodname.equals(methodname);

        }

    }

    /**

     * An annotation found on a method parameter.

     */

    public static class ExpectedParameterAnnotation

        extends ExpectedMethodAnnotation {

        protected final int index;

        /**

         * Create an {@code ExpectedParameterAnnotation} from its

         * components.  It is usually a better idea to use a {@code

         * Builder} to do this.

         *

         * @param methodname The expected method name.

         * @param index The parameter index.

         * @param expectedName The expected annotation name.

         * @param visibility Whether this annotation should be runtime-visible.

         * @param expectedCount The number of annotations that should be seen.

         */

        public ExpectedParameterAnnotation(String methodname,

                                           int index,

                                           String expectedName,

                                           boolean visibility,

                                           int expectedCount) {

            super(methodname, expectedName, visibility, expectedCount);

            this.index = index;

        }

        @Override

        public String toString() {

            final StringBuilder sb = new StringBuilder();

            sb.append("Expected ");

            sb.append(expectedCount);

            sb.append(" annotation ");

            sb.append(expectedName);

            sb.append(visibility ? ", runtime visibile " : ", runtime invisibile ");

            sb.append(" on method ");

            sb.append(methodname);

            sb.append(" parameter ");

            sb.append(index);

            return sb.toString();

        }

    }

    /**

     * An annotation found on a field.

     */

    public static class ExpectedFieldAnnotation extends ExpectedAnnotation {

        private final String fieldname;

        /**

         * Create an {@code ExpectedFieldAnnotation} from its

         * components.  It is usually a better idea to use a {@code

         * Builder} to do this.

         *

         * @param fieldname The expected field name.

         * @param expectedName The expected annotation name.

         * @param visibility Whether this annotation should be runtime-visible.

         * @param expectedCount The number of annotations that should be seen.

         */

        public ExpectedFieldAnnotation(String fieldname,

                                       String expectedName,

                                       boolean visibility,

                                       int expectedCount) {

            super(expectedName, visibility, expectedCount);

            this.fieldname = fieldname;

        }