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.Layer;

    30 import java.lang.reflect.Method;

    31 import java.lang.reflect.Module;

    32 

    33 /**

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

    35  * exported and non-exported packages.

    36  */

    37 

    38 public class Main {

    39 

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

    41         testPublicClassInExportedPackage();

    42         testNonPublicClassInExportedPackage();

    43         testPublicClassInNonExportedPackage();

    44         testNonPublicClassInNonExportedPackage();

    45     }

    46 

    47     static void testPublicClassInExportedPackage() throws Exception {

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

    49         Module targetModule = getTargetModule();

    50 

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

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

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

    54 

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

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

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

    58 

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

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

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

    62 

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

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

    65 

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

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

    68 

    69         tryAccessConstructor(ctor1, true);

    70         tryAccessConstructor(ctor2, false);

    71         tryAccessMethod(m1, true);

    72         tryAccessMethod(m2, false);

    73         tryAccessObjectField(f1, true);

    74         tryAccessObjectField(f2, false);

    75 

    76         trySetAccessible(ctor1, true);

    77         trySetAccessible(ctor2, false);

    78         trySetAccessible(m1, true);

    79         trySetAccessible(m2, false);

    80         trySetAccessible(f1, true);

    81         trySetAccessible(f2, false);

    82 

    83         targetAddOpens("p1", thisModule);

    84 

    85         tryAccessConstructor(ctor1, true);

    86         tryAccessConstructor(ctor2, false);

    87         tryAccessMethod(m1, true);

    88         tryAccessMethod(m2, false);

    89         tryAccessObjectField(f1, true);

    90         tryAccessObjectField(f2, false);

    91 

    92         trySetAccessible(ctor1, true);

    93         trySetAccessible(ctor2, true);

    94         trySetAccessible(m1, true);

    95         trySetAccessible(m2, true);

    96         trySetAccessible(f1, true);

    97         trySetAccessible(f2, true);

    98     }

    99 

   100     static void testNonPublicClassInExportedPackage() throws Exception {

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

   102         Module targetModule = getTargetModule();

   103 

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

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

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

   107 

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

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

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

   111 

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

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

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

   115 

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

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

   118 

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

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

   121 

   122         tryAccessConstructor(ctor1, false);

   123         tryAccessConstructor(ctor2, false);

   124         tryAccessMethod(m1, false);

   125         tryAccessMethod(m2, false);

   126         tryAccessObjectField(f1, false);

   127         tryAccessObjectField(f2, false);

   128 

   129         trySetAccessible(ctor1, false);

   130         trySetAccessible(ctor2, false);

   131         trySetAccessible(m1, false);

   132         trySetAccessible(m2, false);

   133         trySetAccessible(f1, false);

   134         trySetAccessible(f2, false);

   135 

   136         targetAddExports("p2", thisModule);

   137 

   138         tryAccessConstructor(ctor1, false);

   139         tryAccessConstructor(ctor2, false);

   140         tryAccessMethod(m1, false);

   141         tryAccessMethod(m2, false);

   142         tryAccessObjectField(f1, false);

   143         tryAccessObjectField(f2, false);

   144 

   145         trySetAccessible(ctor1, false);

   146         trySetAccessible(ctor2, false);

   147         trySetAccessible(m1, false);

   148         trySetAccessible(m2, false);

   149         trySetAccessible(f1, false);

   150         trySetAccessible(f2, false);

   151 

   152         targetAddOpens("p2", thisModule);

   153 

   154         tryAccessConstructor(ctor1, false);

   155         tryAccessConstructor(ctor2, false);

   156         tryAccessMethod(m1, false);

   157         tryAccessMethod(m2, false);

   158         tryAccessObjectField(f1, false);

   159         tryAccessObjectField(f2, false);

   160 

   161         trySetAccessible(ctor1, true);

   162         trySetAccessible(ctor2, true);

   163         trySetAccessible(m1, true);

   164         trySetAccessible(m2, true);

   165         trySetAccessible(f1, true);

   166         trySetAccessible(f2, true);

   167     }

   168 

   169     static void testPublicClassInNonExportedPackage() throws Exception {

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

   171         Module targetModule = getTargetModule();

   172 

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

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

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

   176 

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

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

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

   180 

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

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

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

   184 

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

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

   187 

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

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

   190 

   191         tryAccessConstructor(ctor1, false);

   192         tryAccessConstructor(ctor2, false);

   193         tryAccessMethod(m1, false);

   194         tryAccessMethod(m2, false);

   195         tryAccessObjectField(f1, false);

   196         tryAccessObjectField(f2, false);

   197 

   198         trySetAccessible(ctor1, false);

   199         trySetAccessible(ctor2, false);

   200         trySetAccessible(m1, false);

   201         trySetAccessible(m2, false);

   202         trySetAccessible(f1, false);

   203         trySetAccessible(f2, false);

   204 

   205         targetAddExports("q1", thisModule);

   206 

   207         tryAccessConstructor(ctor1, true);

   208         tryAccessConstructor(ctor2, false);

   209         tryAccessMethod(m1, true);

   210         tryAccessMethod(m2, false);

   211         tryAccessObjectField(f1, true);

   212         tryAccessObjectField(f2, false);

   213 

   214         trySetAccessible(ctor1, true);

   215         trySetAccessible(ctor2, false);

   216         trySetAccessible(m1, true);

   217         trySetAccessible(m2, false);

   218         trySetAccessible(f1, true);

   219         trySetAccessible(f2, false);

   220 

   221         targetAddOpens("q1", thisModule);

   222 

   223         tryAccessConstructor(ctor1, true);

   224         tryAccessConstructor(ctor1, false);

   225         tryAccessMethod(m1, true);

   226         tryAccessMethod(m2, false);

   227         tryAccessObjectField(f1, true);

   228         tryAccessObjectField(f2, false);

   229 

   230         trySetAccessible(ctor1, true);

   231         trySetAccessible(ctor2, true);

   232         trySetAccessible(m1, true);

   233         trySetAccessible(m2, true);

   234         trySetAccessible(f1, true);

   235         trySetAccessible(f2, true);

   236     }

   237 

   238     static void testNonPublicClassInNonExportedPackage() throws Exception {

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

   240         Module targetModule = getTargetModule();

   241 

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

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

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

   245 

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

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

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

   249 

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

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

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

   253 

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

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

   256 

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

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

   259 

   260         tryAccessConstructor(ctor1, false);

   261         tryAccessConstructor(ctor2, false);

   262         tryAccessMethod(m1, false);

   263         tryAccessMethod(m2, false);

   264         tryAccessObjectField(f1, false);

   265         tryAccessObjectField(f2, false);

   266 

   267         trySetAccessible(ctor1, false);

   268         trySetAccessible(ctor2, false);

   269         trySetAccessible(m1, false);

   270         trySetAccessible(m2, false);

   271         trySetAccessible(f1, false);

   272         trySetAccessible(f2, false);

   273 

   274         targetAddExports("q2", thisModule);

   275 

   276         tryAccessConstructor(ctor1, false);

   277         tryAccessConstructor(ctor2, false);

   278         tryAccessMethod(m1, false);

   279         tryAccessMethod(m2, false);

   280         tryAccessObjectField(f1, false);

   281         tryAccessObjectField(f2, false);

   282 

   283         trySetAccessible(ctor1, false);

   284         trySetAccessible(ctor2, false);

   285         trySetAccessible(m1, false);

   286         trySetAccessible(m2, false);

   287         trySetAccessible(f1, false);

   288         trySetAccessible(f2, false);

   289 

   290         targetAddOpens("q2", thisModule);

   291 

   292         tryAccessConstructor(ctor1, false);

   293         tryAccessConstructor(ctor2, false);

   294         tryAccessMethod(m1, false);

   295         tryAccessMethod(m2, false);

   296         tryAccessObjectField(f1, false);

   297         tryAccessObjectField(f2, false);

   298 

   299         trySetAccessible(ctor1, true);

   300         trySetAccessible(m1, true);

   301         trySetAccessible(m2, true);

   302         trySetAccessible(f1, true);

   303         trySetAccessible(f2, true);

   304     }

   305 

   306 

   307     static Module getTargetModule() {

   308         return Layer.boot().findModule("target").get();

   309     }

   310 

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

   312         try {

   313             ctor.newInstance();

   314             assertTrue(shouldSucceed);

   315         } catch (Exception e) {

   316             assertFalse(shouldSucceed);

   317         }

   318     }

   319 

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

   321         try {

   322             method.invoke(null);

   323             assertTrue(shouldSucceed);

   324         } catch (Exception e) {

   325             e.printStackTrace();

   326             assertFalse(shouldSucceed);

   327         }

   328     }

   329 

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

   331         try {

   332             f.get(null);

   333             assertTrue(shouldSucceed);

   334         } catch (Exception e) {

   335             assertFalse(shouldSucceed);

   336         }

   337         try {

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

   339             assertTrue(shouldSucceed);

   340         } catch (Exception e) {

   341             assertFalse(shouldSucceed);

   342         }

   343     }

   344 

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

   346         try {

   347             ao.setAccessible(true);

   348             assertTrue(shouldSucceed);

   349         } catch (Exception e) {

   350             assertFalse(shouldSucceed);

   351         }

   352     }

   353 

   354     /**

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

   356      */

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

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

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

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

   361     }

   362 

   363     /**

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

   365      */

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

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

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

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

   370     }

   371 

   372     static void assertTrue(boolean expr) {

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

   374     }

   375 

   376     static void assertFalse(boolean expr) {

   377         assertTrue(!expr);

   378     }

   379 }