1 /*
2 * Copyright (c) 2014, 2019, 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 * @bug 4981566 5028634 5094412 6304984 7025786 7025789 8001112 8028545 8000961 8030610 8028546 8188870 8173382 8173382 8193290 8205619 8028563
27 * @summary Check interpretation of -target and -source options
28 * @modules java.compiler
29 * jdk.compiler
30 * @run main Versions
31 */
32
33 import java.io.*;
34 import java.nio.*;
35 import java.nio.channels.*;
36
37 import javax.tools.JavaCompiler;
38 import javax.tools.ToolProvider;
39 import javax.tools.JavaFileObject;
40 import javax.tools.StandardJavaFileManager;
41 import java.util.List;
42 import java.util.ArrayList;
43 import java.util.Arrays;
44 import java.util.Set;
45 import java.util.function.BiConsumer;
46
47 /*
48 * If not explicitly specified the latest source and latest target
49 * values are the defaults. If explicitly specified, the target value
50 * has to be greater than or equal to the source value.
51 */
52 public class Versions {
53
54 protected JavaCompiler javacompiler;
55 protected int failedCases;
56
57 public Versions() throws IOException {
58 javacompiler = ToolProvider.getSystemJavaCompiler();
59 genSourceFiles();
60 failedCases = 0;
61 }
62
63 public static void main(String... args) throws IOException {
64 Versions versions = new Versions();
65 versions.run();
66 }
67
68 public static final Set<String> RETIRED_SOURCES =
69 Set.of("1.2", "1.3", "1.4", "1.5", "1.6");
70
71 public static final Set<String> VALID_SOURCES =
72 Set.of("1.7", "1.8", "1.9", "1.10", "11", "12", "13", "14", "15");
73
74 public static final String LATEST_MAJOR_VERSION = "59.0";
75
76 static enum SourceTarget {
77 SEVEN(true, "51.0", "7", Versions::checksrc17),
78 EIGHT(true, "52.0", "8", Versions::checksrc18),
79 NINE(true, "53.0", "9", Versions::checksrc19),
80 TEN(true, "54.0", "10", Versions::checksrc110),
81 ELEVEN(false, "55.0", "11", Versions::checksrc111),
82 TWELVE(false, "56.0", "12", Versions::checksrc112),
83 THIRTEEN(false, "57.0", "13", Versions::checksrc113),
84 FOURTEEN(false, "58.0", "14", Versions::checksrc114),
85 FIFTEEN(false, "59.0", "15", Versions::checksrc115);
86
87 private final boolean dotOne;
88 private final String classFileVer;
89 private final String target;
90 private final BiConsumer<Versions, String[]> checker;
91
92 private SourceTarget(boolean dotOne, String classFileVer, String target,
93 BiConsumer<Versions, String[]> checker) {
94 this.dotOne = dotOne;
95 this.classFileVer = classFileVer;
96 this.target = target;
97 this.checker = checker;
98 }
99
100 public void checksrc(Versions version, String... args) {
101 checker.accept(version, args);
102 }
103
104 public boolean dotOne() {
105 return dotOne;
106 }
107
108 public String classFileVer() {
109 return classFileVer;
110 }
111
112 public String target() {
113 return target;
114 }
115 }
116
117 void run() {
118 String TC = "";
119 System.out.println("Version.java: Starting");
120
121 check(LATEST_MAJOR_VERSION);
122 for (String source : VALID_SOURCES) {
123 check(LATEST_MAJOR_VERSION, "-source " + source);
124 }
125
126 // Verify that a -source value less than a -target value is
127 // accepted and that the resulting class files are dependent
128 // on the target setting alone.
129 SourceTarget[] sourceTargets = SourceTarget.values();
130 for (int i = 0; i < sourceTargets.length; i++) {
131 SourceTarget st = sourceTargets[i];
132 String classFileVer = st.classFileVer();
133 String target = st.target();
134 boolean dotOne = st.dotOne();
135 check_source_target(dotOne, classFileVer, target, target);
136 for (int j = i; j > 0; j--) {
137 String source = sourceTargets[j].target();
138 check_source_target(dotOne, classFileVer, source, target);
139 }
140 }
141
142 // Verify acceptance of different combinations of -source N,
143 // -target M; N <= M
144 for (int i = 0; i < sourceTargets.length; i++) {
145 SourceTarget st = sourceTargets[i];
146
147 st.checksrc(this, "-source " + st.target());
148 st.checksrc(this, "-source " + st.target(), "-target " + st.target());
149
150 if (st.dotOne()) {
151 st.checksrc(this, "-source 1." + st.target());
152 st.checksrc(this, "-source 1." + st.target(), "-target 1." + st.target());
153 }
154
155 if (i == sourceTargets.length) {
156 // Can use -target without -source setting only for
157 // most recent target since the most recent source is
158 // the default.
159 st.checksrc(this, "-target " + st.target());
160
161 if (!st.classFileVer().equals(LATEST_MAJOR_VERSION)) {
162 throw new RuntimeException(st +
163 "does not have class file version" +
164 LATEST_MAJOR_VERSION);
165 }
166 }
167 }
168
169 // Verify that -source N -target (N-1) is rejected
170 for (int i = 1 /* Skip zeroth value */; i < sourceTargets.length; i++) {
171 fail("-source " + sourceTargets[i].target(),
172 "-target " + sourceTargets[i-1].target(),
173 "Base.java");
174 }
175
176 // Previously supported source/target values
177 for (String source : RETIRED_SOURCES) {
178 fail("-source " + source, "-target " + source, "Base.java");
179 }
180
181 if (failedCases > 0) {
182 System.err.println("failedCases = " + String.valueOf(failedCases));
183 throw new Error("Test failed");
184 }
185
186 }
187
188 protected void printargs(String fname,String... args) {
189 System.out.printf("test: %s", fname);
190 for (String onearg : args) {
191 System.out.printf(" %s", onearg);
192 }
193 System.out.printf("\n", fname);
194 }
195
196 protected void check_source_target(boolean dotOne, String... args) {
197 printargs("check_source_target", args);
198 check_target(dotOne, args[0], args[1], args[2]);
199 if (dotOne) {
200 check_target(dotOne, args[0], "1." + args[1], args[2]);
201 }
202 }
203
204 protected void check_target(boolean dotOne, String... args) {
205 check(args[0], "-source " + args[1], "-target " + args[2]);
206 if (dotOne) {
207 check(args[0], "-source " + args[1], "-target 1." + args[2]);
208 }
209 }
210
211 protected void check(String major, String... args) {
212 printargs("check", args);
213 List<String> jcargs = new ArrayList<>();
214 jcargs.add("-Xlint:-options");
215
216 // add in args conforming to List requrements of JavaCompiler
217 for (String onearg : args) {
218 String[] fields = onearg.split(" ");
219 for (String onefield : fields) {
220 jcargs.add(onefield);
221 }
222 }
223
224 boolean creturn = compile("Base.java", jcargs);
225 if (!creturn) {
226 // compilation errors note and return.. assume no class file
227 System.err.println("check: Compilation Failed");
228 System.err.println("\t classVersion:\t" + major);
229 System.err.println("\t arguments:\t" + jcargs);
230 failedCases++;
231
232 } else if (!checkClassFileVersion("Base.class", major)) {
233 failedCases++;
234 }
235 }
236
237 protected void checksrc17(String... args) {
238 printargs("checksrc17", args);
239 int asize = args.length;
240 String[] newargs = new String[asize+1];
241 System.arraycopy(args, 0, newargs,0 , asize);
242 newargs[asize] = "New17.java";
243 pass(newargs);
244 newargs[asize] = "New18.java";
245 fail(newargs);
246 }
247
248 protected void checksrc18(String... args) {
249 printargs("checksrc18", args);
250 int asize = args.length;
251 String[] newargs = new String[asize+1];
252 System.arraycopy(args, 0, newargs,0 , asize);
253 newargs[asize] = "New17.java";
254 pass(newargs);
255 newargs[asize] = "New18.java";
256 pass(newargs);
257 newargs[asize] = "New110.java";
258 fail(newargs);
259 }
260
261 protected void checksrc19(String... args) {
262 printargs("checksrc19", args);
263 checksrc18(args);
264 }
265
266 protected void checksrc110(String... args) {
267 printargs("checksrc110", args);
268 int asize = args.length;
269 String[] newargs = new String[asize+1];
270 System.arraycopy(args, 0, newargs,0 , asize);
271 newargs[asize] = "New17.java";
272 pass(newargs);
273 newargs[asize] = "New18.java";
274 pass(newargs);
275 newargs[asize] = "New110.java";
276 pass(newargs);
277 }
278
279 protected void checksrc111(String... args) {
280 printargs("checksrc111", args);
281 int asize = args.length;
282 String[] newargs = new String[asize+1];
283 System.arraycopy(args, 0, newargs,0 , asize);
284 newargs[asize] = "New17.java";
285 pass(newargs);
286 newargs[asize] = "New18.java";
287 pass(newargs);
288 newargs[asize] = "New110.java";
289 pass(newargs);
290 newargs[asize] = "New111.java";
291 pass(newargs);
292 }
293
294 protected void checksrc112(String... args) {
295 printargs("checksrc112", args);
296 checksrc111(args);
297 }
298
299 protected void checksrc113(String... args) {
300 printargs("checksrc113", args);
301 checksrc111(args);
302 }
303
304 protected void checksrc114(String... args) {
305 printargs("checksrc114", args);
306 checksrc111(args);
307 }
308
309 protected void checksrc115(String... args) {
310 printargs("checksrc115", args);
311 checksrc111(args);
312 }
313
314 protected void pass(String... args) {
315 printargs("pass", args);
316
317 List<String> jcargs = new ArrayList<String>();
318 jcargs.add("-Xlint:-options");
319
320 // add in args conforming to List requrements of JavaCompiler
321 for (String onearg : args) {
322 String[] fields = onearg.split(" ");
323 for (String onefield : fields) {
324 jcargs.add(onefield);
325 }
326 }
327
328 // empty list is error
329 if (jcargs.isEmpty()) {
330 System.err.println("error: test error in pass() - No arguments");
331 System.err.println("\t arguments:\t" + jcargs);
332 failedCases++;
333 return;
334 }
335
336 // the last argument is the filename *.java
337 String filename = jcargs.get(jcargs.size() - 1);
338 jcargs.remove(jcargs.size() - 1);
339
340 boolean creturn = compile(filename, jcargs);
341 // expect a compilation failure, failure if otherwise
342 if (!creturn) {
343 System.err.println("pass: Compilation erroneously failed");
344 System.err.println("\t arguments:\t" + jcargs);
345 System.err.println("\t file :\t" + filename);
346 failedCases++;
347
348 }
349
350 }
351
352 protected void fail(String... args) {
353 printargs("fail", args);
354
355 List<String> jcargs = new ArrayList<String>();
356 jcargs.add("-Xlint:-options");
357
358 // add in args conforming to List requrements of JavaCompiler
359 for (String onearg : args) {
360 String[] fields = onearg.split(" ");
361 for (String onefield : fields) {
362 jcargs.add(onefield);
363 }
364 }
365
366 // empty list is error
367 if (jcargs.isEmpty()) {
368 System.err.println("error: test error in fail()- No arguments");
369 System.err.println("\t arguments:\t" + jcargs);
370 failedCases++;
371 return;
372 }
373
374 // the last argument is the filename *.java
375 String filename = jcargs.get(jcargs.size() - 1);
376 jcargs.remove(jcargs.size() - 1);
377
378 boolean creturn = compile(filename, jcargs);
379 // expect a compilation failure, failure if otherwise
380 if (creturn) {
381 System.err.println("fail: Compilation erroneously succeeded");
382 System.err.println("\t arguments:\t" + jcargs);
383 System.err.println("\t file :\t" + filename);
384 failedCases++;
385 }
386 }
387
388 protected boolean compile(String sourceFile, List<String>options) {
389 JavaCompiler.CompilationTask jctask;
390 try (StandardJavaFileManager fm = javacompiler.getStandardFileManager(null, null, null)) {
391 Iterable<? extends JavaFileObject> files = fm.getJavaFileObjects(sourceFile);
392
393 jctask = javacompiler.getTask(
394 null, // Writer
395 fm, // JavaFileManager
396 null, // DiagnosticListener
397 options, // Iterable<String>
398 null, // Iterable<String> classes
399 files); // Iterable<? extends JavaFileObject>
400
401 try {
402 return jctask.call();
403 } catch (IllegalStateException e) {
404 System.err.println(e);
405 return false;
406 }
407 } catch (IOException e) {
408 throw new Error(e);
409 }
410 }
411
412 protected void writeSourceFile(String fileName, String body) throws IOException{
413 try (Writer fw = new FileWriter(fileName)) {
414 fw.write(body);
415 }
416 }
417
418 protected void genSourceFiles() throws IOException{
419 /* Create a file that executes with all supported versions. */
420 writeSourceFile("Base.java","public class Base { }\n");
421
422 /*
423 * Create a file with a new feature in 1.7, not in 1.6 : "<>"
424 */
425 writeSourceFile("New17.java",
426 "import java.util.List;\n" +
427 "import java.util.ArrayList;\n" +
428 "class New17 { List<String> s = new ArrayList<>(); }\n"
429 );
430
431 /*
432 * Create a file with a new feature in 1.8, not in 1.7 : lambda
433 */
434 writeSourceFile("New18.java",
435 "public class New18 { \n" +
436 " void m() { \n" +
437 " new Thread(() -> { }); \n" +
438 " } \n" +
439 "} \n"
440 );
441
442 /*
443 * Create a file with a new feature in 1.10, not in 1.9 : var
444 */
445 writeSourceFile("New110.java",
446 "public class New110 { \n" +
447 " void m() { \n" +
448 " var tmp = new Thread(() -> { }); \n" +
449 " } \n" +
450 "} \n"
451 );
452
453 /*
454 * Create a file with a new feature in 11, not in 10 : var for lambda parameters
455 */
456 writeSourceFile("New111.java",
457 "public class New111 { \n" +
458 " static java.util.function.Function<String,String> f = (var x) -> x.substring(0);\n" +
459 " void m(String name) { \n" +
460 " var tmp = new Thread(() -> { }, f.apply(name)); \n" +
461 " } \n" +
462 "} \n"
463 );
464 }
465
466 protected boolean checkClassFileVersion
467 (String filename,String classVersionNumber) {
468 ByteBuffer bb = ByteBuffer.allocate(1024);
469 try (FileChannel fc = new FileInputStream(filename).getChannel()) {
470 bb.clear();
471 if (fc.read(bb) < 0)
472 throw new IOException("Could not read from file : " + filename);
473 bb.flip();
474 int minor = bb.getShort(4);
475 int major = bb.getShort(6);
476 String fileVersion = major + "." + minor;
477 if (fileVersion.equals(classVersionNumber)) {
478 return true;
479 } else {
480 System.err.println("checkClassFileVersion : Failed");
481 System.err.println("\tclassfile version mismatch");
482 System.err.println("\texpected : " + classVersionNumber);
483 System.err.println("\tfound : " + fileVersion);
484 return false;
485 }
486 }
487 catch (IOException e) {
488 System.err.println("checkClassFileVersion : Failed");
489 System.err.println("\terror :\t" + e.getMessage());
490 System.err.println("\tfile:\tfilename");
491 }
492 return false;
493 }
494 }
495