28 * @build BasicLayerTest ModuleUtils
29 * @compile layertest/Test.java
30 * @run testng BasicLayerTest
31 * @summary Basic tests for java.lang.reflect.Layer
32 */
33
34 import java.lang.module.Configuration;
35 import java.lang.module.ModuleDescriptor;
36 import java.lang.module.ModuleDescriptor.Requires;
37 import java.lang.module.ModuleFinder;
38 import java.lang.reflect.Layer;
39 import java.lang.reflect.LayerInstantiationException;
40 import java.lang.reflect.Module;
41 import java.util.HashMap;
42 import java.util.Map;
43 import java.util.Optional;
44 import java.util.Set;
45 import java.util.stream.Collectors;
46
47 import jdk.internal.misc.SharedSecrets;
48 import org.testng.annotations.Test;
49 import static org.testng.Assert.*;
50
51 @Test
52 public class BasicLayerTest {
53
54 /**
55 * Creates a "non-strict" builder for building a module. This allows the
56 * test the create ModuleDescriptor objects that do not require java.base.
57 */
58 private static ModuleDescriptor.Builder newBuilder(String mn) {
59 return SharedSecrets.getJavaLangModuleAccess()
60 .newModuleBuilder(mn, false, Set.of());
61 }
62
63 /**
64 * Exercise Layer.empty()
65 */
66 public void testEmpty() {
67 Layer emptyLayer = Layer.empty();
653 assertFalse(m1.canRead(m4));
654
655 assertTrue(m2.canRead(m1));
656 assertTrue(m2.canRead(m2));
657 assertFalse(m1.canRead(m3));
658 assertFalse(m1.canRead(m4));
659
660 assertTrue(m3.canRead(m1));
661 assertTrue(m3.canRead(m2));
662 assertTrue(m3.canRead(m3));
663 assertFalse(m3.canRead(m4));
664
665 assertTrue(m4.canRead(m1));
666 assertTrue(m4.canRead(m2));
667 assertTrue(m4.canRead(m3));
668 assertTrue(m4.canRead(m4));
669 }
670
671
672 /**
673 * Attempt to use Layer defineModules to create a layer with a module
674 * defined to a class loader that already has a module of the same name
675 * defined to the class loader.
676 */
677 @Test(expectedExceptions = { LayerInstantiationException.class })
678 public void testModuleAlreadyDefinedToLoader() {
679
680 ModuleDescriptor md = newBuilder("m")
681 .requires("java.base")
682 .build();
683
684 ModuleFinder finder = ModuleUtils.finderOf(md);
685
686 Configuration parent = Layer.boot().configuration();
687
688 Configuration cf = parent.resolve(finder, ModuleFinder.of(), Set.of("m"));
689
690 ClassLoader loader = new ClassLoader() { };
691
692 Layer.boot().defineModules(cf, mn -> loader);
779
780 ClassLoader scl = ClassLoader.getSystemClassLoader();
781
782 try {
783 Layer.boot().defineModules(cf, mn -> new ClassLoader() { });
784 assertTrue(false);
785 } catch (LayerInstantiationException e) { }
786
787 try {
788 Layer.boot().defineModulesWithOneLoader(cf, scl);
789 assertTrue(false);
790 } catch (LayerInstantiationException e) { }
791
792 try {
793 Layer.boot().defineModulesWithManyLoaders(cf, scl);
794 assertTrue(false);
795 } catch (LayerInstantiationException e) { }
796 }
797
798
799 /**
800 * Attempt to create a Layer with a module containing a "java." package.
801 * This should only be allowed when the module is defined to the platform
802 * class loader.
803 */
804 @Test(enabled = false)
805 public void testLayerWithJavaPackage() {
806 ModuleDescriptor descriptor = newBuilder("foo")
807 .packages(Set.of("java.foo"))
808 .build();
809
810 ModuleFinder finder = ModuleUtils.finderOf(descriptor);
811
812 Configuration cf = Layer.boot()
813 .configuration()
814 .resolve(finder, ModuleFinder.of(), Set.of("foo"));
815 assertTrue(cf.modules().size() == 1);
816
817 ClassLoader pcl = ClassLoader.getPlatformClassLoader();
818 ClassLoader scl = ClassLoader.getSystemClassLoader();
819
820 try {
821 Layer.boot().defineModules(cf, mn -> new ClassLoader() { });
822 assertTrue(false);
823 } catch (LayerInstantiationException e) { }
824
825 try {
826 Layer.boot().defineModulesWithOneLoader(cf, scl);
827 assertTrue(false);
828 } catch (LayerInstantiationException e) { }
829
830 try {
831 Layer.boot().defineModulesWithManyLoaders(cf, scl);
832 assertTrue(false);
833 } catch (LayerInstantiationException e) { }
834
835 // create layer with module defined to platform class loader
836 Layer layer = Layer.boot().defineModules(cf, mn -> pcl);
837 Optional<Module> om = layer.findModule("foo");
838 assertTrue(om.isPresent());
839 Module foo = om.get();
840 assertTrue(foo.getClassLoader() == pcl);
841 assertTrue(foo.getPackages().length == 1);
842 assertTrue(foo.getPackages()[0].equals("java.foo"));
843 }
844
845
846 /**
847 * Attempt to create a Layer with a module defined to the boot loader
848 */
849 @Test(expectedExceptions = { LayerInstantiationException.class })
850 public void testLayerWithBootLoader() {
851 ModuleDescriptor descriptor = newBuilder("m1")
852 .build();
853
854 ModuleFinder finder = ModuleUtils.finderOf(descriptor);
855
856 Configuration cf = Layer.boot()
857 .configuration()
858 .resolve(finder, ModuleFinder.of(), Set.of("m1"));
859 assertTrue(cf.modules().size() == 1);
860
861 Layer.boot().defineModules(cf, mn -> null );
862 }
|
28 * @build BasicLayerTest ModuleUtils
29 * @compile layertest/Test.java
30 * @run testng BasicLayerTest
31 * @summary Basic tests for java.lang.reflect.Layer
32 */
33
34 import java.lang.module.Configuration;
35 import java.lang.module.ModuleDescriptor;
36 import java.lang.module.ModuleDescriptor.Requires;
37 import java.lang.module.ModuleFinder;
38 import java.lang.reflect.Layer;
39 import java.lang.reflect.LayerInstantiationException;
40 import java.lang.reflect.Module;
41 import java.util.HashMap;
42 import java.util.Map;
43 import java.util.Optional;
44 import java.util.Set;
45 import java.util.stream.Collectors;
46
47 import jdk.internal.misc.SharedSecrets;
48
49 import org.testng.annotations.DataProvider;
50 import org.testng.annotations.Test;
51 import static org.testng.Assert.*;
52
53 @Test
54 public class BasicLayerTest {
55
56 /**
57 * Creates a "non-strict" builder for building a module. This allows the
58 * test the create ModuleDescriptor objects that do not require java.base.
59 */
60 private static ModuleDescriptor.Builder newBuilder(String mn) {
61 return SharedSecrets.getJavaLangModuleAccess()
62 .newModuleBuilder(mn, false, Set.of());
63 }
64
65 /**
66 * Exercise Layer.empty()
67 */
68 public void testEmpty() {
69 Layer emptyLayer = Layer.empty();
655 assertFalse(m1.canRead(m4));
656
657 assertTrue(m2.canRead(m1));
658 assertTrue(m2.canRead(m2));
659 assertFalse(m1.canRead(m3));
660 assertFalse(m1.canRead(m4));
661
662 assertTrue(m3.canRead(m1));
663 assertTrue(m3.canRead(m2));
664 assertTrue(m3.canRead(m3));
665 assertFalse(m3.canRead(m4));
666
667 assertTrue(m4.canRead(m1));
668 assertTrue(m4.canRead(m2));
669 assertTrue(m4.canRead(m3));
670 assertTrue(m4.canRead(m4));
671 }
672
673
674 /**
675 * Test layers with a qualified export. The module exporting the package
676 * does not read the target module.
677 *
678 * m1 { exports p to m2 }
679 * m2 { }
680 */
681 public void testQualifiedExports1() {
682 ModuleDescriptor descriptor1 = newBuilder("m1").
683 exports("p", Set.of("m2"))
684 .build();
685
686 ModuleDescriptor descriptor2 = newBuilder("m2")
687 .build();
688
689 ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
690
691 Configuration cf = resolve(finder1, "m1", "m2");
692
693 ClassLoader cl = new ClassLoader() { };
694 Layer layer = Layer.empty().defineModules(cf, mn -> cl);
695 assertTrue(layer.modules().size() == 2);
696
697 Module m1 = layer.findModule("m1").get();
698 Module m2 = layer.findModule("m2").get();
699
700 // check m1 exports p to m2
701 assertFalse(m1.isExported("p"));
702 assertTrue(m1.isExported("p", m2));
703 assertFalse(m1.isOpen("p", m2));
704 }
705
706
707 /**
708 * Test layers with a qualified export. The module exporting the package
709 * reads the target module.
710 *
711 * m1 { exports p to m2; }
712 * m2 { requires m1; }
713 */
714 public void testQualifiedExports2() {
715 ModuleDescriptor descriptor1 = newBuilder("m1")
716 .exports("p", Set.of("m2"))
717 .build();
718
719 ModuleDescriptor descriptor2 = newBuilder("m2")
720 .requires("m1")
721 .build();
722
723 ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
724
725 Configuration cf = resolve(finder1, "m2");
726 ClassLoader cl = new ClassLoader() { };
727 Layer layer = Layer.empty().defineModules(cf, mn -> cl);
728 assertTrue(layer.modules().size() == 2);
729
730 Module m1 = layer.findModule("m1").get();
731 Module m2 = layer.findModule("m2").get();
732
733 // check m1 exports p to m2
734 assertFalse(m1.isExported("p"));
735 assertTrue(m1.isExported("p", m2));
736 assertFalse(m1.isOpen("p", m2));
737 }
738
739
740 /**
741 * Test layers with a qualified export. The module exporting the package
742 * does not read the target module in the parent layer.
743 *
744 * - Configuration/layer1: m1 { }
745 * - Configuration/layer2: m2 { exports p to m1; }
746 */
747 public void testQualifiedExports3() {
748 // create layer1 with m1
749 ModuleDescriptor descriptor1 = newBuilder("m1").build();
750 ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
751 Configuration cf1 = resolve(finder1, "m1");
752 ClassLoader cl1 = new ClassLoader() { };
753 Layer layer1 = Layer.empty().defineModules(cf1, mn -> cl1);
754 assertTrue(layer1.modules().size() == 1);
755
756 // create layer2 with m2
757 ModuleDescriptor descriptor2 = newBuilder("m2")
758 .exports("p", Set.of("m1"))
759 .build();
760 ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);
761 Configuration cf2 = resolve(cf1, finder2, "m2");
762 ClassLoader cl2 = new ClassLoader() { };
763 Layer layer2 = layer1.defineModules(cf2, mn -> cl2);
764 assertTrue(layer2.modules().size() == 1);
765
766 Module m1 = layer1.findModule("m1").get();
767 Module m2 = layer2.findModule("m2").get();
768
769 // check m2 exports p to layer1/m1
770 assertFalse(m2.isExported("p"));
771 assertTrue(m2.isExported("p", m1));
772 assertFalse(m2.isOpen("p", m1));
773 }
774
775
776 /**
777 * Test layers with a qualified export. The module exporting the package
778 * reads the target module in the parent layer.
779 *
780 * - Configuration/layer1: m1 { }
781 * - Configuration/layer2: m2 { requires m1; exports p to m1; }
782 */
783 public void testQualifiedExports4() {
784 // create layer1 with m1
785 ModuleDescriptor descriptor1 = newBuilder("m1").build();
786 ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
787 Configuration cf1 = resolve(finder1, "m1");
788 ClassLoader cl1 = new ClassLoader() { };
789 Layer layer1 = Layer.empty().defineModules(cf1, mn -> cl1);
790 assertTrue(layer1.modules().size() == 1);
791
792 // create layer2 with m2
793 ModuleDescriptor descriptor2 = newBuilder("m2")
794 .requires("m1")
795 .exports("p", Set.of("m1"))
796 .build();
797 ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);
798 Configuration cf2 = resolve(cf1, finder2, "m2");
799 ClassLoader cl2 = new ClassLoader() { };
800 Layer layer2 = layer1.defineModules(cf2, mn -> cl2);
801 assertTrue(layer2.modules().size() == 1);
802
803 Module m1 = layer1.findModule("m1").get();
804 Module m2 = layer2.findModule("m2").get();
805
806 // check m2 exports p to layer1/m1
807 assertFalse(m2.isExported("p"));
808 assertTrue(m2.isExported("p", m1));
809 assertFalse(m2.isOpen("p", m1));
810 }
811
812 /**
813 * Test layers with a qualified export. The module exporting the package
814 * does not read the target module.
815 *
816 * - Configuration/layer1: m1
817 * - Configuration/layer2: m1, m2 { exports p to m1; }
818 */
819 public void testQualifiedExports5() {
820 // create layer1 with m1
821 ModuleDescriptor descriptor1 = newBuilder("m1").build();
822 ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
823 Configuration cf1 = resolve(finder1, "m1");
824 ClassLoader cl1 = new ClassLoader() { };
825 Layer layer1 = Layer.empty().defineModules(cf1, mn -> cl1);
826 assertTrue(layer1.modules().size() == 1);
827
828 // create layer2 with m1 and m2
829 ModuleDescriptor descriptor2 = newBuilder("m2").exports("p", Set.of("m1")).build();
830 ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1, descriptor2);
831 Configuration cf2 = resolve(cf1, finder2, "m1", "m2");
832 ClassLoader cl2 = new ClassLoader() { };
833 Layer layer2 = layer1.defineModules(cf2, mn -> cl2);
834 assertTrue(layer2.modules().size() == 2);
835
836 Module m1_v1 = layer1.findModule("m1").get();
837 Module m1_v2 = layer2.findModule("m1").get();
838 Module m2 = layer2.findModule("m2").get();
839
840 // check m2 exports p to layer2/m2
841 assertFalse(m2.isExported("p"));
842 assertTrue(m2.isExported("p", m1_v2));
843 assertFalse(m2.isExported("p", m1_v1));
844 }
845
846
847 /**
848 * Test layers with a qualified export. The module exporting the package
849 * reads the target module in the parent layer (due to requires transitive).
850 *
851 * - Configuration/layer1: m1, m2 { requires transitive m1; }
852 * - Configuration/layer2: m1, m3 { requires m2; exports p to m1; }
853 */
854 public void testQualifiedExports6() {
855 // create layer1 with m1 and m2
856 ModuleDescriptor descriptor1 = newBuilder("m1").build();
857 ModuleDescriptor descriptor2 = newBuilder("m2")
858 .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
859 .build();
860 ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
861 Configuration cf1 = resolve(finder1, "m2");
862 ClassLoader loader1 = new ClassLoader() { };
863 Layer layer1 = Layer.empty().defineModules(cf1, mn -> loader1);
864 assertTrue(layer1.modules().size() == 2);
865
866 // create layer2 with m1 and m3
867 ModuleDescriptor descriptor3 = newBuilder("m3")
868 .requires("m2")
869 .exports("p", Set.of("m1"))
870 .build();
871 ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1, descriptor3);
872 Configuration cf2 = resolve(cf1, finder2, "m1", "m3");
873 ClassLoader loader2 = new ClassLoader() { };
874 Layer layer2 = layer1.defineModules(cf2, mn -> loader2);
875 assertTrue(layer2.modules().size() == 2);
876
877 Module m1_v1 = layer1.findModule("m1").get();
878 Module m2 = layer1.findModule("m2").get();
879
880 Module m1_v2 = layer2.findModule("m1").get();
881 Module m3 = layer2.findModule("m3").get();
882
883 assertTrue(m3.canRead(m1_v1));
884 assertFalse(m3.canRead(m1_v2));
885
886 assertFalse(m3.isExported("p"));
887 assertTrue(m3.isExported("p", m1_v1));
888 assertFalse(m3.isExported("p", m1_v2));
889 assertFalse(m3.isExported("p", m2));
890 }
891
892
893 /**
894 * Test layers with a qualified export. The target module is not in any layer.
895 *
896 * - Configuration/layer1: m1 { }
897 * - Configuration/layer2: m2 { exports p to m3; }
898 */
899 public void testQualifiedExports7() {
900 // create layer1 with m1
901 ModuleDescriptor descriptor1 = newBuilder("m1").build();
902 ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
903 Configuration cf1 = resolve(finder1, "m1");
904 ClassLoader cl1 = new ClassLoader() { };
905 Layer layer1 = Layer.empty().defineModules(cf1, mn -> cl1);
906 assertTrue(layer1.modules().size() == 1);
907
908 // create layer2 with m2
909 ModuleDescriptor descriptor2 = newBuilder("m2")
910 .exports("p", Set.of("m3"))
911 .build();
912 ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);
913 Configuration cf2 = resolve(cf1, finder2, "m2");
914 ClassLoader cl2 = new ClassLoader() { };
915 Layer layer2 = layer1.defineModules(cf2, mn -> cl2);
916 assertTrue(layer2.modules().size() == 1);
917
918 Module m1 = layer1.findModule("m1").get();
919 Module m2 = layer2.findModule("m2").get();
920
921 // check m2 does not export p to anyone
922 assertFalse(m2.isExported("p"));
923 assertFalse(m2.isExported("p", m1));
924 }
925
926 /**
927 * Attempt to use Layer defineModules to create a layer with a module
928 * defined to a class loader that already has a module of the same name
929 * defined to the class loader.
930 */
931 @Test(expectedExceptions = { LayerInstantiationException.class })
932 public void testModuleAlreadyDefinedToLoader() {
933
934 ModuleDescriptor md = newBuilder("m")
935 .requires("java.base")
936 .build();
937
938 ModuleFinder finder = ModuleUtils.finderOf(md);
939
940 Configuration parent = Layer.boot().configuration();
941
942 Configuration cf = parent.resolve(finder, ModuleFinder.of(), Set.of("m"));
943
944 ClassLoader loader = new ClassLoader() { };
945
946 Layer.boot().defineModules(cf, mn -> loader);
1033
1034 ClassLoader scl = ClassLoader.getSystemClassLoader();
1035
1036 try {
1037 Layer.boot().defineModules(cf, mn -> new ClassLoader() { });
1038 assertTrue(false);
1039 } catch (LayerInstantiationException e) { }
1040
1041 try {
1042 Layer.boot().defineModulesWithOneLoader(cf, scl);
1043 assertTrue(false);
1044 } catch (LayerInstantiationException e) { }
1045
1046 try {
1047 Layer.boot().defineModulesWithManyLoaders(cf, scl);
1048 assertTrue(false);
1049 } catch (LayerInstantiationException e) { }
1050 }
1051
1052
1053 @DataProvider(name = "javaPackages")
1054 public Object[][] javaPackages() {
1055 return new Object[][] { { "m1", "java" }, { "m2", "java.x" } };
1056 }
1057
1058 /**
1059 * Attempt to create a Layer with a module containing a "java" package.
1060 * This should only be allowed when the module is defined to the platform
1061 * class loader.
1062 */
1063 @Test(dataProvider = "javaPackages")
1064 public void testLayerWithJavaPackage(String mn, String pn) {
1065 ModuleDescriptor descriptor = newBuilder(mn).packages(Set.of(pn)).build();
1066 ModuleFinder finder = ModuleUtils.finderOf(descriptor);
1067
1068 Configuration cf = Layer.boot()
1069 .configuration()
1070 .resolve(finder, ModuleFinder.of(), Set.of(mn));
1071 assertTrue(cf.modules().size() == 1);
1072
1073 ClassLoader pcl = ClassLoader.getPlatformClassLoader();
1074 ClassLoader scl = ClassLoader.getSystemClassLoader();
1075
1076 try {
1077 Layer.boot().defineModules(cf, _mn -> new ClassLoader() { });
1078 assertTrue(false);
1079 } catch (LayerInstantiationException e) { }
1080
1081 try {
1082 Layer.boot().defineModulesWithOneLoader(cf, scl);
1083 assertTrue(false);
1084 } catch (LayerInstantiationException e) { }
1085
1086 try {
1087 Layer.boot().defineModulesWithManyLoaders(cf, scl);
1088 assertTrue(false);
1089 } catch (LayerInstantiationException e) { }
1090
1091 // create layer with module defined to platform class loader
1092 Layer layer = Layer.boot().defineModules(cf, _mn -> pcl);
1093 Optional<Module> om = layer.findModule(mn);
1094 assertTrue(om.isPresent());
1095 Module foo = om.get();
1096 assertTrue(foo.getClassLoader() == pcl);
1097 assertTrue(foo.getPackages().length == 1);
1098 assertTrue(foo.getPackages()[0].equals(pn));
1099 }
1100
1101
1102 /**
1103 * Attempt to create a Layer with a module defined to the boot loader
1104 */
1105 @Test(expectedExceptions = { LayerInstantiationException.class })
1106 public void testLayerWithBootLoader() {
1107 ModuleDescriptor descriptor = newBuilder("m1")
1108 .build();
1109
1110 ModuleFinder finder = ModuleUtils.finderOf(descriptor);
1111
1112 Configuration cf = Layer.boot()
1113 .configuration()
1114 .resolve(finder, ModuleFinder.of(), Set.of("m1"));
1115 assertTrue(cf.modules().size() == 1);
1116
1117 Layer.boot().defineModules(cf, mn -> null );
1118 }
|