Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
PojavLauncherTeam
GitHub Repository: PojavLauncherTeam/mobile
 Path: blob/master/test/jdk/java/lang/ModuleTests/access/src/test/test/Main.java
41921 views
1
/*

2
 * Copyright (c) 2015, 2016, 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
package test;

25


26
import java.lang.reflect.AccessibleObject;

27
import java.lang.reflect.Constructor;

28
import java.lang.reflect.Field;

29
import java.lang.reflect.Method;

30


31
/**

32
 * Test access to public/non-public members of public/non-public classes in

33
 * exported and non-exported packages.

34
 */

35


36
public class Main {

37


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

39
        testPublicClassInExportedPackage();

40
        testNonPublicClassInExportedPackage();

41
        testPublicClassInNonExportedPackage();

42
        testNonPublicClassInNonExportedPackage();

43
    }

44


45
    static void testPublicClassInExportedPackage() throws Exception {

46
        Module thisModule = Main.class.getModule();

47
        Module targetModule = getTargetModule();

48


49
        assertTrue(targetModule.isExported("p1"));

50
        assertTrue(targetModule.isExported("p1", thisModule));

51
        assertTrue(targetModule.isExported("p1", targetModule));

52


53
        assertFalse(targetModule.isOpen("p1"));

54
        assertFalse(targetModule.isOpen("p1", thisModule));

55
        assertTrue(targetModule.isOpen("p1", targetModule));

56


57
        Class<?> clazz = Class.forName("p1.Public");

58
        Constructor<?> ctor1 = clazz.getConstructor();   // public

59
        Constructor<?> ctor2 = clazz.getDeclaredConstructor(Void.class); // non-public

60


61
        Field f1 = clazz.getField("f1");    // public

62
        Field f2 = clazz.getDeclaredField("f2");    // non-public

63


64
        Method m1 = clazz.getMethod("foo");  // public

65
        Method m2 = clazz.getDeclaredMethod("bar");  // non-public

66


67
        tryAccessConstructor(ctor1, true);

68
        tryAccessConstructor(ctor2, false);

69
        tryAccessMethod(m1, true);

70
        tryAccessMethod(m2, false);

71
        tryAccessObjectField(f1, true);

72
        tryAccessObjectField(f2, false);

73


74
        trySetAccessible(ctor1, true);

75
        trySetAccessible(ctor2, false);

76
        trySetAccessible(m1, true);

77
        trySetAccessible(m2, false);

78
        trySetAccessible(f1, true);

79
        trySetAccessible(f2, false);

80


81
        targetAddOpens("p1", thisModule);

82


83
        tryAccessConstructor(ctor1, true);

84
        tryAccessConstructor(ctor2, false);

85
        tryAccessMethod(m1, true);

86
        tryAccessMethod(m2, false);

87
        tryAccessObjectField(f1, true);

88
        tryAccessObjectField(f2, false);

89


90
        trySetAccessible(ctor1, true);

91
        trySetAccessible(ctor2, true);

92
        trySetAccessible(m1, true);

93
        trySetAccessible(m2, true);

94
        trySetAccessible(f1, true);

95
        trySetAccessible(f2, true);

96
    }

97


98
    static void testNonPublicClassInExportedPackage() throws Exception {

99
        Module thisModule = Main.class.getModule();

100
        Module targetModule = getTargetModule();

101


102
        assertTrue(targetModule.isExported("p2"));

103
        assertTrue(targetModule.isExported("p2", thisModule));

104
        assertTrue(targetModule.isExported("p2", targetModule));

105


106
        assertFalse(targetModule.isOpen("p2"));

107
        assertFalse(targetModule.isOpen("p2", thisModule));

108
        assertTrue(targetModule.isOpen("p1", targetModule));

109


110
        Class<?> clazz = Class.forName("p2.NonPublic");

111
        Constructor<?> ctor1 = clazz.getConstructor();

112
        Constructor<?> ctor2 = clazz.getDeclaredConstructor(Void.class);

113


114
        Field f1 = clazz.getField("f1");    // public

115
        Field f2 = clazz.getDeclaredField("f2");    // non-public

116


117
        Method m1 = clazz.getMethod("foo");  // public

118
        Method m2 = clazz.getDeclaredMethod("bar");  // non-public

119


120
        tryAccessConstructor(ctor1, false);

121
        tryAccessConstructor(ctor2, false);

122
        tryAccessMethod(m1, false);

123
        tryAccessMethod(m2, false);

124
        tryAccessObjectField(f1, false);

125
        tryAccessObjectField(f2, false);

126


127
        trySetAccessible(ctor1, false);

128
        trySetAccessible(ctor2, false);

129
        trySetAccessible(m1, false);

130
        trySetAccessible(m2, false);

131
        trySetAccessible(f1, false);

132
        trySetAccessible(f2, false);

133


134
        targetAddExports("p2", thisModule);

135


136
        tryAccessConstructor(ctor1, false);

137
        tryAccessConstructor(ctor2, false);

138
        tryAccessMethod(m1, false);

139
        tryAccessMethod(m2, false);

140
        tryAccessObjectField(f1, false);

141
        tryAccessObjectField(f2, false);

142


143
        trySetAccessible(ctor1, false);

144
        trySetAccessible(ctor2, false);

145
        trySetAccessible(m1, false);

146
        trySetAccessible(m2, false);

147
        trySetAccessible(f1, false);

148
        trySetAccessible(f2, false);

149


150
        targetAddOpens("p2", thisModule);

151


152
        tryAccessConstructor(ctor1, false);

153
        tryAccessConstructor(ctor2, false);

154
        tryAccessMethod(m1, false);

155
        tryAccessMethod(m2, false);

156
        tryAccessObjectField(f1, false);

157
        tryAccessObjectField(f2, false);

158


159
        trySetAccessible(ctor1, true);

160
        trySetAccessible(ctor2, true);

161
        trySetAccessible(m1, true);

162
        trySetAccessible(m2, true);

163
        trySetAccessible(f1, true);

164
        trySetAccessible(f2, true);

165
    }

