Debian Codegraph @

src/test/java/org/jboss/modules/ModuleExportTest.java

raw
1 /*
2 * JBoss, Home of Professional Open Source.
3 * Copyright 2014 Red Hat, Inc., and individual contributors
4 * as indicated by the @author tags.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 package org.jboss.modules;
20
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertTrue;
23
24 import java.lang.reflect.Field;
25 import java.util.Collections;
26 import java.util.HashSet;
27 import java.util.List;
28 import java.util.Map;
29 import java.util.Set;
30
31 import org.jboss.modules.filter.PathFilters;
32 import org.jboss.modules.test.ImportedClass;
33 import org.jboss.modules.util.TestModuleLoader;
34 import org.jboss.modules.util.TestResourceLoader;
35 import org.junit.Ignore;
36 import org.junit.Test;
37
38 /**
39 * Test to verify the module export dependencies and imports are created correctly. Each module should have an entry
40 * directly to the module that has an exported path.
41 *
42 * @author John E. Bailey
43 */
44 public class ModuleExportTest extends AbstractModuleTestCase {
45
46 private static final String MODULE_A = "a";
47 private static final String MODULE_B = "b";
48 private static final String MODULE_C = "c";
49 private static final String MODULE_D = "d";
50
51 @Test
52 public void testExportDependencies() throws Exception {
53 final TestModuleLoader moduleLoader = new TestModuleLoader();
54
55 ModuleSpec.Builder builder = ModuleSpec.build(MODULE_A);
56 builder.addDependency(new ModuleDependencySpecBuilder()
57 .setName(MODULE_B.toString())
58 .setExport(true)
59 .build());
60 moduleLoader.addModuleSpec(builder.create());
61
62 builder = ModuleSpec.build(MODULE_B);
63 builder.addDependency(new ModuleDependencySpecBuilder()
64 .setName(MODULE_C.toString())
65 .setExport(true)
66 .build());
67 builder.addDependency(new ModuleDependencySpecBuilder()
68 .setName(MODULE_D.toString())
69 .build());
70 moduleLoader.addModuleSpec(builder.create());
71
72 builder = ModuleSpec.build(MODULE_C);
73 moduleLoader.addModuleSpec(builder.create());
74
75 builder = ModuleSpec.build(MODULE_D);
76 moduleLoader.addModuleSpec(builder.create());
77
78 Module module = moduleLoader.loadModule(MODULE_A);
79 final Set<String> dependencyExports = new HashSet<>();
80 getExportedModuleDeps(module, dependencyExports);
81 assertEquals(2, dependencyExports.size());
82 assertTrue(dependencyExports.contains(MODULE_B));
83 assertTrue(dependencyExports.contains(MODULE_C));
84
85 dependencyExports.clear();
86 module = moduleLoader.loadModule(MODULE_B);
87 getExportedModuleDeps(module, dependencyExports);
88 assertEquals(1, dependencyExports.size());
89 assertTrue(dependencyExports.contains(MODULE_C));
90
91 dependencyExports.clear();
92 module = moduleLoader.loadModule(MODULE_C);
93 getExportedModuleDeps(module, dependencyExports);
94 assertEquals(0, dependencyExports.size());
95
96 dependencyExports.clear();
97 module = moduleLoader.loadModule(MODULE_D);
98 getExportedModuleDeps(module, dependencyExports);
99 assertEquals(0, dependencyExports.size());
100 }
101
102 private static void getExportedModuleDeps(final Module module, final Set<String> dependencyExports) throws ModuleLoadException {
103 getExportedModuleDeps(module, new HashSet<Module>(Collections.singleton(module)), dependencyExports);
104 }
105
106 private static void getExportedModuleDeps(final Module module, final Set<Module> visited, final Set<String> dependencyExports) throws ModuleLoadException {
107 for (Dependency dependency : module.getDependenciesInternal()) {
108 if (dependency instanceof ModuleDependency && dependency.getExportFilter() != PathFilters.rejectAll()) {
109 final ModuleDependency moduleDependency = (ModuleDependency) dependency;
110 final Module md = moduleDependency.getModuleLoader().loadModule(moduleDependency.getName());
111 if (md != null && moduleDependency.getExportFilter() != PathFilters.rejectAll()) {
112 if (visited.add(md)) {
113 dependencyExports.add(md.getName());
114 getExportedModuleDeps(md, visited, dependencyExports);
115 }
116 }
117 }
118 }
119 }
120
121 @SuppressWarnings({ "unchecked" })
122 @Test
123 @Ignore("Disabled; relies on modules not inheriting full set of JDK paths which is incorrect behavior")
124 public void testImportPaths() throws Exception {
125 final TestModuleLoader moduleLoader = new TestModuleLoader();
126
127 ModuleSpec.Builder builder = ModuleSpec.build(MODULE_A);
128 builder.addDependency(new ModuleDependencySpecBuilder()
129 .setName(MODULE_B.toString())
130 .setExport(true)
131 .build());
132 moduleLoader.addModuleSpec(builder.create());
133
134 builder = ModuleSpec.build(MODULE_B);
135 builder.addDependency(new ModuleDependencySpecBuilder()
136 .setName(MODULE_C.toString())
137 .setExport(true)
138 .build());
139 builder.addDependency(new ModuleDependencySpecBuilder()
140 .setName(MODULE_D.toString())
141 .build());
142 moduleLoader.addModuleSpec(builder.create());
143
144 builder = ModuleSpec.build(MODULE_C);
145 builder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(TestResourceLoader.build()
146 .addClass(ImportedClass.class)
147 .create()
148 ));
149 builder.addDependency(DependencySpec.createLocalDependencySpec());
150 moduleLoader.addModuleSpec(builder.create());
151
152 builder = ModuleSpec.build(MODULE_D);
153 moduleLoader.addModuleSpec(builder.create());
154
155 Module module = moduleLoader.loadModule(MODULE_A);
156 module.getClassLoader().loadClass(ImportedClass.class.getName());
157
158 final Field pathsField = Module.class.getDeclaredField("linkage");
159 pathsField.setAccessible(true);
160 final Object paths = pathsField.get(module);
161 final Field allPathsField = paths.getClass().getDeclaredField("allPaths");
162 allPathsField.setAccessible(true);
163 final Map<String, List<LocalLoader>> allPaths = (Map<String, List<LocalLoader>>) allPathsField.get(paths);
164
165 Module moduleC = moduleLoader.loadModule(MODULE_C);
166
167 assertEquals(4, allPaths.size());
168
169 for(Map.Entry<String, List<LocalLoader>> entry : allPaths.entrySet()) {
170 assertEquals(1, entry.getValue().size());
171 assertEquals(moduleC.getClassLoaderPrivate().getLocalLoader(), entry.getValue().get(0));
172 }
173 }
174 }