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 /** 25 * @test 26 * @summary simple tests of module uses 27 * @library /tools/lib 28 * @modules 29 * jdk.compiler/com.sun.tools.javac.api 30 * jdk.compiler/com.sun.tools.javac.main 31 * @build toolbox.ToolBox toolbox.JavacTask toolbox.ModuleBuilder ModuleTestBase 32 * @run main UsesTest 33 */ 34 35 import java.nio.file.Files; 36 import java.nio.file.Path; 37 import java.util.Arrays; 38 import java.util.Collection; 39 import java.util.List; 40 41 import toolbox.JavacTask; 42 import toolbox.ModuleBuilder; 43 import toolbox.Task; 44 import toolbox.ToolBox; 45 46 public class UsesTest extends ModuleTestBase { 47 public static void main(String... args) throws Exception { 48 UsesTest t = new UsesTest(); 49 t.runTests(); 50 } 51 52 @Test 53 public void testSimple(Path base) throws Exception { 54 Path src = base.resolve("src"); 55 tb.writeJavaFiles(src, 56 "module m { uses p.C; }", 57 "package p; public class C { }"); 58 Path classes = base.resolve("classes"); 59 Files.createDirectories(classes); 60 61 new JavacTask(tb) 62 .outdir(classes) 63 .files(findJavaFiles(src)) 64 .run(Task.Expect.SUCCESS) 65 .writeAll(); 66 } 67 68 @Test 69 public void testSimpleInner(Path base) throws Exception { 70 Path src = base.resolve("src"); 71 tb.writeJavaFiles(src, 72 "module m { uses p.C.Inner; }", 73 "package p; public class C { public class Inner { } }"); 74 Path classes = base.resolve("classes"); 75 Files.createDirectories(classes); 76 77 new JavacTask(tb) 78 .outdir(classes) 79 .files(findJavaFiles(src)) 80 .run(Task.Expect.SUCCESS) 81 .writeAll(); 82 } 83 84 @Test 85 public void testEnumAsAService(Path base) throws Exception { 86 Path src = base.resolve("src"); 87 tb.writeJavaFiles(src, 88 "module m { uses pkg.EnumST; }", 89 "package pkg; public enum EnumST {A, B}"); 90 Path classes = base.resolve("classes"); 91 Files.createDirectories(classes); 92 93 List<String> output = new JavacTask(tb) 94 .options("-XDrawDiagnostics") 95 .outdir(classes) 96 .files(tb.findJavaFiles(src)) 97 .run(Task.Expect.FAIL) 98 .writeAll() 99 .getOutputLines(Task.OutputKind.DIRECT); 100 List<String> expected = Arrays.asList("module-info.java:1:20: compiler.err.service.definition.is.enum: pkg.EnumST", 101 "1 error"); 102 if (!output.containsAll(expected)) { 103 throw new Exception("Expected output not found"); 104 } 105 } 106 107 @Test 108 public void testSimpleAnnotation(Path base) throws Exception { 109 Path src = base.resolve("src"); 110 tb.writeJavaFiles(src, 111 "module m { uses p.C; }", 112 "package p; public @interface C { }"); 113 Path classes = base.resolve("classes"); 114 Files.createDirectories(classes); 115 116 new JavacTask(tb) 117 .outdir(classes) 118 .files(findJavaFiles(src)) 119 .run(Task.Expect.SUCCESS) 120 .writeAll(); 121 } 122 123 @Test 124 public void testPrivateService(Path base) throws Exception { 125 Path src = base.resolve("src"); 126 tb.writeJavaFiles(src, 127 "module m { uses p.C.A; uses p.C; }", 128 "package p; public class C { protected class A { } }"); 129 130 List<String> output = new JavacTask(tb) 131 .options("-XDrawDiagnostics") 132 .outdir(Files.createDirectories(base.resolve("classes"))) 133 .files(findJavaFiles(src)) 134 .run(Task.Expect.FAIL) 135 .writeAll() 136 .getOutputLines(Task.OutputKind.DIRECT); 137 138 List<String> expected = Arrays.asList("module-info.java:1:20: compiler.err.report.access: p.C.A, protected, p.C", 139 "1 error"); 140 if (!output.containsAll(expected)) { 141 throw new Exception("Expected output not found"); 142 } 143 } 144 145 @Test 146 public void testMulti(Path base) throws Exception { 147 Path src = base.resolve("src"); 148 tb.writeJavaFiles(src.resolve("m1"), 149 "module m1 { exports p; }", 150 "package p; public class C { }"); 151 tb.writeJavaFiles(src.resolve("m2"), 152 "module m2 { requires m1; uses p.C; }"); 153 Path modules = base.resolve("modules"); 154 Files.createDirectories(modules); 155 156 new JavacTask(tb) 157 .options("-modulesourcepath", src.toString()) 158 .outdir(modules) 159 .files(findJavaFiles(src)) 160 .run(Task.Expect.SUCCESS) 161 .writeAll(); 162 } 163 164 @Test 165 public void testMultiOnModulePath(Path base) throws Exception { 166 Path modSrc = base.resolve("modSrc"); 167 Path modules = base.resolve("modules"); 168 new ModuleBuilder(tb, "m1") 169 .exports("p") 170 .classes("package p; public class C { }") 171 .build(modules); 172 new ModuleBuilder(tb, "m2") 173 .requires("m1") 174 .uses("p.C") 175 .write(modSrc); 176 177 new JavacTask(tb) 178 .options("-mp", modules.toString()) 179 .outdir(modules) 180 .files(findJavaFiles(modSrc.resolve("m2"))) 181 .run(Task.Expect.SUCCESS) 182 .writeAll(); 183 } 184 185 @Test 186 public void testMultiOnModulePathInner(Path base) throws Exception { 187 Path modSrc = base.resolve("modSrc"); 188 Path modules = base.resolve("modules"); 189 new ModuleBuilder(tb, "m1") 190 .exports("p") 191 .classes("package p; public class C { public class Inner { } }") 192 .build(modules); 193 new ModuleBuilder(tb, "m2") 194 .requires("m1") 195 .uses("p.C.Inner") 196 .write(modSrc); 197 198 new JavacTask(tb) 199 .options("-mp", modules.toString()) 200 .outdir(modules) 201 .files(findJavaFiles(modSrc.resolve("m2"))) 202 .run(Task.Expect.SUCCESS) 203 .writeAll(); 204 } 205 206 @Test 207 public void testDuplicateUses(Path base) throws Exception { 208 Path src = base.resolve("src"); 209 tb.writeJavaFiles(src.resolve("m"), 210 "module m { uses p.C; uses p.C; }", 211 "package p; public class C { }"); 212 213 List<String> output = new JavacTask(tb) 214 .options("-XDrawDiagnostics") 215 .outdir(Files.createDirectories(base.resolve("classes"))) 216 .files(findJavaFiles(src)) 217 .run(Task.Expect.FAIL) 218 .writeAll() 219 .getOutputLines(Task.OutputKind.DIRECT); 220 221 if (!output.containsAll(Arrays.asList( 222 "module-info.java:1:22: compiler.err.duplicate.uses: p.C"))) { 223 throw new Exception("Expected output not found"); 224 } 225 } 226 227 @Test 228 public void testServiceNotExist(Path base) throws Exception { 229 Path src = base.resolve("src"); 230 tb.writeJavaFiles(src, 231 "module m { uses p.NotExist; }", 232 "package p; public class C { }"); 233 234 List<String> output = new JavacTask(tb) 235 .outdir(Files.createDirectories(base.resolve("classes"))) 236 .options("-XDrawDiagnostics") 237 .files(findJavaFiles(src)) 238 .run(Task.Expect.FAIL) 239 .writeAll() 240 .getOutputLines(Task.OutputKind.DIRECT); 241 Collection<?> expected = Arrays.asList("module-info.java:1:18: compiler.err.cant.resolve.location: kindname.class, NotExist, , , (compiler.misc.location: kindname.package, p, null)", 242 "1 error"); 243 if (!output.containsAll(expected)) { 244 throw new Exception("Expected output not found"); 245 } 246 } 247 248 @Test 249 public void testUsesUnexportedService(Path base) throws Exception { 250 Path src = base.resolve("src"); 251 tb.writeJavaFiles(src.resolve("m1"), 252 "module m1 { }", 253 "package p; public class C { }"); 254 tb.writeJavaFiles(src.resolve("m2"), 255 "module m2 { requires m1; uses p.C; }"); 256 257 List<String> output = new JavacTask(tb) 258 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString()) 259 .outdir(Files.createDirectories(base.resolve("modules"))) 260 .files(findJavaFiles(src)) 261 .run(Task.Expect.FAIL) 262 .writeAll() 263 .getOutputLines(Task.OutputKind.DIRECT); 264 265 List<String> expected = Arrays.asList("module-info.java:1:32: compiler.err.not.def.access.package.cant.access: p.C, p", 266 "1 error"); 267 if (!output.containsAll(expected)) { 268 throw new Exception("Expected output not found"); 269 } 270 } 271 272 @Test 273 public void testUsesUnexportedButProvidedService(Path base) throws Exception { 274 Path src = base.resolve("src"); 275 tb.writeJavaFiles(src.resolve("m1"), 276 "module m1 { provides p.C with p.C; }", 277 "package p; public class C { }"); 278 tb.writeJavaFiles(src.resolve("m2"), 279 "module m2 { requires m1; uses p.C; }"); 280 281 List<String> output = new JavacTask(tb) 282 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString()) 283 .outdir(Files.createDirectories(base.resolve("modules"))) 284 .files(findJavaFiles(src)) 285 .run(Task.Expect.FAIL) 286 .writeAll() 287 .getOutputLines(Task.OutputKind.DIRECT); 288 289 List<String> expected = Arrays.asList("module-info.java:1:32: compiler.err.not.def.access.package.cant.access: p.C, p", 290 "1 error"); 291 if (!output.containsAll(expected)) { 292 throw new Exception("Expected output not found"); 293 } 294 } 295 }