jdk8-mips64-public/langtools: test/tools/javac/Diagnostics/6769027/T6769027.java@809a50f24d6f (annotated)

test/tools/javac/Diagnostics/6769027/T6769027.java@809a50f24d6f (annotated)

test/tools/javac/Diagnostics/6769027/T6769027.java

Mon, 23 Sep 2013 17:27:38 +0400

author: kizune
date: Mon, 23 Sep 2013 17:27:38 +0400
changeset 2048: 809a50f24d6f
parent 1520: 5c956be64b9e
child 2525: 2eb010b6cb22
permissions: -rw-r--r--

7154966: CRs found to be in Fixed state with no test and no noreg- keyword.
Reviewed-by: ksrini

 /*
  * Copyright (c) 2009, 2013, 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     6769027 8006694
  * @summary Source line should be displayed immediately after the first diagnostic line
  *  temporarily workaround combo tests are causing time out in several platforms
  * @author  Maurizio Cimadamore
  * @library ../../lib
  * @build JavacTestingAbstractThreadedTest
  * @run main/othervm T6769027
  */
 // use /othervm to avoid jtreg timeout issues (CODETOOLS-7900047)
 // see JDK-8006746
 import java.net.URI;
 import java.util.regex.Matcher;
 import javax.tools.*;
 import com.sun.tools.javac.util.*;
 public class T6769027
     extends JavacTestingAbstractThreadedTest
     implements Runnable {
     enum OutputKind {
         RAW("rawDiagnostics","rawDiagnostics"),
         BASIC("","");
         String key;
         String value;
         void init(Options opts) {
             opts.put(key, value);
         }
         OutputKind(String key, String value) {
             this.key = key;
             this.value = value;
         }
     }
     enum CaretKind {
         DEFAULT("", ""),
         SHOW("showCaret","true"),
         HIDE("showCaret","false");
         String key;
         String value;
         void init(Options opts) {
             opts.put(key, value);
         }
         CaretKind(String key, String value) {
             this.key = key;
             this.value = value;
         }
         boolean isEnabled() {
             return this == DEFAULT || this == SHOW;
         }
     }
     enum SourceLineKind {
         DEFAULT("", ""),
         AFTER_SUMMARY("sourcePosition", "top"),
         BOTTOM("sourcePosition", "bottom");
         String key;
         String value;
         void init(Options opts) {
             opts.put(key, value);
         }
         SourceLineKind(String key, String value) {
             this.key = key;
             this.value = value;
         }
         boolean isAfterSummary() {
             return this == DEFAULT || this == AFTER_SUMMARY;
         }
     }
     enum XDiagsSource {
         DEFAULT(""),
         SOURCE("source"),
         NO_SOURCE("-source");
         String flag;
         void init(Options opts) {
             if (this != DEFAULT) {
                 String flags = opts.get("diags");
                 flags = flags == null ? flag : flags + "," + flag;
                 opts.put("diags", flags);
             }
         }
         XDiagsSource(String flag) {
             this.flag = flag;
         }
         String getOutput(CaretKind caretKind, IndentKind indent, OutputKind outKind) {
             String spaces = (outKind == OutputKind.BASIC) ? indent.string : "";
             return "\n" + spaces + "This is a source line" +
                    (caretKind.isEnabled() ? "\n" + spaces + "     ^" : "");
         }
     }
     enum XDiagsCompact {
         DEFAULT(""),
         COMPACT("short"),
         NO_COMPACT("-short");
         String flag;
         void init(Options opts) {
             if (this != DEFAULT) {
                 String flags = opts.get("diags");
                 flags = flags == null ? flag : flags + "," + flag;
                 opts.put("diags", flags);
             }
         }
         XDiagsCompact(String flag) {
             this.flag = flag;
         }
     }
     enum ErrorKind {
         SINGLE("single",
             "compiler.err.single: Hello!",
             "KXThis is a test error message Hello!"),
         DOUBLE("double",
             "compiler.err.double: Hello!",
             "KXThis is a test error message.\n" +
             "KXYThis is another line of the above error message Hello!");
         String key;
         String rawOutput;
         String nonRawOutput;
         String key() {
             return key;
         }
         ErrorKind(String key, String rawOutput, String nonRawOutput) {
             this.key = key;
             this.rawOutput = rawOutput;
             this.nonRawOutput = nonRawOutput;
         }
         String getOutput(OutputKind outKind, IndentKind summaryIndent, IndentKind detailsIndent) {
             return outKind == OutputKind.RAW ?
                 rawOutput :
                 nonRawOutput.replace("X", summaryIndent.string).replace("Y", detailsIndent.string).replace("K", "");
         }
         String getOutput(OutputKind outKind, IndentKind summaryIndent, IndentKind detailsIndent, String indent) {
             return outKind == OutputKind.RAW ?
                 rawOutput :
                 nonRawOutput.replace("X", summaryIndent.string).replace("Y", detailsIndent.string).replace("K", indent);
         }
     }
     enum MultilineKind {
         NONE(0),
         DOUBLE(1),
         NESTED(2),
         DOUBLE_NESTED(3);
         static String[][] rawTemplates = {
             {"", ",{(E),(E)}", ",{(E,{(E)})}", ",{(E,{(E)}),(E,{(E)})}"}, //ENABLED
             {"", "", "", "",""}, //DISABLED
             {"", ",{(E)}", ",{(E,{(E)})}", ",{(E,{(E)})}"}, //LIMIT_LENGTH
             {"", ",{(E),(E)}", ",{(E)}", ",{(E),(E)}"}, //LIMIT_DEPTH
             {"", ",{(E)}", ",{(E)}", ",{(E)}"}}; //LIMIT_BOTH
         static String[][] basicTemplates = {
             {"", "\nE\nE", "\nE\nQ", "\nE\nQ\nE\nQ"}, //ENABLED
             {"", "", "", "",""}, //DISABLED
             {"", "\nE", "\nE\nQ", "\nE\nQ"}, //LIMIT_LENGTH
             {"", "\nE\nE", "\nE", "\nE\nE"}, //LIMIT_DEPTH
             {"", "\nE", "\nE", "\nE"}}; //LIMIT_BOTH
         int index;
         MultilineKind (int index) {
             this.index = index;
         }
         boolean isDouble() {
             return this == DOUBLE || this == DOUBLE_NESTED;
         }
         boolean isNested() {
             return this == NESTED || this == DOUBLE_NESTED;
         }
         String getOutput(OutputKind outKind, ErrorKind errKind, MultilinePolicy policy,
                 IndentKind summaryIndent, IndentKind detailsIndent, IndentKind multiIndent) {
             String constIndent = (errKind == ErrorKind.DOUBLE) ?
                 summaryIndent.string + detailsIndent.string :
                 summaryIndent.string;
             constIndent += multiIndent.string;
             String errMsg1 = errKind.getOutput(outKind, summaryIndent, detailsIndent, constIndent);
             String errMsg2 = errKind.getOutput(outKind, summaryIndent, detailsIndent, constIndent + constIndent);
             errMsg1 = errMsg1.replaceAll("compiler.err", "compiler.misc");
             errMsg1 = errMsg1.replaceAll("error message", "subdiagnostic");
             errMsg2 = errMsg2.replaceAll("compiler.err", "compiler.misc");
             errMsg2 = errMsg2.replaceAll("error message", "subdiagnostic");
             String template = outKind == OutputKind.RAW ?
                 rawTemplates[policy.index][index] :
                 basicTemplates[policy.index][index];
             template = template.replaceAll("E", errMsg1);
             return template.replaceAll("Q", errMsg2);
         }
     }
     enum MultilinePolicy {
         ENABLED(0, "multilinePolicy", "enabled"),
         DISABLED(1, "multilinePolicy", "disabled"),
         LIMIT_LENGTH(2, "multilinePolicy", "limit:1:*"),
         LIMIT_DEPTH(3, "multilinePolicy", "limit:*:1"),
         LIMIT_BOTH(4, "multilinePolicy", "limit:1:1");
         String name;
         String value;
         int index;
         MultilinePolicy(int index, String name, String value) {
             this.name = name;
             this.value = value;
             this.index = index;
         }
         void init(Options options) {
             options.put(name, value);
         }
     }
     enum PositionKind {
         NOPOS(Position.NOPOS, "- ", "error: "),
         POS(5, "Test.java:1:6: ", "/Test.java:1: error: ");
         int pos;
         String rawOutput;
         String nonRawOutput;
         PositionKind(int pos, String rawOutput, String nonRawOutput) {
             this.pos = pos;
             this.rawOutput = rawOutput;
             this.nonRawOutput = nonRawOutput;
         }
         JCDiagnostic.DiagnosticPosition pos() {
             return new JCDiagnostic.SimpleDiagnosticPosition(pos);
         }
         String getOutput(OutputKind outputKind) {
             return outputKind == OutputKind.RAW ?
                 rawOutput :
                 nonRawOutput;
         }
     }
     static class MyFileObject extends SimpleJavaFileObject {
         private String text;
         public MyFileObject(String text) {
             super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
             this.text = text;
         }
         @Override
         public CharSequence getCharContent(boolean ignoreEncodingErrors) {
             return text;
         }
     }
     enum IndentKind {
         NONE(""),
         CUSTOM("   ");
         String string;
         IndentKind(String indent) {
             string = indent;
         }
     }
     class MyLog extends Log {
         MyLog(Context ctx) {
             super(ctx);
         }
         @Override
         protected java.io.PrintWriter getWriterForDiagnosticType(JCDiagnostic.DiagnosticType dt) {
             return outWriter;
         }
         @Override
         protected boolean shouldReport(JavaFileObject jfo, int pos) {
             return true;
         }
     }
     OutputKind outputKind;
     ErrorKind errorKind;
     MultilineKind multiKind;
     MultilinePolicy multiPolicy;
     PositionKind posKind;
     XDiagsSource xdiagsSource;
     XDiagsCompact xdiagsCompact;
     CaretKind caretKind;
     SourceLineKind sourceLineKind;
     IndentKind summaryIndent;
     IndentKind detailsIndent;
     IndentKind sourceIndent;
     IndentKind subdiagsIndent;
     T6769027(OutputKind outputKind, ErrorKind errorKind, MultilineKind multiKind,
             MultilinePolicy multiPolicy, PositionKind posKind, XDiagsSource xdiagsSource,
             XDiagsCompact xdiagsCompact, CaretKind caretKind, SourceLineKind sourceLineKind,
             IndentKind summaryIndent, IndentKind detailsIndent, IndentKind sourceIndent,
             IndentKind subdiagsIndent) {
         this.outputKind = outputKind;
         this.errorKind = errorKind;
         this.multiKind = multiKind;
         this.multiPolicy = multiPolicy;
         this.posKind = posKind;
         this.xdiagsSource = xdiagsSource;
         this.xdiagsCompact = xdiagsCompact;
         this.caretKind = caretKind;
         this.sourceLineKind = sourceLineKind;
         this.summaryIndent = summaryIndent;
         this.detailsIndent = detailsIndent;
         this.sourceIndent = sourceIndent;
         this.subdiagsIndent = subdiagsIndent;
     }
     @Override
     public void run() {
         Context ctx = new Context();
         Options options = Options.instance(ctx);
         outputKind.init(options);
         multiPolicy.init(options);
         xdiagsSource.init(options);
         xdiagsCompact.init(options);
         caretKind.init(options);
         sourceLineKind.init(options);
         String indentString = "";
         indentString = (summaryIndent == IndentKind.CUSTOM) ? "3" : "0";
         indentString += (detailsIndent == IndentKind.CUSTOM) ? "|3" : "|0";
         indentString += (sourceIndent == IndentKind.CUSTOM) ? "|3" : "|0";
         indentString += (subdiagsIndent == IndentKind.CUSTOM) ? "|3" : "|0";
         options.put("diagsIndentation", indentString);
         MyLog log = new MyLog(ctx);
         JavacMessages messages = JavacMessages.instance(ctx);
         messages.add("tester");
         JCDiagnostic.Factory diags = JCDiagnostic.Factory.instance(ctx);
         log.useSource(new MyFileObject("This is a source line"));
         JCDiagnostic d = diags.error(log.currentSource(),
             posKind.pos(),
             errorKind.key(), "Hello!");
         if (multiKind != MultilineKind.NONE) {
             JCDiagnostic sub = diags.fragment(errorKind.key(), "Hello!");
             if (multiKind.isNested())
                 sub = new JCDiagnostic.MultilineDiagnostic(sub, List.of(sub));
             List<JCDiagnostic> subdiags = multiKind.isDouble() ?
                 List.of(sub, sub) :
                 List.of(sub);
             d = new JCDiagnostic.MultilineDiagnostic(d, subdiags);
         }
         String diag = log.getDiagnosticFormatter().format(d, messages.getCurrentLocale());
         checkOutput(diag);
     }
     public static void main(String[] args) throws Exception {
         for (OutputKind outputKind : OutputKind.values()) {
             for (ErrorKind errKind : ErrorKind.values()) {
                 for (MultilineKind multiKind : MultilineKind.values()) {
                     for (MultilinePolicy multiPolicy : MultilinePolicy.values()) {
                         for (PositionKind posKind : PositionKind.values()) {
                             for (XDiagsSource xdiagsSource : XDiagsSource.values()) {
                                 for (XDiagsCompact xdiagsCompact : XDiagsCompact.values()) {
                                     for (CaretKind caretKind : CaretKind.values()) {
                                         for (SourceLineKind sourceLineKind : SourceLineKind.values()) {
                                             for (IndentKind summaryIndent : IndentKind.values()) {
                                                 for (IndentKind detailsIndent : IndentKind.values()) {
                                                     for (IndentKind sourceIndent : IndentKind.values()) {
                                                         for (IndentKind subdiagsIndent : IndentKind.values()) {
                                                             pool.execute(new T6769027(outputKind,
                                                                 errKind,
                                                                 multiKind,
                                                                 multiPolicy,
                                                                 posKind,
                                                                 xdiagsSource,
                                                                 xdiagsCompact,
                                                                 caretKind,
                                                                 sourceLineKind,
                                                                 summaryIndent,
                                                                 detailsIndent,
                                                                 sourceIndent,
                                                                 subdiagsIndent));
                                                         }
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
         checkAfterExec(false);
     }
     void printInfo(String msg, String errorLine) {
         String sep = "*********************************************************";
         String desc = "raw=" + outputKind + " pos=" + posKind + " key=" + errorKind.key() +
                 " multiline=" + multiKind +" multiPolicy=" + multiPolicy.value +
                 " diags= " + java.util.Arrays.asList(xdiagsSource.flag, xdiagsCompact.flag) +
                 " caret=" + caretKind + " sourcePosition=" + sourceLineKind +
                 " summaryIndent=" + summaryIndent + " detailsIndent=" + detailsIndent +
                 " sourceIndent=" + sourceIndent + " subdiagsIndent=" + subdiagsIndent;
         errWriter.println(sep);
         errWriter.println(desc);
         errWriter.println(sep);
         errWriter.println(msg);
         errWriter.println("Diagnostic formatting problem - expected diagnostic...\n" + errorLine);
     }
     void checkOutput(String msg) {
         boolean shouldPrintSource = posKind == PositionKind.POS &&
                 xdiagsSource != XDiagsSource.NO_SOURCE &&
                 (xdiagsSource == XDiagsSource.SOURCE ||
                 outputKind == OutputKind.BASIC);
         String errorLine = posKind.getOutput(outputKind) +
                 errorKind.getOutput(outputKind, summaryIndent, detailsIndent);
         if (xdiagsCompact != XDiagsCompact.COMPACT)
             errorLine += multiKind.getOutput(outputKind, errorKind, multiPolicy,
                     summaryIndent, detailsIndent, subdiagsIndent);
         String[] lines = errorLine.split("\n");
         if (xdiagsCompact == XDiagsCompact.COMPACT) {
             errorLine = lines[0];
             lines = new String[] {errorLine};
         }
         if (shouldPrintSource) {
             if (sourceLineKind.isAfterSummary()) {
                 String sep = "\n";
                 if (lines.length == 1) {
                     errorLine += "\n";
                     sep = "";
                 }
                 errorLine = errorLine.replaceFirst("\n",
                         Matcher.quoteReplacement(xdiagsSource.getOutput(caretKind, sourceIndent, outputKind) + sep));
             }
             else
                 errorLine += xdiagsSource.getOutput(caretKind, sourceIndent, outputKind);
         }
         if (!msg.equals(errorLine)) {
 //            printInfo(msg, errorLine);
             errCount.incrementAndGet();
         }
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/Diagnostics/6769027/T6769027.java@809a50f24d6f (annotated)

test/tools/javac/Diagnostics/6769027/T6769027.java