/*

 * Copyright (c) 2016, 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.

 */

import util.ClassSupplier;

import util.MemberFactory;

import java.lang.reflect.AccessibleObject;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.EnumSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Optional;

import java.util.stream.Stream;

import static java.util.stream.Collectors.groupingBy;

import static java.util.stream.Collectors.joining;

import static java.util.stream.Collectors.mapping;

import static java.util.stream.Collectors.toCollection;

import static util.MemberFactory.*;

import static util.MemberFactory.Group.*;

import static util.ClassSupplier.*;

/**

 * @test

 * @summary An exhaustive test of reflective access controls

 * @bug 6378384

 * @build a.PublicSuper a.Package b.PublicSub b.Package

 *        util.MemberFactory util.ClassSupplier

 * @run main AccessControlTest

 */

public class AccessControlTest {

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

        boolean ok = true;

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_A)

            .member (PACKAGE_CLASS_IN_PKG_A).target(PACKAGE_CLASS_IN_PKG_A)

            .allowed(ALL)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_A)

            .member (PUBLIC_SUPERCLASS_IN_PKG_A).target(PUBLIC_SUPERCLASS_IN_PKG_A)

            .allowed(PACKAGE_MEMBERS, PROTECTED_MEMBERS, PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_A)

            .member (PUBLIC_SUPERCLASS_IN_PKG_A).target(PUBLIC_SUBCLASS_IN_PKG_B)

            .allowed(PACKAGE_MEMBERS, PROTECTED_MEMBERS, PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_A)

            .member (PACKAGE_CLASS_IN_PKG_B).target(PACKAGE_CLASS_IN_PKG_B)

            .denied (ALL)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_A)

            .member (PUBLIC_SUBCLASS_IN_PKG_B).target(PUBLIC_SUBCLASS_IN_PKG_B)

            .allowed(PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS, PACKAGE_MEMBERS, PROTECTED_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUPERCLASS_IN_PKG_A)

            .member (PACKAGE_CLASS_IN_PKG_A).target(PACKAGE_CLASS_IN_PKG_A)

            .allowed(PACKAGE_MEMBERS, PROTECTED_MEMBERS, PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUPERCLASS_IN_PKG_A)

            .member (PUBLIC_SUPERCLASS_IN_PKG_A).target(PUBLIC_SUPERCLASS_IN_PKG_A)

            .allowed(ALL)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUPERCLASS_IN_PKG_A)

            .member (PUBLIC_SUPERCLASS_IN_PKG_A).target(PUBLIC_SUBCLASS_IN_PKG_B)

            .allowed(ALL)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUPERCLASS_IN_PKG_A)

            .member (PACKAGE_CLASS_IN_PKG_B).target(PACKAGE_CLASS_IN_PKG_B)

            .denied (ALL)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUPERCLASS_IN_PKG_A)

            .member (PUBLIC_SUBCLASS_IN_PKG_B).target(PUBLIC_SUBCLASS_IN_PKG_B)

            .allowed(PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS, PACKAGE_MEMBERS, PROTECTED_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_B)

            .member (PACKAGE_CLASS_IN_PKG_A).target(PACKAGE_CLASS_IN_PKG_A)

            .denied (ALL)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_B)

            .member (PUBLIC_SUPERCLASS_IN_PKG_A).target(PUBLIC_SUPERCLASS_IN_PKG_A)

            .allowed(PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS, PACKAGE_MEMBERS, PROTECTED_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_B)

            .member (PUBLIC_SUPERCLASS_IN_PKG_A).target(PUBLIC_SUBCLASS_IN_PKG_B)

            .allowed(PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS, PACKAGE_MEMBERS, PROTECTED_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_B)

            .member (PACKAGE_CLASS_IN_PKG_B).target(PACKAGE_CLASS_IN_PKG_B)

            .allowed(ALL)

            .perform();

        ok &= new Test()

            .current(PACKAGE_CLASS_IN_PKG_B)

            .member (PUBLIC_SUBCLASS_IN_PKG_B).target(PUBLIC_SUBCLASS_IN_PKG_B)

            .allowed(PACKAGE_MEMBERS, PROTECTED_MEMBERS, PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUBCLASS_IN_PKG_B)

            .member (PACKAGE_CLASS_IN_PKG_A).target(PACKAGE_CLASS_IN_PKG_A)

            .denied (ALL)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUBCLASS_IN_PKG_B)

            .member (PUBLIC_SUPERCLASS_IN_PKG_A).target(PUBLIC_SUPERCLASS_IN_PKG_A)

            .allowed(PUBLIC_MEMBERS, PROTECTED_STATIC_F_M)

            .denied (PRIVATE_MEMBERS, PACKAGE_MEMBERS, PROTECTED_INSTANCE_F_M,

                     PROTECTED_C)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUBCLASS_IN_PKG_B)

            .member (PUBLIC_SUPERCLASS_IN_PKG_A).target(PUBLIC_SUBCLASS_IN_PKG_B)

            .allowed(PUBLIC_MEMBERS, PROTECTED_INSTANCE_F_M, PROTECTED_STATIC_F_M)

            .denied (PRIVATE_MEMBERS, PACKAGE_MEMBERS, PROTECTED_C)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUBCLASS_IN_PKG_B)

            .member (PACKAGE_CLASS_IN_PKG_B).target(PACKAGE_CLASS_IN_PKG_B)

            .allowed(PACKAGE_MEMBERS, PROTECTED_MEMBERS, PUBLIC_MEMBERS)

            .denied (PRIVATE_MEMBERS)

            .perform();

        ok &= new Test()

            .current(PUBLIC_SUBCLASS_IN_PKG_B)

            .member (PUBLIC_SUBCLASS_IN_PKG_B).target(PUBLIC_SUBCLASS_IN_PKG_B)

            .allowed(ALL)

            .perform();

        if (ok) {

            System.out.println("\nAll cases passed.");

        } else {

            throw new RuntimeException("Some cases failed - see log.");

        }

    }

    // use this for generating an exhaustive set of test cases on stdout

    public static class Generate {

        public static void main(String[] args) {

            for (ClassSupplier current : ClassSupplier.values()) {

                for (ClassSupplier member : ClassSupplier.values()) {

                    for (ClassSupplier target : ClassSupplier.values()) {

                        if (member.get().isAssignableFrom(target.get())) {

                            new Test()

                                .current(current).member(member).target(target)

                                .allowed(ALL)

                                .perform(true);

                        }

                    }

                }

            }

        }

    }

    static class Test {

        ClassSupplier currentClassSupplier, memberClassSupplier, targetClassSupplier;

        EnumSet<MemberFactory> expectAllowedMembers = EnumSet.noneOf(MemberFactory.class);

        EnumSet<MemberFactory> expectDeniedMembers = EnumSet.noneOf(MemberFactory.class);

        Test current(ClassSupplier current) {

            currentClassSupplier = current;

            return this;

        }

        Test member(ClassSupplier member) {

            memberClassSupplier = member;

            return this;

        }

        Test target(ClassSupplier target) {

            targetClassSupplier = target;

            return this;

        }

        Test allowed(MemberFactory... allowed) {

            expectAllowedMembers = MemberFactory.asSet(allowed);

            return this;

        }

        Test allowed(MemberFactory.Group... allowedGroups) {

            expectAllowedMembers = MemberFactory.groupsToMembers(

                MemberFactory.Group.asSet(allowedGroups));

            return this;

        }

        Test denied(MemberFactory... denied) {

            expectDeniedMembers = MemberFactory.asSet(denied);

            return this;

        }

        Test denied(MemberFactory.Group... deniedGroups) {

            expectDeniedMembers = MemberFactory.groupsToMembers(

                MemberFactory.Group.asSet(deniedGroups));

            return this;

        }

        boolean perform() {

            return perform(false);

        }

        boolean perform(boolean generateCases) {

            // some validation 1st

            EnumSet<MemberFactory> intersection = EnumSet.copyOf(expectAllowedMembers);

            intersection.retainAll(expectDeniedMembers);

            if (!intersection.isEmpty()) {

                throw new IllegalArgumentException(

                    "Expected allowed and denied MemberFactories have non-empty intersection: " +

                    intersection);

            }

            EnumSet<MemberFactory> missing = EnumSet.allOf(MemberFactory.class);

            missing.removeAll(expectAllowedMembers);

            missing.removeAll(expectDeniedMembers);

            if (!missing.isEmpty()) {

                throw new IllegalArgumentException(

                    "Union of expected allowed and denied MemberFactories is missing elements: " +

                    missing);

            }

            // retrieve method that will perform reflective access

            Method checkAccessMethod;

            try {

                checkAccessMethod = currentClassSupplier.get().getDeclaredMethod(

                    "checkAccess", AccessibleObject.class, Object.class);

                // in case of inaccessible currentClass

                checkAccessMethod.setAccessible(true);

            } catch (NoSuchMethodException e) {

                throw new RuntimeException(e);

            }

            // construct a target object (for instance field/method)

            Object target;

            Constructor<?> targetConstructor =

                (Constructor<?>) PUBLIC_CONSTRUCTOR.apply(targetClassSupplier.get());

            // in case of inaccessible targetClass

            targetConstructor.setAccessible(true);

            try {

                target = targetConstructor.newInstance(

                    new Object[targetConstructor.getParameterCount()]);

            } catch (ReflectiveOperationException e) {

                throw new RuntimeException(e);

            }

            Class<?> memberClass = memberClassSupplier.get();

            Map<Boolean, EnumSet<MemberFactory>> actualMembers = Stream.concat(

                expectAllowedMembers.stream().map(member -> new Trial(member, true)),

                expectDeniedMembers.stream().map(member -> new Trial(member, false))

            ).map(trial -> {

                // obtain AccessibleObject to be used to perform reflective access

                AccessibleObject accessibleObject = trial.member.apply(memberClass);

                // only need target 'obj' for instance fields and methods

                Object obj =

                    (accessibleObject instanceof Field &&

                     !Modifier.isStatic(((Field) accessibleObject).getModifiers())

                     ||

                     accessibleObject instanceof Method &&

                     !Modifier.isStatic(((Method) accessibleObject).getModifiers())

                    )

                    ? target : null;

                // invoke checkAccess method and let it perform the reflective access

                try {

                    checkAccessMethod.invoke(null, accessibleObject, obj);

                    trial.actualAllowed = true;

                } catch (IllegalAccessException e) {

                    // should not happen as checkAccessMethod.isAccessible()

                    throw new RuntimeException(e);

                } catch (InvocationTargetException e) {

                    if (e.getTargetException() instanceof IllegalAccessException) {

                        trial.actualAllowed = false;

                    } else {

                        // any other Exception is a fault in test or infrastructure - fail fast

                        throw new RuntimeException(e.getTargetException());

                    }

                }

                if (!generateCases) {

                    System.out.printf(

                        "%-26s accessing %26s's %-25s %-43s - expected %s, actual %s: %s\n",

                        currentClassSupplier, memberClassSupplier, trial.member.name(),

                        (obj == null ? "" : "with instance of " + targetClassSupplier),

                        (trial.expectAllowed ? "allowed" : "denied "),

                        (trial.actualAllowed ? "allowed" : "denied "),

                        (trial.expectAllowed == trial.actualAllowed ? "OK" : "FAILURE")

                    );

                }

                return trial;

            }).collect(

                groupingBy(

                    Trial::isActualAllowed,

                    mapping(

                        Trial::getMember,

                        toCollection(() -> EnumSet.noneOf(MemberFactory.class))))

            );

            EnumSet<MemberFactory> actualAllowedMembers =

                Optional.ofNullable(actualMembers.get(true))

                        .orElse(EnumSet.noneOf(MemberFactory.class));

            EnumSet<MemberFactory> actualDeniedMembers =

                Optional.ofNullable(actualMembers.get(false))

                        .orElse(EnumSet.noneOf(MemberFactory.class));

            if (generateCases) {

                System.out.printf(

                    "        ok &= new Test()\n" +

                    "            .current(%s)\n" +

                    "            .member (%s).target(%s)\n",

                    currentClassSupplier,

                    memberClassSupplier, targetClassSupplier

                );

                if (!actualAllowedMembers.isEmpty()) {

                    EnumSet<? extends Enum> actualAllowed =

                        MemberFactory.membersToGroupsOrNull(actualAllowedMembers);

                    if (actualAllowed == null)

                        actualAllowed = actualAllowedMembers;

                    System.out.print(

                        chunkBy(3, actualAllowed.stream().map(Enum::name))

                            .map(chunk -> chunk.collect(joining(", ")))

                            .collect(joining(",\n" +

                                             "                     ",

                                             "            .allowed(",

                                             ")\n"))

                    );

                }

                if (!actualDeniedMembers.isEmpty()) {

                    EnumSet<? extends Enum> actualDenied =

                        MemberFactory.membersToGroupsOrNull(actualDeniedMembers);

                    if (actualDenied == null)

                        actualDenied = actualAllowedMembers;

                    System.out.print(

                        chunkBy(3, actualDenied.stream().map(Enum::name))

                            .map(chunk -> chunk.collect(joining(", ")))

                            .collect(joining(",\n" +

                                             "                     ",

                                             "            .denied (",

                                             ")\n"))

                    );

                }

                System.out.print(

                    "            .perform();\n"

                );

            }

            return expectAllowedMembers.equals(actualAllowedMembers) &&

                   expectDeniedMembers.equals(actualDeniedMembers);

        }

    }

    private static <T> Stream<Stream<T>> chunkBy(int chunkSize, Stream<T> stream) {

        Iterator<T> elements = stream.iterator();

        Stream.Builder<Stream<T>> b1 = Stream.builder();

        while (elements.hasNext()) {

            Stream.Builder<T> b2 = Stream.builder();

            for (int i = 0; i < chunkSize && elements.hasNext(); i++) {

                b2.accept(elements.next());

            }

            b1.accept(b2.build());

        }

        return b1.build();

    }

    private static class Trial {

        final MemberFactory member;

        final boolean expectAllowed;

        boolean actualAllowed;

        Trial(MemberFactory member, boolean expectAllowed) {

            this.member = member;

            this.expectAllowed = expectAllowed;

        }

        MemberFactory getMember() {

            return member;

        }

        boolean isActualAllowed() {

            return actualAllowed;

        }

    }

}