1 /*

     2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @bug 8046171

    27  * @summary Test access to private static methods between nestmates and nest-host

    28  *          using different flavours of named nested types using core reflection

    29  * @run main TestReflection

    30  * @run main/othervm -Dsun.reflect.noInflation=true TestReflection

    31  */

    32 

    33 // The first run will use NativeMethodAccessor and due to the limited number

    34 // of calls we will not reach the inflation threshold.

    35 // The second run disables inflation so we will use the GeneratedMethodAccessor

    36 // instead. In this way both sets of Reflection classes are tested.

    37 

    38 

    39 public class TestReflection {

    40 

    41     // Private method of nest-host for nestmates to access

    42     private static void priv_static_invoke() {

    43         System.out.println("TestReflection::priv_static_invoke");

    44     }

    45 

    46     // public constructor so we aren't relying on private access

    47     public TestReflection() {}

    48 

    49     // Methods that will access private static methods of nestmates

    50 

    51     // NOTE: No InnerNested calls in this test because non-static nested types

    52     // can't have static methods

    53 

    54     void access_priv(TestReflection o) throws Throwable {

    55         o.getClass().getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

    56     }

    57     void access_priv(StaticNested o) throws Throwable {

    58         o.getClass().getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

    59     }

    60     void access_priv(StaticIface o) throws Throwable {

    61         // Can't use o.getClass() as the method is not in that class

    62         StaticIface.class.getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

    63     }

    64 

    65     // The various nestmates

    66 

    67     static interface StaticIface {

    68 

    69         private static void priv_static_invoke() {

    70             System.out.println("StaticIface::priv_static_invoke");

    71         }

    72 

    73         // Methods that will access private static methods of nestmates

    74 

    75         default void access_priv(TestReflection o) throws Throwable {

    76             o.getClass().getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

    77         }

    78         default void access_priv(StaticNested o) throws Throwable {

    79             o.getClass().getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

    80         }

    81         default void access_priv(StaticIface o) throws Throwable {

    82             // Can't use o.getClass() as the method is not in that class

    83             StaticIface.class.getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

    84         }

    85     }

    86 

    87     static class StaticNested {

    88 

    89         private static void priv_static_invoke() {

    90             System.out.println("StaticNested::priv_static_invoke");

    91         }

    92 

    93         // public constructor so we aren't relying on private access

    94         public StaticNested() {}

    95 

    96         // Methods that will access private static methods of nestmates

    97 

    98         void access_priv(TestReflection o) throws Throwable {

    99             o.getClass().getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

   100         }

   101         void access_priv(StaticNested o) throws Throwable {

   102             o.getClass().getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

   103         }

   104         void access_priv(StaticIface o) throws Throwable {

   105             // Can't use o.getClass() as the method is not in that class

   106             StaticIface.class.getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

   107         }

   108     }

   109 

   110     class InnerNested {

   111 

   112         // public constructor so we aren't relying on private access

   113         public InnerNested() {}

   114 

   115         void access_priv(TestReflection o) throws Throwable {

   116             o.getClass().getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

   117         }

   118         void access_priv(StaticNested o) throws Throwable {

   119             o.getClass().getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

   120         }

   121         void access_priv(StaticIface o) throws Throwable {

   122             // Can't use o.getClass() as the method is not in that class

   123             StaticIface.class.getDeclaredMethod("priv_static_invoke", new Class<?>[0]).invoke(null, new Object[0]);

   124         }

   125     }

   126 

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

   128         TestReflection o = new TestReflection();

   129         StaticNested s = new StaticNested();

   130         InnerNested i = o.new InnerNested();

   131         StaticIface intf = new StaticIface() {};

   132 

   133         o.access_priv(new TestReflection());

   134         o.access_priv(s);

   135         o.access_priv(intf);

   136 

   137         s.access_priv(o);

   138         s.access_priv(new StaticNested());

   139         s.access_priv(intf);

   140 

   141         i.access_priv(o);

   142         i.access_priv(s);

   143         i.access_priv(intf);

   144 

   145         intf.access_priv(o);

   146         intf.access_priv(s);

   147         intf.access_priv(new StaticIface(){});

   148     }

   149 }