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-top
28 * using different flavours of named nested types using MethodHandles
29 * @run main TestMethodHandles
30 */
31
32
33 import java.lang.invoke.*;
34 import static java.lang.invoke.MethodHandles.*;
35 import static java.lang.invoke.MethodType.*;
36
37 public class TestMethodHandles {
38
39 static final MethodType INVOKE_T = MethodType.methodType(void.class);
40
41 // Private static method of nest-top for nestmates to access
42 private static void priv_static_invoke() {
43 System.out.println("TestMethodHandles::priv_static_invoke");
44 }
45
46 // public constructor so we aren't relying on private access
47 public TestMethodHandles() {}
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(TestMethodHandles o) throws Throwable {
55 MethodHandle mh =
56 lookup().findStatic(o.getClass(), "priv_static_invoke", INVOKE_T);
57 mh.invoke();
58 mh.invokeExact();
59 }
60 void access_priv(StaticNested o) throws Throwable {
61 MethodHandle mh =
62 lookup().findStatic(o.getClass(), "priv_static_invoke", INVOKE_T);
63 mh.invoke();
64 mh.invokeExact();
65 }
66 void access_priv(StaticIface o) throws Throwable {
67 MethodHandle mh =
68 lookup().findStatic(StaticIface.class, "priv_static_invoke", INVOKE_T);
69 mh.invoke();
70 mh.invokeExact();
71 }
72
73 // The various nestmates
74
75 static interface StaticIface {
76
77 private static void priv_static_invoke() {
78 System.out.println("StaticIface::priv_static_invoke");
79 }
80
81 // Methods that will access private static methods of nestmates
82
83 default void access_priv(TestMethodHandles o) throws Throwable {
84 MethodHandle mh =
85 lookup().findStatic(o.getClass(), "priv_static_invoke", INVOKE_T);
86 mh.invoke();
87 mh.invokeExact();
88 }
89 default void access_priv(StaticNested o) throws Throwable {
90 MethodHandle mh =
91 lookup().findStatic(o.getClass(), "priv_static_invoke", INVOKE_T);
92 mh.invoke();
93 mh.invokeExact();
94 }
95 default void access_priv(StaticIface o) throws Throwable {
96 MethodHandle mh =
97 lookup().findStatic(StaticIface.class, "priv_static_invoke", INVOKE_T);
98 mh.invoke();
99 mh.invokeExact();
100 }
101 }
102
103 static class StaticNested {
104
105 private static void priv_static_invoke() {
106 System.out.println("StaticNested::priv_static_invoke");
107 }
108
109 // public constructor so we aren't relying on private access
110 public StaticNested() {}
111
112 // Methods that will access private static methods of nestmates
113
114 void access_priv(TestMethodHandles o) throws Throwable {
115 MethodHandle mh =
116 lookup().findStatic(o.getClass(), "priv_static_invoke", INVOKE_T);
117 mh.invoke();
118 mh.invokeExact();
119 }
120 void access_priv(StaticNested o) throws Throwable {
121 MethodHandle mh =
122 lookup().findStatic(o.getClass(), "priv_static_invoke", INVOKE_T);
123 mh.invoke();
124 mh.invokeExact();
125 }
126 void access_priv(StaticIface o) throws Throwable {
127 MethodHandle mh =
128 lookup().findStatic(StaticIface.class, "priv_static_invoke", INVOKE_T);
129 mh.invoke();
130 mh.invokeExact();
131 }
132 }
133
134 class InnerNested {
135
136 // public constructor so we aren't relying on private access
137 public InnerNested() {}
138
139 void access_priv(TestMethodHandles o) throws Throwable {
140 MethodHandle mh =
141 lookup().findStatic(o.getClass(), "priv_static_invoke", INVOKE_T);
142 mh.invoke();
143 mh.invokeExact();
144 }
145 void access_priv(StaticNested o) throws Throwable {
146 MethodHandle mh =
147 lookup().findStatic(o.getClass(), "priv_static_invoke", INVOKE_T);
148 mh.invoke();
149 mh.invokeExact();
150 }
151 void access_priv(StaticIface o) throws Throwable {
152 MethodHandle mh =
153 lookup().findStatic(StaticIface.class, "priv_static_invoke", INVOKE_T);
154 mh.invoke();
155 mh.invokeExact();
156 }
157 }
158
159 public static void main(String[] args) throws Throwable {
160 TestMethodHandles o = new TestMethodHandles();
161 StaticNested s = new StaticNested();
162 InnerNested i = o.new InnerNested();
163 StaticIface intf = new StaticIface() {};
164
165 o.access_priv(new TestMethodHandles());
166 o.access_priv(s);
167 o.access_priv(intf);
168
169 s.access_priv(o);
170 s.access_priv(new StaticNested());
171 s.access_priv(intf);
172
173 i.access_priv(o);
174 i.access_priv(s);
175 i.access_priv(intf);
176
177 intf.access_priv(o);
178 intf.access_priv(s);
179 intf.access_priv(new StaticIface(){});
180 }
181 }