--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/processing/TestWarnErrorCount.java Mon Feb 28 13:37:48 2011 -0800
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+/*
+ * @test
+ * @bug 7022337
+ * @summary repeated warnings about bootclasspath not set
+ * @library ../lib
+ * @build JavacTestingAbstractProcessor TestWarnErrorCount
+ * @run main TestWarnErrorCount
+ */
+
+import java.io.*;
+import java.util.*;
+import javax.annotation.processing.*;
+import javax.lang.model.element.*;
+import javax.tools.*;
+
+@SupportedOptions({"errKind", "msgrWarnKind", "javaWarnKind"})
+public class TestWarnErrorCount extends JavacTestingAbstractProcessor {
+ public static void main(String... args) throws Exception {
+ new TestWarnErrorCount().run(args);
+ }
+
+ final int MAX_GEN = 10;
+ final int ERROR_ROUND = MAX_GEN / 2; // when to generate error
+
+ /**
+ * Type of errors to generate in test case.
+ */
+ enum ErrorKind {
+ /** No errors. */
+ NONE,
+ /** Source code errors. */
+ JAVA,
+ /** Errors reported to Messager. */
+ MESSAGER,
+ /** Error as a result of using -Werror. */
+ WERROR,
+ }
+
+ /**
+ * Frequency of warnings in test case.
+ */
+ enum WarnKind {
+ /** No warnings. */
+ NONE {
+ boolean warn(int round) { return false; }
+ int count(int start, int end) { return 0; }
+ },
+ /** Generate a warning if round count is a multiple of 2. */
+ EVERY_TWO {
+ boolean warn(int round) { return (round % 2) == 0; }
+ int count(int start, int end) { return (end / 2) - ((start - 1)/ 2); }
+ },
+ /** Generate a warning if round count is a multiple of 3. */
+ EVERY_THREE {
+ boolean warn(int round) { return (round % 3) == 0; }
+ int count(int start, int end) { return (end / 3) - ((start - 1)/ 3); }
+ },
+ /** Generate a warning every round. */
+ ALL {
+ boolean warn(int round) { return true; }
+ int count(int start, int end) { return (end - start + 1); }
+ };
+
+ /** whether to generate a warning in round 'round'. */
+ abstract boolean warn(int round);
+
+ /** number of warnings generated in a range of rounds, inclusive. */
+ abstract int count(int start, int end);
+ }
+
+
+ /**
+ * Run test.
+ * @param args provide ability to specify particular test cases for debugging.
+ */
+ void run(String... args) throws Exception {
+ for (String arg: args) {
+ if (arg.matches("[0-9]+")) {
+ if (testCases == null)
+ testCases = new HashSet<Integer>();
+ testCases.add(Integer.valueOf(arg));
+ } else if (arg.equals("-stopOnError")) {
+ stopOnError = true;
+ } else
+ throw new IllegalArgumentException(arg);
+ }
+
+ run ();
+
+ if (errors > 0)
+ throw new Exception(errors + " errors found");
+ }
+
+ /**
+ * Run test.
+ */
+ void run() throws Exception {
+ for (ErrorKind ek: ErrorKind.values()) {
+ for (WarnKind mwk: WarnKind.values()) {
+ for (WarnKind jwk: WarnKind.values()) {
+ test(ek, mwk, jwk);
+ if (stopOnError && errors > 0)
+ throw new Exception(errors + " errors found");
+ }
+ }
+ }
+ }
+
+ boolean stopOnError;
+ Set<Integer> testCases;
+ int testNum = 0;
+
+ /**
+ * Run a test case.
+ * @param ek The type of errors to generate
+ * @param mwk The frequency of Messager warnings to generate
+ * @param jwk The frequency of Java warnings to generate
+ */
+ void test(ErrorKind ek, WarnKind mwk, WarnKind jwk) {
+ testNum++;
+
+ if (testCases != null && !testCases.contains(testNum))
+ return;
+
+ System.err.println("Test " + testNum + ": ek:" + ek + " mwk:" + mwk + " jwk:" + jwk);
+
+ File testDir = new File("test" + testNum);
+ testDir.mkdirs();
+
+ String myName = TestWarnErrorCount.class.getSimpleName();
+ File testSrc = new File(System.getProperty("test.src"));
+ File file = new File(testSrc, myName + ".java");
+
+ List<String> args = new ArrayList<String>();
+ args.addAll(Arrays.asList(
+ "-XDrawDiagnostics",
+ "-d", testDir.getPath(),
+ "-processor", myName,
+// "-XprintRounds",
+ "-Xlint",
+ "-AerrKind=" + ek,
+ "-AmsgrWarnKind=" + mwk,
+ "-AjavaWarnKind=" + jwk));
+ if (ek == ErrorKind.WERROR)
+ args.add("-Werror");
+ args.add(file.getPath());
+
+ String out = compile(args.toArray(new String[args.size()]));
+
+ int errsFound = 0;
+ int errsReported = 0;
+ int warnsFound = 0;
+ int warnsReported = 0;
+
+ // Scan the output looking for messages of interest.
+
+ for (String line: out.split("[\r\n]+")) {
+ if (line.contains("compiler.err.")) {
+ errsFound++;
+ } else if (line.contains("compiler.warn.")) {
+ warnsFound++;
+ } else if (line.matches("[0-9]+ error(?:s?)")) {
+ errsReported = Integer.valueOf(line.substring(0, line.indexOf("error")).trim());
+ } else if (line.matches("[0-9]+ warning(?:s?)")) {
+ warnsReported = Integer.valueOf(line.substring(0, line.indexOf("warning")).trim());
+ }
+ }
+
+ // Compute the expected number of errors and warnings, based on
+ // the test case parameters.
+ // This is highly specific to the annotation processor below, and to
+ // the files it generates.
+ // Generally, the rules are:
+ // -- errors stop annotation processing, allowing for one extra "last round"
+ // -- messager warnings are immediate
+ // -- javac warnings are not shown before the final compilation
+ // (FIXME? -Werror does not stop processing for java warnings)
+ int errsExpected;
+ int msgrWarnsExpected;
+ int javaWarnsExpected;
+ switch (ek) {
+ case NONE:
+ errsExpected = 0;
+ msgrWarnsExpected = mwk.count(1, 1 + MAX_GEN + 1);
+ javaWarnsExpected = jwk.count(2, 1 + MAX_GEN);
+ break;
+ case MESSAGER:
+ errsExpected = 1;
+ msgrWarnsExpected = mwk.count(1, ERROR_ROUND + 1);
+ javaWarnsExpected = 0;
+ break;
+ case JAVA:
+ errsExpected = 2;
+ msgrWarnsExpected = mwk.count(1, ERROR_ROUND + 1);
+ javaWarnsExpected = 0;
+ break;
+ case WERROR:
+ errsExpected = (mwk != WarnKind.NONE || jwk != WarnKind.NONE) ? 1 : 0;
+ switch (mwk) {
+ case NONE:
+ msgrWarnsExpected = 0;
+ javaWarnsExpected = (jwk == WarnKind.NONE)
+ ? 0
+ : 1; // this is surprising: javac only reports warning in first file
+ break;
+ case EVERY_TWO:
+ msgrWarnsExpected = mwk.count(1, 2 + 1);
+ javaWarnsExpected = 0;
+ break;
+ case EVERY_THREE:
+ msgrWarnsExpected = mwk.count(1, 3 + 1);
+ javaWarnsExpected = 0;
+ break;
+ case ALL:
+ msgrWarnsExpected = mwk.count(1, 1 + 1);
+ javaWarnsExpected = 0;
+ break;
+ default:
+ throw new IllegalStateException();
+ }
+ break;
+ default:
+ throw new IllegalStateException();
+ }
+
+ int warnsExpected = msgrWarnsExpected + javaWarnsExpected;
+ System.err.println("mwk: " + msgrWarnsExpected
+ + ", jwk: " + javaWarnsExpected
+ + ", total: " + warnsExpected);
+
+ boolean ok;
+ ok = checkEqual("errors", "reported", errsFound, errsReported);
+ ok &= checkEqual("errors", "expected", errsFound, errsExpected);
+ ok &= checkEqual("warnings", "reported", warnsFound, warnsReported);
+ ok &= checkEqual("warnings", "expected", warnsFound, warnsExpected);
+ if (ok)
+ System.err.println("OK");
+
+ System.err.println();
+ }
+
+ String compile(String... args) {
+ StringWriter sw = new StringWriter();
+ PrintWriter pw = new PrintWriter(sw);
+ int rc = com.sun.tools.javac.Main.compile(args, pw);
+ pw.close();
+ String out = sw.toString();
+ if (!out.isEmpty())
+ System.err.println(out);
+ if (rc != 0)
+ System.err.println("compilation failed: rc=" + rc);
+ return out;
+ }
+
+ boolean checkEqual(String l1, String l2, int i1, int i2) {
+ if (i1 != i2)
+ error("number of " + l1 + " found, " + i1 + ", does not match number " + l2 + ", " + i2);
+ return (i1 == i2);
+ }
+
+ void error(String msg) {
+ System.err.println("Error: " + msg);
+ errors++;
+ }
+
+ int errors = 0;
+
+ // ----- Annotation processor -----
+
+ int round = 0;
+
+ @Override
+ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+ round++;
+
+ ErrorKind ek = ErrorKind.valueOf(options.get("errKind"));
+ WarnKind mwk = WarnKind.valueOf(options.get("msgrWarnKind"));
+ WarnKind jwk = WarnKind.valueOf(options.get("javaWarnKind"));
+ messager.printMessage(Diagnostic.Kind.NOTE,
+ "Round " + round
+ + " " + roundEnv.getRootElements()
+ + ", last round: " + roundEnv.processingOver());
+ messager.printMessage(Diagnostic.Kind.NOTE,
+ "ek: " + ek + ", mwk: " + mwk + ", jwk: " + jwk);
+
+ if (round <= MAX_GEN && !roundEnv.processingOver())
+ generate("Gen" + round,
+ (ek == ErrorKind.JAVA) && (round == ERROR_ROUND),
+ jwk.warn(round));
+
+ if (mwk.warn(round))
+ messager.printMessage(Diagnostic.Kind.WARNING, "round " + round);
+
+ if ((ek == ErrorKind.MESSAGER) && (round == ERROR_ROUND))
+ messager.printMessage(Diagnostic.Kind.ERROR, "round " + round);
+
+ return true;
+ }
+
+ void generate(String name, boolean error, boolean warn) {
+ try {
+ JavaFileObject fo = filer.createSourceFile(name);
+ Writer out = fo.openWriter();
+ try {
+ out.write("class " + name + " {\n"
+ + (warn ? " int i = (int) 0;\n" : "")
+ + (error ? " ERROR\n" : "")
+ + "}\n");
+ } finally {
+ out.close();
+ }
+ } catch (IOException e) {
+ throw new Error(e);
+ }
+ }
+}