/*

 * Copyright (c) 2017, 2018, 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 8046171

 * @summary Test the new nestmate reflection API

 * @compile TestReflectionAPI.java

 *          PackagedNestHost.java

 *          PackagedNestHost2.java

 *          SampleNest.java

 *          Hosts.java

 *          InvalidNestHost.java

 *

 * @compile MemberNoHost.jcod

 *          MemberMissingHost.jcod

 *          MemberNotInstanceHost.jcod

 *          MemberNotOurHost.jcod

 *          MemberMalformedHost.jcod

 *          MalformedHost.jcod

 *          PackagedNestHost.jcod

 *          PackagedNestHost2Member.jcod

 *          PackagedNestHostMember.jcod

 *          HostOfMemberNoHost.jcod

 *          HostOfMemberMissingHost.jcod

 *          HostOfMemberNotInstanceHost.jcod

 *          HostOfMemberNotOurHost.jcod

 *          HostOfMemberMalformedHost.jcod

 *          HostWithSelfMember.jcod

 *          HostWithDuplicateMembers.jcod

 *

 * @run main/othervm TestReflectionAPI

 * @run main/othervm/java.security.policy=empty.policy TestReflectionAPI

 */

// We need a nest member class that is invalid for each of the possible reasons,

// plus we need some external classes to test other failure modes.

// For each nested class below there is a corresponding .jcod file which breaks one

// of the rules regarding nest membership. For the package related tests we have

// additional PackageNestHost*.java sources.

// For testing getNestMembers we need an external host class that has a nested class

// which we can form a jcod file from such that we get all the expected failure modes.

// Note that all the .java files must be compiled in the same step, while all

// .jcod files must be compiled in a later step.

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashSet;

public class TestReflectionAPI {

    // Valid nest member

    static class Member {}

    // Missing NestHost attribute

    static class MemberNoHost {}

    // Missing NestHost class

    static class MemberMissingHost {}

    // Invalid NestHost class (not instance class)

    static class MemberNotInstanceHost {

        Object[] oa; // create CP entry to use in jcod change

    }

    // Valid but different NestHost class

    static class MemberNotOurHost {}

    // Malformed NestHost class

    static class MemberMalformedHost {}

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

        // run tests twice so that failure reasons are

        // seen to remain the same