166


167
    static void testPublicClassInNonExportedPackage() throws Exception {

168
        Module thisModule = Main.class.getModule();

169
        Module targetModule = getTargetModule();

170


171
        assertFalse(targetModule.isExported("q1"));

172
        assertFalse(targetModule.isExported("q1", thisModule));

173
        assertTrue(targetModule.isExported("q1", targetModule));

174


175
        assertFalse(targetModule.isOpen("q1"));

176
        assertFalse(targetModule.isOpen("q1", thisModule));

177
        assertTrue(targetModule.isOpen("q1", targetModule));

178


179
        Class<?> clazz = Class.forName("q1.Public");

180
        Constructor<?> ctor1 = clazz.getConstructor();  // public

181
        Constructor<?> ctor2 = clazz.getDeclaredConstructor(Void.class);  // non-public

182


183
        Field f1 = clazz.getField("f1");    // public

184
        Field f2 = clazz.getDeclaredField("f2");    // non-public

185


186
        Method m1 = clazz.getMethod("foo");  // public

187
        Method m2 = clazz.getDeclaredMethod("bar");  // non-public

188


189
        tryAccessConstructor(ctor1, false);

190
        tryAccessConstructor(ctor2, false);

191
        tryAccessMethod(m1, false);

192
        tryAccessMethod(m2, false);

193
        tryAccessObjectField(f1, false);

194
        tryAccessObjectField(f2, false);

195


196
        trySetAccessible(ctor1, false);

197
        trySetAccessible(ctor2, false);

198
        trySetAccessible(m1, false);

199
        trySetAccessible(m2, false);

200
        trySetAccessible(f1, false);

201
        trySetAccessible(f2, false);

202


203
        targetAddExports("q1", thisModule);

204


205
        tryAccessConstructor(ctor1, true);

206
        tryAccessConstructor(ctor2, false);

207
        tryAccessMethod(m1, true);

208
        tryAccessMethod(m2, false);

209
        tryAccessObjectField(f1, true);

210
        tryAccessObjectField(f2, false);

211


212
        trySetAccessible(ctor1, true);

213
        trySetAccessible(ctor2, false);

214
        trySetAccessible(m1, true);

215
        trySetAccessible(m2, false);

216
        trySetAccessible(f1, true);

217
        trySetAccessible(f2, false);

218


219
        targetAddOpens("q1", thisModule);

220


221
        tryAccessConstructor(ctor1, true);

222
        tryAccessConstructor(ctor1, false);

223
        tryAccessMethod(m1, true);

224
        tryAccessMethod(m2, false);

225
        tryAccessObjectField(f1, true);

226
        tryAccessObjectField(f2, false);

227


228
        trySetAccessible(ctor1, true);

229
        trySetAccessible(ctor2, true);

230
        trySetAccessible(m1, true);

231
        trySetAccessible(m2, true);

232
        trySetAccessible(f1, true);

233
        trySetAccessible(f2, true);

234
    }

235


