24 /*
  25  * @test
  26  * @bug 4981566 5028634 5094412 6304984 7025786 7025789 8001112 8028545 8000961 8030610 8028546 8188870 8173382 8173382 8193290 8205619
  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 
  45 
  46 public class Versions {
  47 
  48     protected JavaCompiler javacompiler;
  49     protected int failedCases;
  50 
  51     public Versions() throws IOException {
  52         javacompiler = ToolProvider.getSystemJavaCompiler();
  53         genSourceFiles();
  54         failedCases = 0;
  55     }
  56 
  57     public static void main(String... args) throws IOException {
  58         Versions versions = new Versions();
  59         versions.run();







































































  60     }
  61 
  62     void run() {
  63 
  64         String TC = "";
  65         System.out.println("Version.java: Starting");
  66 
  67         String LATEST_MAJOR_VERSION = "56.0";
  68         check(LATEST_MAJOR_VERSION);
  69         check(LATEST_MAJOR_VERSION, "-source 1.6");
  70         check(LATEST_MAJOR_VERSION, "-source 1.7");
  71         check(LATEST_MAJOR_VERSION, "-source 1.8");
  72         check(LATEST_MAJOR_VERSION, "-source 1.9");
  73         check(LATEST_MAJOR_VERSION, "-source 1.10");
  74         check(LATEST_MAJOR_VERSION, "-source 11");
  75         check(LATEST_MAJOR_VERSION, "-source 12");
  76 
  77         check_source_target(true, "50.0", "6", "6");
  78         check_source_target(true, "51.0", "6", "7");
  79         check_source_target(true, "51.0", "7", "7");
  80         check_source_target(true, "52.0", "6", "8");
  81         check_source_target(true, "52.0", "7", "8");
  82         check_source_target(true, "52.0", "8", "8");
  83         check_source_target(true, "53.0", "6", "9");
  84         check_source_target(true, "53.0", "7", "9");
  85         check_source_target(true, "53.0", "8", "9");
  86         check_source_target(true, "53.0", "9", "9");
  87         check_source_target(true, "54.0", "6", "10");
  88         check_source_target(true, "54.0", "7", "10");
  89         check_source_target(true, "54.0", "8", "10");
  90         check_source_target(true, "54.0", "9", "10");
  91         check_source_target(true, "54.0", "10", "10");
  92         check_source_target(false, "55.0", "6", "11");
  93         check_source_target(false, "55.0", "7", "11");
  94         check_source_target(false, "55.0", "8", "11");
  95         check_source_target(false, "55.0", "9", "11");
  96         check_source_target(false, "55.0", "10", "11");
  97         check_source_target(false, "55.0", "11", "11");
  98         check_source_target(false, "56.0", "12", "12");
  99 
 100         checksrc16("-source 1.6");
 101         checksrc16("-source 6");
 102         checksrc16("-source 1.6", "-target 1.6");
 103         checksrc16("-source 6", "-target 6");
 104         checksrc17("-source 1.7");
 105         checksrc17("-source 7");
 106         checksrc17("-source 1.7", "-target 1.7");
 107         checksrc17("-source 7", "-target 7");
 108         checksrc18("-source 1.8");
 109         checksrc18("-source 8");
 110         checksrc18("-source 1.8", "-target 1.8");
 111         checksrc18("-source 8", "-target 8");
 112         checksrc19("-source 1.9");
 113         checksrc19("-source 9");
 114         checksrc19("-source 1.9", "-target 1.9");
 115         checksrc19("-source 9", "-target 9");
 116         checksrc110();
 117         checksrc110("-source 1.10");
 118         checksrc110("-source 10");
 119         checksrc110("-source 1.10", "-target 1.10");
 120         checksrc110("-source 10", "-target 10");
 121         checksrc111("-source 11");
 122         checksrc111("-source 11", "-target 11");
 123         checksrc112("-source 12");
 124         checksrc112("-source 12", "-target 12");
 125         checksrc112("-target 12");
 126 
 127         fail("-source 7", "-target 1.6", "Base.java");
 128         fail("-source 8", "-target 1.6", "Base.java");
 129         fail("-source 8", "-target 1.7", "Base.java");
 130         fail("-source 9", "-target 1.7", "Base.java");
 131         fail("-source 9", "-target 1.8", "Base.java");
 132         fail("-source 10", "-target 1.7", "Base.java");
 133         fail("-source 10", "-target 1.8", "Base.java");
 134         fail("-source 11", "-target 1.9", "Base.java");
 135         fail("-source 11", "-target 1.10", "Base.java");
 136         fail("-source 12", "-target 1.10", "Base.java");
 137         fail("-source 12", "-target 11", "Base.java");
 138 
 139         fail("-source 1.5", "-target 1.5", "Base.java");
 140         fail("-source 1.4", "-target 1.4", "Base.java");
 141         fail("-source 1.3", "-target 1.3", "Base.java");
 142         fail("-source 1.2", "-target 1.2", "Base.java");
 143 
 144         if (failedCases > 0) {
 145             System.err.println("failedCases = " + String.valueOf(failedCases));
 146             throw new Error("Test failed");
 147         }
 148 
 149     }
 150 
 151     protected void printargs(String fname,String... args) {
 152         System.out.printf("test: %s", fname);
 153         for (String onearg : args) {
 154             System.out.printf(" %s", onearg);
 155         }
 156         System.out.printf("\n", fname);
 157     }
 158 
 159     protected void check_source_target(boolean dotOne, String... args) {
 160         printargs("check_source_target", args);
 161         check_target(dotOne, args[0], args[1], args[2]);
 162         if (dotOne) {
 163             check_target(dotOne, args[0], "1." + args[1], args[2]);
 164         }
 165     }
 166 
 167     protected void check_target(boolean dotOne, String... args) {
 168         check(args[0], "-source " + args[1], "-target " + args[2]);
 169         if (dotOne) {
 170             check(args[0], "-source " + args[1], "-target 1." + args[2]);
 171         }
 172     }
 173 
 174     protected void check(String major, String... args) {
 175         printargs("check", args);
 176         List<String> jcargs = new ArrayList<>();
 177         jcargs.add("-Xlint:-options");
 178 
 179         // add in args conforming to List requrements of JavaCompiler
 180         for (String onearg : args) {
 181             String[] fields = onearg.split(" ");
 182             for (String onefield : fields) {
 183                 jcargs.add(onefield);
 184             }
 185         }
 186 
 187         boolean creturn = compile("Base.java", jcargs);
 188         if (!creturn) {
 189             // compilation errors note and return.. assume no class file
 190             System.err.println("check: Compilation Failed");
 191             System.err.println("\t classVersion:\t" + major);
 192             System.err.println("\t arguments:\t" + jcargs);
 193             failedCases++;
 194 
 195         } else if (!checkClassFileVersion("Base.class", major)) {
 196             failedCases++;
 197         }
 198     }
 199 
 200     protected void checksrc16(String... args) {
 201         printargs("checksrc16", args);
 202         int asize = args.length;
 203         String[] newargs = new String[asize + 1];
 204         System.arraycopy(args, 0, newargs, 0, asize);
 205         newargs[asize] = "Base.java";
 206         pass(newargs);
 207         newargs[asize] = "New17.java";
 208         fail(newargs);
 209     }
 210 
 211     protected void checksrc17(String... args) {
 212         printargs("checksrc17", args);
 213         int asize = args.length;
 214         String[] newargs = new String[asize+1];
 215         System.arraycopy(args, 0, newargs,0 , asize);
 216         newargs[asize] = "New17.java";
 217         pass(newargs);
 218         newargs[asize] = "New18.java";
 219         fail(newargs);
 220     }
 221 
 222     protected void checksrc18(String... args) {
 223         printargs("checksrc18", args);
 224         int asize = args.length;
 225         String[] newargs = new String[asize+1];
 226         System.arraycopy(args, 0, newargs,0 , asize);
 227         newargs[asize] = "New17.java";
 228         pass(newargs);
 229         newargs[asize] = "New18.java";
 230         pass(newargs);
 231         newargs[asize] = "New110.java";
 232         fail(newargs);
 233     }
 234 
 235     protected void checksrc19(String... args) {
 236         printargs("checksrc19", args);
 237         checksrc18(args);
 238     }
 239 
 240     protected void checksrc110(String... args) {
 241         printargs("checksrc110", args);
 242         int asize = args.length;
 243         String[] newargs = new String[asize+1];
 244         System.arraycopy(args, 0, newargs,0 , asize);
 245         newargs[asize] = "New17.java";
 246         pass(newargs);
 247         newargs[asize] = "New18.java";
 248         pass(newargs);
 249         newargs[asize] = "New110.java";
 250         pass(newargs);
 251     }
 252 
 253     protected void checksrc111(String... args) {
 254         printargs("checksrc111", args);
 255         checksrc110(args);
 256     }
 257 
 258     protected void checksrc112(String... args) {
 259         printargs("checksrc112", args);
 260         checksrc111(args);
 261     }
 262 
 263     protected void pass(String... args) {
 264         printargs("pass", args);
 265 
 266         List<String> jcargs = new ArrayList<String>();
 267         jcargs.add("-Xlint:-options");
 268 
 269         // add in args conforming to List requrements of JavaCompiler
 270         for (String onearg : args) {
 271             String[] fields = onearg.split(" ");
 272             for (String onefield : fields) {
 273                 jcargs.add(onefield);
 274             }
 275         }
 276 
 277         // empty list is error
 278         if (jcargs.isEmpty()) {
 279             System.err.println("error: test error in pass() - No arguments");
 280             System.err.println("\t arguments:\t" + jcargs);
 281             failedCases++;
 282             return;
 283         }
 284 
 285         // the last argument is the filename *.java
 286         String filename = jcargs.get(jcargs.size() - 1);
 287         jcargs.remove(jcargs.size() - 1);
 288 
 289         boolean creturn = compile(filename, jcargs);
 290         // expect a compilation failure, failure if otherwise
 291         if (!creturn) {
 292             System.err.println("pass: Compilation erroneously failed");
 293             System.err.println("\t arguments:\t" + jcargs);
 294             System.err.println("\t file     :\t" + filename);
 295             failedCases++;
 296 
 297         }
 298 
 299     }
 300 
 301     protected void fail(String... args) {
 302         printargs("fail", args);
 303 
 304         List<String> jcargs = new ArrayList<String>();
 305         jcargs.add("-Xlint:-options");
 306 
 307         // add in args conforming to List requrements of JavaCompiler
 308         for (String onearg : args) {
 309             String[] fields = onearg.split(" ");
 310             for (String onefield : fields) {
 311                 jcargs.add(onefield);
 312             }
 313         }
 314 
 315         // empty list is error
 316         if (jcargs.isEmpty()) {
 317             System.err.println("error: test error in fail()- No arguments");
 318             System.err.println("\t arguments:\t" + jcargs);
 319             failedCases++;
 320             return;
 321         }
 322 
 323         // the last argument is the filename *.java
 324         String filename = jcargs.get(jcargs.size() - 1);
 325         jcargs.remove(jcargs.size() - 1);
 326 
 327         boolean creturn = compile(filename, jcargs);
 328         // expect a compilation failure, failure if otherwise
 329         if (creturn) {
 330             System.err.println("fail: Compilation erroneously succeeded");
 331             System.err.println("\t arguments:\t" + jcargs);
 332             System.err.println("\t file     :\t" + filename);
 333             failedCases++;
 334         }
 335     }
 336 
 337     protected boolean compile(String sourceFile, List<String>options) {
 338         JavaCompiler.CompilationTask jctask;
 339         try (StandardJavaFileManager fm = javacompiler.getStandardFileManager(null, null, null)) {
 340             Iterable<? extends JavaFileObject> files = fm.getJavaFileObjects(sourceFile);
 341 
 342             jctask = javacompiler.getTask(
 343                 null,    // Writer
 344                 fm,      // JavaFileManager
 345                 null,    // DiagnosticListener
 346                 options, // Iterable<String>
 347                 null,    // Iterable<String> classes
 348                 files);  // Iterable<? extends JavaFileObject>
 349 
 350             try {
 351                 return jctask.call();
 352             } catch (IllegalStateException e) {
 353                 System.err.println(e);
 354                 return false;
 355             }
 356         } catch (IOException e) {
 357             throw new Error(e);
 358         }
 359     }
 360 
 361     protected void writeSourceFile(String fileName, String body) throws IOException{
 362         try (Writer fw = new FileWriter(fileName)) {
 363             fw.write(body);
 364         }
 365     }
 366 
 367     protected void genSourceFiles() throws IOException{
 368         /* Create a file that executes with all supported versions. */
 369         writeSourceFile("Base.java","public class Base { }\n");
 370 
 371         /*
 372          * Create a file with a new feature in 1.7, not in 1.6 : "<>"
 373          */
 374         writeSourceFile("New17.java",
 375             "import java.util.List;\n" +
 376             "import java.util.ArrayList;\n" +
 377             "class New17 { List<String> s = new ArrayList<>(); }\n"
 378         );
 379 
 380         /*
 381          * Create a file with a new feature in 1.8, not in 1.7 : lambda
 382          */
 383         writeSourceFile("New18.java",
 384             "public class New18 { \n" +
 385             "    void m() { \n" +
 386             "    new Thread(() -> { }); \n" +
 387             "    } \n" +
 388             "} \n"
 389         );
 390 
 391         /*
 392          * Create a file with a new feature in 1.10, not in 1.9 : var
 393          */
 394         writeSourceFile("New110.java",
 395             "public class New110 { \n" +
 396             "    void m() { \n" +
 397             "    var tmp = new Thread(() -> { }); \n" +
 398             "    } \n" +
 399             "} \n"
 400         );
 401 
 402     }
 403 
 404     protected boolean checkClassFileVersion
 405         (String filename,String classVersionNumber) {
 406         ByteBuffer bb = ByteBuffer.allocate(1024);
 407         try (FileChannel fc = new FileInputStream(filename).getChannel()) {
 408             bb.clear();
 409             if (fc.read(bb) < 0)
 410                 throw new IOException("Could not read from file : " + filename);
 411             bb.flip();
 412             int minor = bb.getShort(4);
 413             int major = bb.getShort(6);
 414             String fileVersion = major + "." + minor;
 415             if (fileVersion.equals(classVersionNumber)) {
 416                 return true;
 417             } else {
 418                 System.err.println("checkClassFileVersion : Failed");
 419                 System.err.println("\tclassfile version mismatch");
 420                 System.err.println("\texpected : " + classVersionNumber);
 421                 System.err.println("\tfound    : " + fileVersion);
 422                 return false;
 423             }
 424         }

  24 /*
  25  * @test
  26  * @bug 4981566 5028634 5094412 6304984 7025786 7025789 8001112 8028545 8000961 8030610 8028546 8188870 8173382 8173382 8193290 8205619
  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 
  46 public class Versions {
  47 
  48     static JavaCompiler javacompiler = ToolProvider.getSystemJavaCompiler();
  49     static int failedCases = 0;
  50 
  51     public static void main(String... args) throws IOException {

  52         genSourceFiles();
  53         run();
  54     }
  55 
  56     public static final Set<String> retiredSources =
  57         Set.of("1.2", "1.3", "1.4", "1.5");
  58 
  59     public static final Set<String> validSources =
  60         Set.of("1.6", "1.7", "1.8", "1.9", "1.10", "11", "12");
  61 
  62     public static final String LATEST_MAJOR_VERSION = "56.0";
  63 
  64     static enum SourceTarget {
  65         // Reminder: update switch in checksrc when adding or removing values.
  66         SIX(true,     "50.0",  "6"),
  67         SEVEN(true,   "51.0",  "7"),
  68         EIGHT(true,   "52.0",  "8"),
  69         NINE(true,    "53.0",  "9"),
  70         TEN(true,     "54.0", "10"),
  71         ELEVEN(false, "55.0", "11"),
  72         TWELVE(false, "56.0", "12");
  73 
  74         private boolean dotOne;
  75         private String classFileVer;
  76         private String target;
  77 
  78         private SourceTarget(boolean dotOne, String classFileVer, String target) {
  79             this.dotOne = dotOne;
  80             this.classFileVer = classFileVer;
  81             this.target = target;
  82         }
  83 
  84         public static void checksrc(SourceTarget st, String... args) {
  85             switch(st) {
  86             case SIX:
  87                 Versions.checksrc16(args);
  88                 break;
  89 
  90             case SEVEN:
  91                 Versions.checksrc17(args);
  92                 break;
  93 
  94             case EIGHT:
  95                 Versions.checksrc18(args);
  96                 break;
  97 
  98             case NINE:
  99                 Versions.checksrc19(args);
 100                 break;
 101 
 102             case TEN:
 103                 Versions.checksrc110(args);
 104                 break;
 105 
 106             case ELEVEN:
 107                 Versions.checksrc111(args);
 108                 break;
 109 
 110              case TWELVE:
 111                  Versions.checksrc112(args);
 112                  break;
 113 
 114             default:
 115                 throw new AssertionError();
 116             }
 117         }
 118 
 119         public boolean dotOne() {
 120             return dotOne;
 121         }
 122 
 123         public String classFileVer() {
 124             return classFileVer;
 125         }
 126 
 127         public String target() {
 128             return target;
 129         }
 130     }
 131 
 132     static void run() {
 133 
 134         String TC = "";
 135         System.out.println("Version.java: Starting");
 136 

 137         check(LATEST_MAJOR_VERSION);
 138         for (String source : validSources) {
 139             check(LATEST_MAJOR_VERSION, "-source " + source);
 140         }
 141         
 142         // Verify that a -source value less than a -target value is
 143         // accepted and that the resulting class files are dependent
 144         // on the target setting alone.
 145         SourceTarget[] sourceTargets = SourceTarget.values();
 146         for (int i = 0; i < sourceTargets.length; i++) {
 147             SourceTarget st = sourceTargets[i];
 148             String classFileVer = st.classFileVer();
 149             String target = st.target();
 150             boolean dotOne = st.dotOne();
 151             check_source_target(dotOne, classFileVer, target, target);
 152             for (int j = i; j > 0; j--) {
 153                 String source = sourceTargets[j].target();
 154                 check_source_target(dotOne, classFileVer, source, target);
 155             }
 156         }
 157 
 158         // Verify acceptance of different combinations of -source N,
 159         // -target N
 160         for (int i = 0; i < sourceTargets.length; i++) {
 161             SourceTarget st = sourceTargets[i];
 162             
 163             SourceTarget.checksrc(st, "-source " + st.target());
 164             SourceTarget.checksrc(st, "-source " + st.target(), "-target " + st.target());
 165 
 166             if (st.dotOne()) {
 167                 SourceTarget.checksrc(st, "-source 1." + st.target());
 168                 SourceTarget.checksrc(st, "-source 1." + st.target(), "-target 1." + st.target());
 169             }
 170 
 171             if (i == sourceTargets.length) {
 172                 // Can use -target without -source setting only for
 173                 // most recent target
 174                 SourceTarget.checksrc(st, "-target " + st.target());
 175 
 176                 if (!st.classFileVer().equals(LATEST_MAJOR_VERSION)) {
 177                     throw new RuntimeException(st +
 178                                                "does not have class file version" +
 179                                                LATEST_MAJOR_VERSION);
 180                 }
 181             }
 182         }
 183 
 184         // Verify that -source N -target (N-1) is rejected
 185         for (int i = 1 /* Skip zeroth value */; i < sourceTargets.length; i++) {
 186             fail("-source " + sourceTargets[i].target(),
 187                  "-target " + sourceTargets[i-1].target(),
 188                  "Base.java");
 189         }
 190 
 191         // Previously supported source/target values
 192         for (String source  : retiredSources) {
 193             fail("-source " + source, "-target " + source, "Base.java");
 194         }

















 195 
 196         if (failedCases > 0) {
 197             System.err.println("failedCases = " + String.valueOf(failedCases));
 198             throw new Error("Test failed");
 199         }
 200 
 201     }
 202 
 203     static void printargs(String fname,String... args) {
 204         System.out.printf("test: %s", fname);
 205         for (String onearg : args) {
 206             System.out.printf(" %s", onearg);
 207         }
 208         System.out.printf("\n", fname);
 209     }
 210 
 211     static void check_source_target(boolean dotOne, String... args) {
 212         printargs("check_source_target", args);
 213         check_target(dotOne, args[0], args[1], args[2]);
 214         if (dotOne) {
 215             check_target(dotOne, args[0], "1." + args[1], args[2]);
 216         }
 217     }
 218 
 219     static void check_target(boolean dotOne, String... args) {
 220         check(args[0], "-source " + args[1], "-target " + args[2]);
 221         if (dotOne) {
 222             check(args[0], "-source " + args[1], "-target 1." + args[2]);
 223         }
 224     }
 225 
 226     static void check(String major, String... args) {
 227         printargs("check", args);
 228         List<String> jcargs = new ArrayList<>();
 229         jcargs.add("-Xlint:-options");
 230 
 231         // add in args conforming to List requrements of JavaCompiler
 232         for (String onearg : args) {
 233             String[] fields = onearg.split(" ");
 234             for (String onefield : fields) {
 235                 jcargs.add(onefield);
 236             }
 237         }
 238 
 239         boolean creturn = compile("Base.java", jcargs);
 240         if (!creturn) {
 241             // compilation errors note and return.. assume no class file
 242             System.err.println("check: Compilation Failed");
 243             System.err.println("\t classVersion:\t" + major);
 244             System.err.println("\t arguments:\t" + jcargs);
 245             failedCases++;
 246 
 247         } else if (!checkClassFileVersion("Base.class", major)) {
 248             failedCases++;
 249         }
 250     }
 251 
 252     static void checksrc16(String... args) {
 253         printargs("checksrc16", args);
 254         int asize = args.length;
 255         String[] newargs = new String[asize + 1];
 256         System.arraycopy(args, 0, newargs, 0, asize);
 257         newargs[asize] = "Base.java";
 258         pass(newargs);
 259         newargs[asize] = "New17.java";
 260         fail(newargs);
 261     }
 262 
 263     static void checksrc17(String... args) {
 264         printargs("checksrc17", args);
 265         int asize = args.length;
 266         String[] newargs = new String[asize+1];
 267         System.arraycopy(args, 0, newargs,0 , asize);
 268         newargs[asize] = "New17.java";
 269         pass(newargs);
 270         newargs[asize] = "New18.java";
 271         fail(newargs);
 272     }
 273 
 274     static void checksrc18(String... args) {
 275         printargs("checksrc18", args);
 276         int asize = args.length;
 277         String[] newargs = new String[asize+1];
 278         System.arraycopy(args, 0, newargs,0 , asize);
 279         newargs[asize] = "New17.java";
 280         pass(newargs);
 281         newargs[asize] = "New18.java";
 282         pass(newargs);
 283         newargs[asize] = "New110.java";
 284         fail(newargs);
 285     }
 286 
 287     static void checksrc19(String... args) {
 288         printargs("checksrc19", args);
 289         checksrc18(args);
 290     }
 291 
 292     static void checksrc110(String... args) {
 293         printargs("checksrc110", args);
 294         int asize = args.length;
 295         String[] newargs = new String[asize+1];
 296         System.arraycopy(args, 0, newargs,0 , asize);
 297         newargs[asize] = "New17.java";
 298         pass(newargs);
 299         newargs[asize] = "New18.java";
 300         pass(newargs);
 301         newargs[asize] = "New110.java";
 302         pass(newargs);
 303     }
 304 
 305     static void checksrc111(String... args) {
 306         printargs("checksrc111", args);
 307         checksrc110(args);
 308     }
 309 
 310     static void checksrc112(String... args) {
 311         printargs("checksrc112", args);
 312         checksrc111(args);
 313     }
 314 
 315     static void pass(String... args) {
 316         printargs("pass", args);
 317 
 318         List<String> jcargs = new ArrayList<String>();
 319         jcargs.add("-Xlint:-options");
 320 
 321         // add in args conforming to List requrements of JavaCompiler
 322         for (String onearg : args) {
 323             String[] fields = onearg.split(" ");
 324             for (String onefield : fields) {
 325                 jcargs.add(onefield);
 326             }
 327         }
 328 
 329         // empty list is error
 330         if (jcargs.isEmpty()) {
 331             System.err.println("error: test error in pass() - No arguments");
 332             System.err.println("\t arguments:\t" + jcargs);
 333             failedCases++;
 334             return;
 335         }
 336 
 337         // the last argument is the filename *.java
 338         String filename = jcargs.get(jcargs.size() - 1);
 339         jcargs.remove(jcargs.size() - 1);
 340 
 341         boolean creturn = compile(filename, jcargs);
 342         // expect a compilation failure, failure if otherwise
 343         if (!creturn) {
 344             System.err.println("pass: Compilation erroneously failed");
 345             System.err.println("\t arguments:\t" + jcargs);
 346             System.err.println("\t file     :\t" + filename);
 347             failedCases++;
 348 
 349         }
 350 
 351     }
 352 
 353   static void fail(String... args) {
 354         printargs("fail", args);
 355 
 356         List<String> jcargs = new ArrayList<String>();
 357         jcargs.add("-Xlint:-options");
 358 
 359         // add in args conforming to List requrements of JavaCompiler
 360         for (String onearg : args) {
 361             String[] fields = onearg.split(" ");
 362             for (String onefield : fields) {
 363                 jcargs.add(onefield);
 364             }
 365         }
 366 
 367         // empty list is error
 368         if (jcargs.isEmpty()) {
 369             System.err.println("error: test error in fail()- No arguments");
 370             System.err.println("\t arguments:\t" + jcargs);
 371             failedCases++;
 372             return;
 373         }
 374 
 375         // the last argument is the filename *.java
 376         String filename = jcargs.get(jcargs.size() - 1);
 377         jcargs.remove(jcargs.size() - 1);
 378 
 379         boolean creturn = compile(filename, jcargs);
 380         // expect a compilation failure, failure if otherwise
 381         if (creturn) {
 382             System.err.println("fail: Compilation erroneously succeeded");
 383             System.err.println("\t arguments:\t" + jcargs);
 384             System.err.println("\t file     :\t" + filename);
 385             failedCases++;
 386         }
 387     }
 388 
 389     static boolean compile(String sourceFile, List<String>options) {
 390         JavaCompiler.CompilationTask jctask;
 391         try (StandardJavaFileManager fm = javacompiler.getStandardFileManager(null, null, null)) {
 392             Iterable<? extends JavaFileObject> files = fm.getJavaFileObjects(sourceFile);
 393 
 394             jctask = javacompiler.getTask(
 395                 null,    // Writer
 396                 fm,      // JavaFileManager
 397                 null,    // DiagnosticListener
 398                 options, // Iterable<String>
 399                 null,    // Iterable<String> classes
 400                 files);  // Iterable<? extends JavaFileObject>
 401 
 402             try {
 403                 return jctask.call();
 404             } catch (IllegalStateException e) {
 405                 System.err.println(e);
 406                 return false;
 407             }
 408         } catch (IOException e) {
 409             throw new Error(e);
 410         }
 411     }
 412 
 413     static void writeSourceFile(String fileName, String body) throws IOException{
 414         try (Writer fw = new FileWriter(fileName)) {
 415             fw.write(body);
 416         }
 417     }
 418 
 419     static void genSourceFiles() throws IOException{
 420         /* Create a file that executes with all supported versions. */
 421         writeSourceFile("Base.java","public class Base { }\n");
 422 
 423         /*
 424          * Create a file with a new feature in 1.7, not in 1.6 : "<>"
 425          */
 426         writeSourceFile("New17.java",
 427             "import java.util.List;\n" +
 428             "import java.util.ArrayList;\n" +
 429             "class New17 { List<String> s = new ArrayList<>(); }\n"
 430         );
 431 
 432         /*
 433          * Create a file with a new feature in 1.8, not in 1.7 : lambda
 434          */
 435         writeSourceFile("New18.java",
 436             "public class New18 { \n" +
 437             "    void m() { \n" +
 438             "    new Thread(() -> { }); \n" +
 439             "    } \n" +
 440             "} \n"
 441         );
 442 
 443         /*
 444          * Create a file with a new feature in 1.10, not in 1.9 : var
 445          */
 446         writeSourceFile("New110.java",
 447             "public class New110 { \n" +
 448             "    void m() { \n" +
 449             "    var tmp = new Thread(() -> { }); \n" +
 450             "    } \n" +
 451             "} \n"
 452         );
 453 
 454     }
 455 
 456     static boolean checkClassFileVersion
 457         (String filename,String classVersionNumber) {
 458         ByteBuffer bb = ByteBuffer.allocate(1024);
 459         try (FileChannel fc = new FileInputStream(filename).getChannel()) {
 460             bb.clear();
 461             if (fc.read(bb) < 0)
 462                 throw new IOException("Could not read from file : " + filename);
 463             bb.flip();
 464             int minor = bb.getShort(4);
 465             int major = bb.getShort(6);
 466             String fileVersion = major + "." + minor;
 467             if (fileVersion.equals(classVersionNumber)) {
 468                 return true;
 469             } else {
 470                 System.err.println("checkClassFileVersion : Failed");
 471                 System.err.println("\tclassfile version mismatch");
 472                 System.err.println("\texpected : " + classVersionNumber);
 473                 System.err.println("\tfound    : " + fileVersion);
 474                 return false;
 475             }
 476         }