        for (int i = 0; i < 2; i++) {

            test_getNestHost();

            test_isNestmateOf();

            test_getNestMembers();

        }

    }

    static void test_getNestHost() {

        Class<?> host = TestReflectionAPI.class;

        // sampling of "good" checks

        checkHost(host, host);

        checkHost(Member.class, host);

        Runnable r = new Runnable() { public void run() {}};

        checkHost(r.getClass(), host);

        // all the "bad" classes should report themselves as their

        // own nest host - no exceptions should be thrown

        Class<?>[] allClasses = host.getDeclaredClasses();

        for (Class<?> c : allClasses) {

            if (c == Member.class)

                continue;

            checkHost(c, c);

        }

        checkHost(P1.PackagedNestHost.Member.class,

                  P1.PackagedNestHost.Member.class);

        checkHost(P2.PackagedNestHost2.Member.class,

                  P2.PackagedNestHost2.Member.class);

        // test some 'special' classes

        checkHost(int.class, int.class);                   // primitive

        checkHost(Object[].class, Object[].class);         // array

        checkHost(Thread.State.class, Thread.class);       // enum

        checkHost(java.lang.annotation.Documented.class,   // annotation

                  java.lang.annotation.Documented.class);

    }

    static void test_isNestmateOf() {

        Class<?> host = TestReflectionAPI.class;

        checkNestmates(host, host, true);

        checkNestmates(Member.class, host, true);

        Runnable r = new Runnable() { public void run() {}};

        checkNestmates(r.getClass(), host, true);

        // all the "bad" classes should report themselves as their

        // own nest host - no exceptions should be thrown - so not

        // nestmates

        Class<?>[] allClasses = host.getDeclaredClasses();

        for (Class<?> c : allClasses) {

            if (c == Member.class)

                continue;

            checkNestmates(host, c, false);

        }

        // 'special' classes

        checkNestmates(int.class, int.class, true);             // primitive

        checkNestmates(int.class, long.class, false);           // primitive

        checkNestmates(Object[].class, Object[].class, true);   // array

        checkNestmates(Object[].class, int[].class, false);     // array

        checkNestmates(Thread.State.class, Thread.class, true); // enum

        checkNestmates(java.lang.annotation.Documented.class,   // annotation

                       java.lang.annotation.Documented.class, true);

    }

    static void test_getNestMembers() {

        // Sampling of "good" checks

        Class<?>[] good = { Object.class, Object[].class, int.class};

        checkSingletonNests(good);

        // More thorough correctness check

        checkNest(SampleNest.class, SampleNest.nestedTypes(), false);

        // Special cases - legal but not produced by javac

        checkNest(HostWithSelfMember.class,

                  new Class<?>[] { HostWithSelfMember.class,

                          HostWithSelfMember.Member.class },

                  true);

        checkNest(HostWithDuplicateMembers.class,

                  new Class<?>[] { HostWithDuplicateMembers.class,

                          HostWithDuplicateMembers.Member1.class,

                          HostWithDuplicateMembers.Member2.class },

                  true);

        // Hosts with "bad" members

        Class<?>[] bad = {

            HostOfMemberNoHost.class,

            HostOfMemberMissingHost.class,

            HostOfMemberNotOurHost.class,

            HostOfMemberNotInstanceHost.class,

            HostOfMemberMalformedHost.class,

        };

        Class<?>[] exceptions = {

            IncompatibleClassChangeError.class,

            NoClassDefFoundError.class,

            IncompatibleClassChangeError.class,

            IncompatibleClassChangeError.class,

            ClassFormatError.class,

        };

        String[] messages = {

            "Nest member HostOfMemberNoHost$MemberNoHost in HostOfMemberNoHost " +

            "declares a different nest host of HostOfMemberNoHost$MemberNoHost",

            "Unable to load nest-host class (NestHost) of " +

            "HostOfMemberMissingHost$MemberMissingHost",

            "Incompatible magic value 3735928559 in class file MalformedHost",

        };

        for (int i = 0; i < bad.length; i++) {

            try {

                bad[i].getNestMembers();

                throw new Error("getNestMembers() succeeded for class " +

                               bad[i].getName());

            } catch (LinkageError e) {

                checkException(e, messages[i], exceptions[i]);

            }

        }

    }

    static void checkException(Throwable actual, String msg, Class<?> expected) {

        if (!actual.getClass().equals(expected))

            throw new Error("Unexpected exception: got " + actual.getClass().getName()

                            + " but expected " + expected.getName());

        if (!actual.getMessage().contains(msg))

            throw new Error("Wrong " + actual.getClass().getSimpleName() +": \"" +

                            actual.getMessage() + "\" does not contain \"" +

                            msg + "\"");

        System.out.println("OK - got expected exception: " + actual);

    }

    static void checkHost(Class<?> target, Class<?> expected) {

        System.out.println("Checking nest host of " + target.getName());

        Class<?> host = target.getNestHost();

        if (host != expected)

            throw new Error("Class " + target.getName() +

                            " has nest host " + host.getName() +

                            " but expected " + expected.getName());

    }

    static void checkNestmates(Class<?> a, Class<?> b, boolean mates) {

        System.out.println("Checking if " + a.getName() +

                           " isNestmateOf " + b.getName());

        if (a.isNestmateOf(b) != mates)

            throw new Error("Class " + a.getName() + " is " +

                            (mates ? "not " : "") +

                            "a nestmate of " + b.getName() + " but should " +

                            (mates ? "" : "not ") + "be");

    }

    static Comparator<Class<?>> cmp = Comparator.comparing(Class::getName);

    static void checkNest(Class<?> host, Class<?>[] unsortedTypes, boolean expectDups) {

        Class<?>[] members = host.getNestMembers();

        Arrays.sort(members, cmp);

        Class<?>[] nestedTypes = unsortedTypes.clone();

        Arrays.sort(nestedTypes, cmp);

        printMembers(host, members);

        printDeclared(host, nestedTypes);

        if (!Arrays.equals(members, nestedTypes)) {

            if (!expectDups) {

                throw new Error("Class " + host.getName() + " has different members " +

                                "compared to declared classes");

            }

            else {

                // get rid of duplicates

                Class<?>[] memberSet =

                    Arrays.stream(members).sorted(cmp).distinct().toArray(Class<?>[]::new);

                if (!Arrays.equals(memberSet, nestedTypes)) {

                    throw new Error("Class " + host.getName() + " has different members " +

                                "compared to declared classes, even after duplicate removal");

                }

            }

        }

        // verify all the relationships that must hold for nest members

        for (Class<?> a : members) {

            checkHost(a, host);

            checkNestmates(a, host, true);

            Class<?>[] aMembers = a.getNestMembers();

            if (aMembers[0] != host) {

                throw new Error("Class " + a.getName() + " getNestMembers()[0] = " +

                                aMembers[0].getName() + " not " + host.getName());

            }

            Arrays.sort(aMembers, cmp);

            if (!Arrays.equals(members, aMembers)) {

                throw new Error("Class " + a.getName() + " has different members " +

                                "compared to host " + host.getName());

            }

            for (Class<?> b : members) {

                checkNestmates(a, b, true);

            }

        }

    }

    static void checkSingletonNests(Class<?>[] classes) {

        for (Class<?> host : classes) {

            Class<?>[] members = host.getNestMembers();

            if (members.length != 1) {

                printMembers(host, members);

                throw new Error("Class " + host.getName() + " lists " + members.length

                                + " members instead of 1 (itself)");

            }

            if (members[0] != host) {

                printMembers(host, members);

                throw new Error("Class " + host.getName() + " lists " +

                                members[0].getName() + " as member instead of itself");

            }

        }

    }

    static void printMembers(Class<?> host, Class<?>[] members) {

        System.out.println("Class " + host.getName() + " has members: ");

        for (Class<?> c : members) {

            System.out.println(" - " + c.getName());

        }

    }

    static void printDeclared(Class<?> host, Class<?>[] declared) {

        System.out.println("Class " + host.getName() + " has declared types: ");

        for (Class<?> c : declared) {

            System.out.println(" - " + c.getName());

        }

    }

}