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 Test the --add-exports option 27 * @library /tools/lib 28 * @modules jdk.compiler/com.sun.tools.javac.api 29 * jdk.compiler/com.sun.tools.javac.main 30 * @build toolbox.ToolBox toolbox.JavacTask ModuleTestBase 31 * @run main AddExportsTest 32 */ 33 34 import java.nio.file.Files; 35 import java.nio.file.Path; 36 import java.util.Set; 37 38 import toolbox.JavacTask; 39 import toolbox.Task; 40 import toolbox.ToolBox; 41 42 public class AddExportsTest extends ModuleTestBase { 43 44 public static void main(String... args) throws Exception { 45 new AddExportsTest().runTests(); 46 } 47 48 @Test 49 public void testEmpty(Path base) throws Exception { 50 Path src = base.resolve("src"); 51 tb.writeJavaFiles(src, "class Dummy { }"); 52 Path classes = base.resolve("classes"); 53 tb.createDirectories(classes); 54 testEmpty(src, classes, "--add-exports", ""); 55 testEmpty(src, classes, "--add-exports="); 56 } 57 58 private void testEmpty(Path src, Path classes, String... options) throws Exception { 59 String log = new JavacTask(tb, Task.Mode.CMDLINE) 60 .options(options) 61 .outdir(classes) 62 .files(findJavaFiles(src)) 63 .run(Task.Expect.FAIL) 64 .writeAll() 65 .getOutput(Task.OutputKind.DIRECT); 66 67 checkOutputContains(log, 68 "javac: no value for --add-exports option"); 69 } 70 71 @Test 72 public void testEmptyItem(Path base) throws Exception { 73 Path src = base.resolve("src"); 74 Path src_m1 = src.resolve("m1"); 75 tb.writeJavaFiles(src_m1, 76 "module m1 { }", 77 "package p1; public class C1 { }"); 78 Path src_m2 = src.resolve("m2"); 79 tb.writeJavaFiles(src_m2, 80 "module m2 { }", 81 "package p2; class C2 { p1.C1 c1; }"); 82 Path src_m3 = src.resolve("m3"); 83 tb.writeJavaFiles(src_m3, 84 "module m3 { }", 85 "package p3; class C3 { p1.C1 c1; }"); 86 Path classes = base.resolve("classes"); 87 tb.createDirectories(classes); 88 89 testEmptyItem(src, classes, "m1/p1=,m2,m3"); 90 testEmptyItem(src, classes, "m1/p1=m2,,m3"); 91 testEmptyItem(src, classes, "m1/p1=m2,m3,"); 92 } 93 94 void testEmptyItem(Path src, Path classes, String option) throws Exception { 95 new JavacTask(tb) 96 .options("--module-source-path", src.toString(), 97 "--add-exports", option) 98 .outdir(classes) 99 .files(findJavaFiles(src)) 100 .run() 101 .writeAll(); 102 } 103 104 @Test 105 public void testEmptyList(Path base) throws Exception { 106 Path src = base.resolve("src"); 107 Path src_m1 = src.resolve("m1"); 108 tb.writeJavaFiles(src_m1, 109 "module m1 { exports p1; }", 110 "package p1; public class C1 { }"); 111 Path classes = base.resolve("classes"); 112 tb.createDirectories(classes); 113 114 testEmptyList(src, classes, "m1/p1="); 115 testEmptyList(src, classes, "m1/p1=,"); 116 } 117 118 void testEmptyList(Path src, Path classes, String option) throws Exception { 119 String log = new JavacTask(tb, Task.Mode.CMDLINE) 120 .options("--module-source-path", src.toString(), 121 "--add-exports", option) 122 .outdir(classes) 123 .files(findJavaFiles(src)) 124 .run(Task.Expect.FAIL) 125 .writeAll() 126 .getOutput(Task.OutputKind.DIRECT); 127 128 checkOutputContains(log, 129 "javac: bad value for --add-exports option: '" + option + "'"); 130 } 131 132 @Test 133 public void testMissingSourceParts(Path base) throws Exception { 134 Path src = base.resolve("src"); 135 Path src_m1 = src.resolve("m1"); 136 tb.writeJavaFiles(src_m1, 137 "module m1 { exports p1; }", 138 "package p1; public class C1 { }"); 139 Path src_m2 = src.resolve("m2"); 140 tb.writeJavaFiles(src_m2, 141 "module m2 { }", 142 "package p2; class C2 { p1.C1 c1; }"); 143 Path classes = base.resolve("classes"); 144 tb.createDirectories(classes); 145 146 testMissingSourcePart(src, classes, "=m2"); 147 testMissingSourcePart(src, classes, "/=m2"); 148 testMissingSourcePart(src, classes, "m1/=m2"); 149 testMissingSourcePart(src, classes, "/p1=m2"); 150 testMissingSourcePart(src, classes, "m1p1=m2"); 151 } 152 153 private void testMissingSourcePart(Path src, Path classes, String option) throws Exception { 154 String log = new JavacTask(tb, Task.Mode.CMDLINE) 155 .options("--module-source-path", src.toString(), 156 "--add-exports", option) 157 .outdir(classes) 158 .files(findJavaFiles(src)) 159 .run(Task.Expect.FAIL) 160 .writeAll() 161 .getOutput(Task.OutputKind.DIRECT); 162 163 checkOutputContains(log, 164 "javac: bad value for --add-exports option: '" + option + "'"); 165 } 166 167 @Test 168 public void testBadSourceParts(Path base) throws Exception { 169 Path src = base.resolve("src"); 170 Path src_m1 = src.resolve("m1"); 171 tb.writeJavaFiles(src_m1, 172 "module m1 { exports p1; }", 173 "package p1; public class C1 { }"); 174 Path src_m2 = src.resolve("m2"); 175 tb.writeJavaFiles(src_m2, 176 "module m2 { }", 177 "package p2; class C2 { p1.C1 c1; }"); 178 Path classes = base.resolve("classes"); 179 tb.createDirectories(classes); 180 181 testBadSourcePart(src, classes, "m!/p1=m2", "m!"); 182 testBadSourcePart(src, classes, "m1/p!=m2", "p!"); 183 } 184 185 private void testBadSourcePart(Path src, Path classes, String option, String badName) 186 throws Exception { 187 String log = new JavacTask(tb, Task.Mode.CMDLINE) 188 .options("-XDrawDiagnostics", 189 "--module-source-path", src.toString(), 190 "--add-exports", option) 191 .outdir(classes) 192 .files(findJavaFiles(src)) 193 .run(Task.Expect.FAIL) 194 .writeAll() 195 .getOutput(Task.OutputKind.DIRECT); 196 197 checkOutputContains(log, 198 "- compiler.warn.bad.name.for.option: --add-exports, " + badName); 199 } 200 201 @Test 202 public void testBadTarget(Path base) throws Exception { 203 Path src = base.resolve("src"); 204 Path src_m1 = src.resolve("m1"); 205 tb.writeJavaFiles(src_m1, 206 "module m1 { exports p1; }", 207 "package p1; public class C1 { }"); 208 Path classes = base.resolve("classes"); 209 tb.createDirectories(classes); 210 211 String log = new JavacTask(tb, Task.Mode.CMDLINE) 212 .options("-XDrawDiagnostics", 213 "--module-source-path", src.toString(), 214 "--add-exports", "m1/p1=m!") 215 .outdir(classes) 216 .files(findJavaFiles(src)) 217 .run() 218 .writeAll() 219 .getOutput(Task.OutputKind.DIRECT); 220 221 checkOutputContains(log, 222 "- compiler.warn.bad.name.for.option: --add-exports, m!"); 223 } 224 225 @Test 226 public void testSourceNotFound(Path base) throws Exception { 227 Path src = base.resolve("src"); 228 Path src_m1 = src.resolve("m1"); 229 tb.writeJavaFiles(src_m1, 230 "module m1 { }"); 231 Path classes = base.resolve("classes"); 232 tb.createDirectories(classes); 233 234 String log = new JavacTask(tb, Task.Mode.CMDLINE) 235 .options("-XDrawDiagnostics", 236 "--module-source-path", src.toString(), 237 "--add-exports", "DoesNotExist/p=m1") 238 .outdir(classes) 239 .files(findJavaFiles(src)) 240 .run() 241 .writeAll() 242 .getOutput(Task.OutputKind.DIRECT); 243 244 checkOutputContains(log, 245 "- compiler.warn.module.for.option.not.found: --add-exports, DoesNotExist"); 246 } 247 248 @Test 249 public void testTargetNotFound(Path base) throws Exception { 250 Path src = base.resolve("src"); 251 Path src_m1 = src.resolve("m1"); 252 tb.writeJavaFiles(src_m1, 253 "module m1 { }", 254 "package p1; class C1 { }"); 255 Path classes = base.resolve("classes"); 256 tb.createDirectories(classes); 257 258 String log = new JavacTask(tb, Task.Mode.CMDLINE) 259 .options("-XDrawDiagnostics", 260 "--module-source-path", src.toString(), 261 "--add-exports", "m1/p1=DoesNotExist") 262 .outdir(classes) 263 .files(findJavaFiles(src)) 264 .run() 265 .writeAll() 266 .getOutput(Task.OutputKind.DIRECT); 267 268 checkOutputContains(log, 269 "- compiler.warn.module.for.option.not.found: --add-exports, DoesNotExist"); 270 } 271 272 @Test 273 public void testDuplicate(Path base) throws Exception { 274 Path src = base.resolve("src"); 275 Path src_m1 = src.resolve("m1"); 276 tb.writeJavaFiles(src_m1, 277 "module m1 { }", 278 "package p1; public class C1 { }"); 279 Path src_m2 = src.resolve("m2"); 280 tb.writeJavaFiles(src_m2, 281 "module m2 { }", 282 "package p2; class C2 { p1.C1 c1; }"); 283 Path classes = base.resolve("classes"); 284 tb.createDirectories(classes); 285 286 new JavacTask(tb) 287 .options("--module-source-path", src.toString(), 288 "--add-exports", "m1/p1=m2,m2") 289 .outdir(classes) 290 .files(findJavaFiles(src)) 291 .run() 292 .writeAll(); 293 } 294 295 @Test 296 public void testRepeated_SameTarget(Path base) throws Exception { 297 Path src = base.resolve("src"); 298 Path src_m1 = src.resolve("m1"); 299 tb.writeJavaFiles(src_m1, 300 "module m1 { }", 301 "package p1; public class C1 { }"); 302 Path src_m2 = src.resolve("m2"); 303 tb.writeJavaFiles(src_m2, 304 "module m2 { }", 305 "package p2; class C2 { p1.C1 c1; }"); 306 Path classes = base.resolve("classes"); 307 tb.createDirectories(classes); 308 309 new JavacTask(tb) 310 .options("--module-source-path", src.toString(), 311 "--add-exports", "m1/p1=m2", 312 "--add-exports", "m1/p1=m2") 313 .outdir(classes) 314 .files(findJavaFiles(src)) 315 .run() 316 .writeAll(); 317 } 318 319 @Test 320 public void testRepeated_DifferentTarget(Path base) throws Exception { 321 Path src = base.resolve("src"); 322 Path src_m1 = src.resolve("m1"); 323 tb.writeJavaFiles(src_m1, 324 "module m1 { }", 325 "package p1; public class C1 { }"); 326 Path src_m2 = src.resolve("m2"); 327 tb.writeJavaFiles(src_m2, 328 "module m2 { }", 329 "package p2; class C2 { p1.C1 c1; }"); 330 Path src_m3 = src.resolve("m3"); 331 tb.writeJavaFiles(src_m3, 332 "module m3 { }", 333 "package p3; class C3 { p1.C1 c1; }"); 334 Path classes = base.resolve("classes"); 335 tb.createDirectories(classes); 336 337 new JavacTask(tb) 338 .options("--module-source-path", src.toString(), 339 "--add-exports", "m1/p1=m2", 340 "--add-exports", "m1/p1=m3") 341 .outdir(classes) 342 .files(findJavaFiles(src)) 343 .run() 344 .writeAll(); 345 } 346 } | 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 Test the --add-exports option 27 * @library /tools/lib 28 * @modules jdk.compiler/com.sun.tools.javac.api 29 * jdk.compiler/com.sun.tools.javac.main 30 * @build toolbox.ToolBox toolbox.JavacTask ModuleTestBase 31 * @run main AddExportsTest 32 */ 33 34 import java.nio.file.Path; 35 36 import toolbox.JavacTask; 37 import toolbox.Task; 38 39 public class AddExportsTest extends ModuleTestBase { 40 41 public static void main(String... args) throws Exception { 42 new AddExportsTest().runTests(); 43 } 44 45 @Test 46 public void testEmpty(Path base) throws Exception { 47 Path src = base.resolve("src"); 48 tb.writeJavaFiles(src, "class Dummy { }"); 49 Path classes = base.resolve("classes"); 50 tb.createDirectories(classes); 51 testEmpty(src, classes, "--add-exports", ""); 52 testEmpty(src, classes, "--add-exports="); 53 } 54 55 private void testEmpty(Path src, Path classes, String... options) throws Exception { 56 String log = new JavacTask(tb, Task.Mode.CMDLINE) 57 .options(options) 58 .outdir(classes) 59 .files(findJavaFiles(src)) 60 .run(Task.Expect.FAIL) 61 .writeAll() 62 .getOutput(Task.OutputKind.DIRECT); 63 64 checkOutputContains(log, 65 "javac: no value for --add-exports option"); 66 } 67 68 @Test 69 public void testEmptyItem(Path base) throws Exception { 70 Path src = base.resolve("src"); 71 Path src_m1 = src.resolve("m1x"); 72 tb.writeJavaFiles(src_m1, 73 "module m1x { }", 74 "package p1; public class C1 { }"); 75 Path src_m2 = src.resolve("m2x"); 76 tb.writeJavaFiles(src_m2, 77 "module m2x { }", 78 "package p2; class C2 { p1.C1 c1; }"); 79 Path src_m3 = src.resolve("m3x"); 80 tb.writeJavaFiles(src_m3, 81 "module m3x { }", 82 "package p3; class C3 { p1.C1 c1; }"); 83 Path classes = base.resolve("classes"); 84 tb.createDirectories(classes); 85 86 testEmptyItem(src, classes, "m1x/p1=,m2x,m3x"); 87 testEmptyItem(src, classes, "m1x/p1=m2x,,m3x"); 88 testEmptyItem(src, classes, "m1x/p1=m2x,m3x,"); 89 } 90 91 void testEmptyItem(Path src, Path classes, String option) throws Exception { 92 new JavacTask(tb) 93 .options("--module-source-path", src.toString(), 94 "--add-exports", option) 95 .outdir(classes) 96 .files(findJavaFiles(src)) 97 .run() 98 .writeAll(); 99 } 100 101 @Test 102 public void testEmptyList(Path base) throws Exception { 103 Path src = base.resolve("src"); 104 Path src_m1 = src.resolve("m1x"); 105 tb.writeJavaFiles(src_m1, 106 "module m1x { exports p1; }", 107 "package p1; public class C1 { }"); 108 Path classes = base.resolve("classes"); 109 tb.createDirectories(classes); 110 111 testEmptyList(src, classes, "m1x/p1="); 112 testEmptyList(src, classes, "m1x/p1=,"); 113 } 114 115 void testEmptyList(Path src, Path classes, String option) throws Exception { 116 String log = new JavacTask(tb, Task.Mode.CMDLINE) 117 .options("--module-source-path", src.toString(), 118 "--add-exports", option) 119 .outdir(classes) 120 .files(findJavaFiles(src)) 121 .run(Task.Expect.FAIL) 122 .writeAll() 123 .getOutput(Task.OutputKind.DIRECT); 124 125 checkOutputContains(log, 126 "javac: bad value for --add-exports option: '" + option + "'"); 127 } 128 129 @Test 130 public void testMissingSourceParts(Path base) throws Exception { 131 Path src = base.resolve("src"); 132 Path src_m1 = src.resolve("m1x"); 133 tb.writeJavaFiles(src_m1, 134 "module m1x { exports p1; }", 135 "package p1; public class C1 { }"); 136 Path src_m2 = src.resolve("m2x"); 137 tb.writeJavaFiles(src_m2, 138 "module m2x { }", 139 "package p2; class C2 { p1.C1 c1; }"); 140 Path classes = base.resolve("classes"); 141 tb.createDirectories(classes); 142 143 testMissingSourcePart(src, classes, "=m2x"); 144 testMissingSourcePart(src, classes, "/=m2x"); 145 testMissingSourcePart(src, classes, "m1x/=m2x"); 146 testMissingSourcePart(src, classes, "/p1=m2x"); 147 testMissingSourcePart(src, classes, "m1xp1=m2x"); 148 } 149 150 private void testMissingSourcePart(Path src, Path classes, String option) throws Exception { 151 String log = new JavacTask(tb, Task.Mode.CMDLINE) 152 .options("--module-source-path", src.toString(), 153 "--add-exports", option) 154 .outdir(classes) 155 .files(findJavaFiles(src)) 156 .run(Task.Expect.FAIL) 157 .writeAll() 158 .getOutput(Task.OutputKind.DIRECT); 159 160 checkOutputContains(log, 161 "javac: bad value for --add-exports option: '" + option + "'"); 162 } 163 164 @Test 165 public void testBadSourceParts(Path base) throws Exception { 166 Path src = base.resolve("src"); 167 Path src_m1 = src.resolve("m1x"); 168 tb.writeJavaFiles(src_m1, 169 "module m1x { exports p1; }", 170 "package p1; public class C1 { }"); 171 Path src_m2 = src.resolve("m2x"); 172 tb.writeJavaFiles(src_m2, 173 "module m2x { }", 174 "package p2; class C2 { p1.C1 c1; }"); 175 Path classes = base.resolve("classes"); 176 tb.createDirectories(classes); 177 178 testBadSourcePart(src, classes, "m!/p1=m2x", "m!"); 179 testBadSourcePart(src, classes, "m1x/p!=m2x", "p!"); 180 } 181 182 private void testBadSourcePart(Path src, Path classes, String option, String badName) 183 throws Exception { 184 String log = new JavacTask(tb, Task.Mode.CMDLINE) 185 .options("-XDrawDiagnostics", 186 "--module-source-path", src.toString(), 187 "--add-exports", option) 188 .outdir(classes) 189 .files(findJavaFiles(src)) 190 .run(Task.Expect.FAIL) 191 .writeAll() 192 .getOutput(Task.OutputKind.DIRECT); 193 194 checkOutputContains(log, 195 "- compiler.warn.bad.name.for.option: --add-exports, " + badName); 196 } 197 198 @Test 199 public void testBadTarget(Path base) throws Exception { 200 Path src = base.resolve("src"); 201 Path src_m1 = src.resolve("m1x"); 202 tb.writeJavaFiles(src_m1, 203 "module m1x { exports p1; }", 204 "package p1; public class C1 { }"); 205 Path classes = base.resolve("classes"); 206 tb.createDirectories(classes); 207 208 String log = new JavacTask(tb, Task.Mode.CMDLINE) 209 .options("-XDrawDiagnostics", 210 "--module-source-path", src.toString(), 211 "--add-exports", "m1x/p1=m!") 212 .outdir(classes) 213 .files(findJavaFiles(src)) 214 .run() 215 .writeAll() 216 .getOutput(Task.OutputKind.DIRECT); 217 218 checkOutputContains(log, 219 "- compiler.warn.bad.name.for.option: --add-exports, m!"); 220 } 221 222 @Test 223 public void testSourceNotFound(Path base) throws Exception { 224 Path src = base.resolve("src"); 225 Path src_m1 = src.resolve("m1x"); 226 tb.writeJavaFiles(src_m1, 227 "module m1x { }"); 228 Path classes = base.resolve("classes"); 229 tb.createDirectories(classes); 230 231 String log = new JavacTask(tb, Task.Mode.CMDLINE) 232 .options("-XDrawDiagnostics", 233 "--module-source-path", src.toString(), 234 "--add-exports", "DoesNotExist/p=m1x") 235 .outdir(classes) 236 .files(findJavaFiles(src)) 237 .run() 238 .writeAll() 239 .getOutput(Task.OutputKind.DIRECT); 240 241 checkOutputContains(log, 242 "- compiler.warn.module.for.option.not.found: --add-exports, DoesNotExist"); 243 } 244 245 @Test 246 public void testTargetNotFound(Path base) throws Exception { 247 Path src = base.resolve("src"); 248 Path src_m1 = src.resolve("m1x"); 249 tb.writeJavaFiles(src_m1, 250 "module m1x { }", 251 "package p1; class C1 { }"); 252 Path classes = base.resolve("classes"); 253 tb.createDirectories(classes); 254 255 String log = new JavacTask(tb, Task.Mode.CMDLINE) 256 .options("-XDrawDiagnostics", 257 "--module-source-path", src.toString(), 258 "--add-exports", "m1x/p1=DoesNotExist") 259 .outdir(classes) 260 .files(findJavaFiles(src)) 261 .run() 262 .writeAll() 263 .getOutput(Task.OutputKind.DIRECT); 264 265 checkOutputContains(log, 266 "- compiler.warn.module.for.option.not.found: --add-exports, DoesNotExist"); 267 } 268 269 @Test 270 public void testDuplicate(Path base) throws Exception { 271 Path src = base.resolve("src"); 272 Path src_m1 = src.resolve("m1x"); 273 tb.writeJavaFiles(src_m1, 274 "module m1x { }", 275 "package p1; public class C1 { }"); 276 Path src_m2 = src.resolve("m2x"); 277 tb.writeJavaFiles(src_m2, 278 "module m2x { }", 279 "package p2; class C2 { p1.C1 c1; }"); 280 Path classes = base.resolve("classes"); 281 tb.createDirectories(classes); 282 283 new JavacTask(tb) 284 .options("--module-source-path", src.toString(), 285 "--add-exports", "m1x/p1=m2x,m2x") 286 .outdir(classes) 287 .files(findJavaFiles(src)) 288 .run() 289 .writeAll(); 290 } 291 292 @Test 293 public void testRepeated_SameTarget(Path base) throws Exception { 294 Path src = base.resolve("src"); 295 Path src_m1 = src.resolve("m1x"); 296 tb.writeJavaFiles(src_m1, 297 "module m1x { }", 298 "package p1; public class C1 { }"); 299 Path src_m2 = src.resolve("m2x"); 300 tb.writeJavaFiles(src_m2, 301 "module m2x { }", 302 "package p2; class C2 { p1.C1 c1; }"); 303 Path classes = base.resolve("classes"); 304 tb.createDirectories(classes); 305 306 new JavacTask(tb) 307 .options("--module-source-path", src.toString(), 308 "--add-exports", "m1x/p1=m2x", 309 "--add-exports", "m1x/p1=m2x") 310 .outdir(classes) 311 .files(findJavaFiles(src)) 312 .run() 313 .writeAll(); 314 } 315 316 @Test 317 public void testRepeated_DifferentTarget(Path base) throws Exception { 318 Path src = base.resolve("src"); 319 Path src_m1 = src.resolve("m1x"); 320 tb.writeJavaFiles(src_m1, 321 "module m1x { }", 322 "package p1; public class C1 { }"); 323 Path src_m2 = src.resolve("m2x"); 324 tb.writeJavaFiles(src_m2, 325 "module m2x { }", 326 "package p2; class C2 { p1.C1 c1; }"); 327 Path src_m3 = src.resolve("m3x"); 328 tb.writeJavaFiles(src_m3, 329 "module m3x { }", 330 "package p3; class C3 { p1.C1 c1; }"); 331 Path classes = base.resolve("classes"); 332 tb.createDirectories(classes); 333 334 new JavacTask(tb) 335 .options("--module-source-path", src.toString(), 336 "--add-exports", "m1x/p1=m2x", 337 "--add-exports", "m1x/p1=m3x") 338 .outdir(classes) 339 .files(findJavaFiles(src)) 340 .run() 341 .writeAll(); 342 } 343 } |