236
    static void testNonPublicClassInNonExportedPackage() throws Exception {

237
        Module thisModule = Main.class.getModule();

238
        Module targetModule = getTargetModule();

239


240
        assertFalse(targetModule.isExported("q2"));

241
        assertFalse(targetModule.isExported("q2", thisModule));

242
        assertTrue(targetModule.isExported("q2", targetModule));

243


244
        assertFalse(targetModule.isOpen("q2"));

245
        assertFalse(targetModule.isOpen("q2", thisModule));

246
        assertTrue(targetModule.isOpen("q2", targetModule));

247


248
        Class<?> clazz = Class.forName("q2.NonPublic");

249
        Constructor<?> ctor1 = clazz.getConstructor();  // public

250
        Constructor<?> ctor2 = clazz.getDeclaredConstructor(Void.class);  // non-public

251


252
        Field f1 = clazz.getField("f1");    // public

253
        Field f2 = clazz.getDeclaredField("f2");    // non-public

254


255
        Method m1 = clazz.getMethod("foo");  // public

256
        Method m2 = clazz.getDeclaredMethod("bar");  // non-public

257


258
        tryAccessConstructor(ctor1, false);

259
        tryAccessConstructor(ctor2, false);

260
        tryAccessMethod(m1, false);

261
        tryAccessMethod(m2, false);

262
        tryAccessObjectField(f1, false);

263
        tryAccessObjectField(f2, false);

264


265
        trySetAccessible(ctor1, false);

266
        trySetAccessible(ctor2, false);

267
        trySetAccessible(m1, false);

268
        trySetAccessible(m2, false);

269
        trySetAccessible(f1, false);

270
        trySetAccessible(f2, false);

271


272
        targetAddExports("q2", thisModule);

273


274
        tryAccessConstructor(ctor1, false);

275
        tryAccessConstructor(ctor2, false);

276
        tryAccessMethod(m1, false);

277
        tryAccessMethod(m2, false);

278
        tryAccessObjectField(f1, false);

279
        tryAccessObjectField(f2, false);

280


281
        trySetAccessible(ctor1, false);

282
        trySetAccessible(ctor2, false);

283
        trySetAccessible(m1, false);

284
        trySetAccessible(m2, false);

285
        trySetAccessible(f1, false);

286
        trySetAccessible(f2, false);

287


288
        targetAddOpens("q2", thisModule);

289


290
        tryAccessConstructor(ctor1, false);

291
        tryAccessConstructor(ctor2, false);

292
        tryAccessMethod(m1, false);

293
        tryAccessMethod(m2, false);

294
        tryAccessObjectField(f1, false);

295
        tryAccessObjectField(f2, false);

296


297
        trySetAccessible(ctor1, true);

298
        trySetAccessible(m1, true);

299
        trySetAccessible(m2, true);

300
        trySetAccessible(f1, true);

301
        trySetAccessible(f2, true);

302
    }

303


304


305
    static Module getTargetModule() {

306
        return ModuleLayer.boot().findModule("target").get();

307
    }

308


309
    static void tryAccessConstructor(Constructor<?> ctor, boolean shouldSucceed) {

310
        try {

311
            ctor.newInstance();

312
            assertTrue(shouldSucceed);

313
        } catch (Exception e) {

314
            assertFalse(shouldSucceed);

315
        }

316
    }

317


318
    static void tryAccessMethod(Method method, boolean shouldSucceed) {

319
        try {

320
            method.invoke(null);

321
            assertTrue(shouldSucceed);

322
        } catch (Exception e) {

323
            e.printStackTrace();

324
            assertFalse(shouldSucceed);

325
        }

326
    }

327


328
    static void tryAccessObjectField(Field f, boolean shouldSucceed) {

329
        try {

330
            f.get(null);

331
            assertTrue(shouldSucceed);

332
        } catch (Exception e) {

333
            assertFalse(shouldSucceed);

334
        }

335
        try {

336
            f.set(null, new Object());

337
            assertTrue(shouldSucceed);

338
        } catch (Exception e) {

339
            assertFalse(shouldSucceed);

340
        }

341
    }

342


343
    static void trySetAccessible(AccessibleObject ao, boolean shouldSucceed) {

344
        try {

345
            ao.setAccessible(true);

346
            assertTrue(shouldSucceed);

347
        } catch (Exception e) {

348
            assertFalse(shouldSucceed);

349
        }

350
    }

351


352
    /**

353
     * Update target module to export a package to the given module.

354
     */

355
    static void targetAddExports(String pn, Module who) throws Exception {

356
        Class<?> helper = Class.forName("p1.Helper");

357
        Method m = helper.getMethod("addExports", String.class, Module.class);

358
        m.invoke(null, pn, who);

359
    }

360


361
    /**

362
     * Update target module to open a package to the given module.

363
     */

364
    static void targetAddOpens(String pn, Module who) throws Exception {

365
        Class<?> helper = Class.forName("p1.Helper");

366
        Method m = helper.getMethod("addOpens", String.class, Module.class);

367
        m.invoke(null, pn, who);

368
    }

369


370
    static void assertTrue(boolean expr) {

371
        if (!expr) throw new RuntimeException();

372
    }

373


374
    static void assertFalse(boolean expr) {

375
        assertTrue(!expr);

376
    }

377
}

378


379