jdk8-mips64-public/langtools: comparison test/tools/javac/varargs/warning/Warn5.java

-:47147081d5b4
+:b5d0b8effc85
 * questions.
 */
 /**
 * @test
-* @bug     6993978
+* @bug     6993978 7097436
 * @summary Project Coin: Annotation to reduce varargs warnings
 * @author  mcimadamore
 * @run main Warn5
 */
 import com.sun.source.util.JavacTask;
 import com.sun.tools.javac.api.JavacTool;
 import java.net.URI;
-import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.EnumSet;
 import javax.tools.Diagnostic;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 import javax.tools.SimpleJavaFileObject;
 import javax.tools.StandardJavaFileManager;
 }
 enum MethodKind {
 METHOD("void m"),
 CONSTRUCTOR("Test");
 String name;
 MethodKind(String name) {
 this.name = name;
 this.body = body;
 this.hasAliasing = hasAliasing;
 }
 }
-static class JavaSource extends SimpleJavaFileObject {
+enum WarningKind {
+UNSAFE_BODY,
-String template = "import com.sun.tools.javac.api.*;\n" +
+UNSAFE_DECL,
-"import java.util.List;\n" +
+MALFORMED_SAFEVARARGS,
-"class Test {\n" +
+REDUNDANT_SAFEVARARGS;
-"   static void test(Object o) {}\n" +
+}
-"   static void testArr(Object[] o) {}\n" +
-"   #T \n #S #M { #B }\n" +
+// Create a single file manager and reuse it for each compile to save time.
-"}\n";
+static StandardJavaFileManager fm = JavacTool.create().getStandardFileManager(null, null, null);
-String source;
-public JavaSource(TrustMe trustMe, SuppressLevel suppressLevel, ModifierKind modKind,
-MethodKind methKind, SignatureKind meth, BodyKind body) {
-super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
-source = template.replace("#T", trustMe.anno).
-replace("#S", suppressLevel.getSuppressAnno()).
-replace("#M", meth.getSignature(modKind, methKind)).
-replace("#B", body.body);
-}
-@Override
-public CharSequence getCharContent(boolean ignoreEncodingErrors) {
-return source;
-}
-}
 public static void main(String... args) throws Exception {
 for (SourceLevel sourceLevel : SourceLevel.values()) {
 for (XlintOption xlint : XlintOption.values()) {
 for (TrustMe trustMe : TrustMe.values()) {
 for (SuppressLevel suppressLevel : SuppressLevel.values()) {
 for (ModifierKind modKind : ModifierKind.values()) {
 for (MethodKind methKind : MethodKind.values()) {
 for (SignatureKind sig : SignatureKind.values()) {
 for (BodyKind body : BodyKind.values()) {
-test(sourceLevel,
+new Warn5(sourceLevel,
 xlint,
 trustMe,
 suppressLevel,
 modKind,
 methKind,
 sig,
-body);
+body).test();
 }
 }
 }
 }
 }
 }
 }
 }
 }
-// Create a single file manager and reuse it for each compile to save time.
+final SourceLevel sourceLevel;
-static StandardJavaFileManager fm = JavacTool.create().getStandardFileManager(null, null, null);
+final XlintOption xlint;
+final TrustMe trustMe;
-static void test(SourceLevel sourceLevel, XlintOption xlint, TrustMe trustMe, SuppressLevel suppressLevel,
+final SuppressLevel suppressLevel;
-ModifierKind modKind, MethodKind methKind, SignatureKind sig, BodyKind body) throws Exception {
+final ModifierKind modKind;
+final MethodKind methKind;
+final SignatureKind sig;
+final BodyKind body;
+final JavaSource source;
+final DiagnosticChecker dc;
+public Warn5(SourceLevel sourceLevel, XlintOption xlint, TrustMe trustMe, SuppressLevel suppressLevel, ModifierKind modKind, MethodKind methKind, SignatureKind sig, BodyKind body) {
+this.sourceLevel = sourceLevel;
+this.xlint = xlint;
+this.trustMe = trustMe;
+this.suppressLevel = suppressLevel;
+this.modKind = modKind;
+this.methKind = methKind;
+this.sig = sig;
+this.body = body;
+this.source = new JavaSource();
+this.dc = new DiagnosticChecker();
+}
+void test() throws Exception {
 final JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
-JavaSource source = new JavaSource(trustMe, suppressLevel, modKind, methKind, sig, body);
-DiagnosticChecker dc = new DiagnosticChecker();
 JavacTask ct = (JavacTask)tool.getTask(null, fm, dc,
 Arrays.asList(xlint.getXlintOption(), "-source", sourceLevel.sourceKey), null, Arrays.asList(source));
 ct.analyze();
-check(sourceLevel, dc, source, xlint, trustMe,
+check();
-suppressLevel, modKind, methKind, sig, body);
+}
-}
+void check() {
-static void check(SourceLevel sourceLevel, DiagnosticChecker dc, JavaSource source,
-XlintOption xlint, TrustMe trustMe, SuppressLevel suppressLevel, ModifierKind modKind,
+EnumSet<WarningKind> expectedWarnings = EnumSet.noneOf(WarningKind.class);
-MethodKind methKind, SignatureKind meth, BodyKind body) {
+if (sourceLevel == SourceLevel.JDK_7 &&
-boolean hasPotentiallyUnsafeBody = sourceLevel == SourceLevel.JDK_7 &&
 trustMe == TrustMe.TRUST &&
 suppressLevel != SuppressLevel.VARARGS &&
 xlint != XlintOption.NONE &&
-meth.isVarargs && !meth.isReifiableArg && body.hasAliasing &&
+sig.isVarargs && !sig.isReifiableArg && body.hasAliasing &&
-(methKind == MethodKind.CONSTRUCTOR || (methKind == MethodKind.METHOD && modKind != ModifierKind.NONE));
+(methKind == MethodKind.CONSTRUCTOR || (methKind == MethodKind.METHOD && modKind != ModifierKind.NONE))) {
+expectedWarnings.add(WarningKind.UNSAFE_BODY);
-boolean hasPotentiallyPollutingDecl = sourceLevel == SourceLevel.JDK_7 &&
+}
+if (sourceLevel == SourceLevel.JDK_7 &&
 trustMe == TrustMe.DONT_TRUST &&
-meth.isVarargs &&
+sig.isVarargs &&
-!meth.isReifiableArg &&
+!sig.isReifiableArg &&
-xlint == XlintOption.ALL;
+xlint == XlintOption.ALL) {
+expectedWarnings.add(WarningKind.UNSAFE_DECL);
-boolean hasMalformedAnnoInDecl = sourceLevel == SourceLevel.JDK_7 &&
+}
+if (sourceLevel == SourceLevel.JDK_7 &&
 trustMe == TrustMe.TRUST &&
-(!meth.isVarargs ||
+(!sig.isVarargs ||
-(modKind == ModifierKind.NONE && methKind == MethodKind.METHOD));
+(modKind == ModifierKind.NONE && methKind == MethodKind.METHOD))) {
+expectedWarnings.add(WarningKind.MALFORMED_SAFEVARARGS);
-boolean hasRedundantAnnoInDecl = sourceLevel == SourceLevel.JDK_7 &&
+}
+if (sourceLevel == SourceLevel.JDK_7 &&
 trustMe == TrustMe.TRUST &&
 xlint != XlintOption.NONE &&
 suppressLevel != SuppressLevel.VARARGS &&
 (modKind != ModifierKind.NONE || methKind == MethodKind.CONSTRUCTOR) &&
-meth.isVarargs &&
+sig.isVarargs &&
-meth.isReifiableArg;
+sig.isReifiableArg) {
+expectedWarnings.add(WarningKind.REDUNDANT_SAFEVARARGS);
-if (hasPotentiallyUnsafeBody != dc.hasPotentiallyUnsafeBody ||
+}
-hasPotentiallyPollutingDecl != dc.hasPotentiallyPollutingDecl ||
-hasMalformedAnnoInDecl != dc.hasMalformedAnnoInDecl ||
+if (!expectedWarnings.containsAll(dc.warnings) ||
-hasRedundantAnnoInDecl != dc.hasRedundantAnnoInDecl) {
+!dc.warnings.containsAll(expectedWarnings)) {
 throw new Error("invalid diagnostics for source:\n" +
 source.getCharContent(true) +
 "\nOptions: " + xlint.getXlintOption() +
-"\nExpected potentially unsafe body warning: " + hasPotentiallyUnsafeBody +
+"\nExpected warnings: " + expectedWarnings +
-"\nExpected potentially polluting decl warning: " + hasPotentiallyPollutingDecl +
+"\nFound warnings: " + dc.warnings);
-"\nExpected malformed anno error: " + hasMalformedAnnoInDecl +
+}
-"\nExpected redundant anno warning: " + hasRedundantAnnoInDecl +
+}
-"\nFound potentially unsafe body warning: " + dc.hasPotentiallyUnsafeBody +
-"\nFound potentially polluting decl warning: " + dc.hasPotentiallyPollutingDecl +
+class JavaSource extends SimpleJavaFileObject {
-"\nFound malformed anno error: " + dc.hasMalformedAnnoInDecl +
-"\nFound redundant anno warning: " + dc.hasRedundantAnnoInDecl);
+String template = "import com.sun.tools.javac.api.*;\n" +
-}
+"import java.util.List;\n" +
-}
+"class Test {\n" +
+"   static void test(Object o) {}\n" +
-static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
+"   static void testArr(Object[] o) {}\n" +
+"   #T \n #S #M { #B }\n" +
-boolean hasPotentiallyUnsafeBody = false;
+"}\n";
-boolean hasPotentiallyPollutingDecl = false;
-boolean hasMalformedAnnoInDecl = false;
+String source;
-boolean hasRedundantAnnoInDecl = false;
+public JavaSource() {
+super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
+source = template.replace("#T", trustMe.anno).
+replace("#S", suppressLevel.getSuppressAnno()).
+replace("#M", sig.getSignature(modKind, methKind)).
+replace("#B", body.body);
+}
+@Override
+public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+return source;
+}
+}
+class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
+EnumSet<WarningKind> warnings = EnumSet.noneOf(WarningKind.class);
 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
 if (diagnostic.getKind() == Diagnostic.Kind.WARNING) {
 if (diagnostic.getCode().contains("unsafe.use.varargs.param")) {
-hasPotentiallyUnsafeBody = true;
+setWarning(WarningKind.UNSAFE_BODY);
 } else if (diagnostic.getCode().contains("redundant.trustme")) {
-hasRedundantAnnoInDecl = true;
+setWarning(WarningKind.REDUNDANT_SAFEVARARGS);
 }
 } else if (diagnostic.getKind() == Diagnostic.Kind.MANDATORY_WARNING &&
 diagnostic.getCode().contains("varargs.non.reifiable.type")) {
-hasPotentiallyPollutingDecl = true;
+setWarning(WarningKind.UNSAFE_DECL);
 } else if (diagnostic.getKind() == Diagnostic.Kind.ERROR &&
 diagnostic.getCode().contains("invalid.trustme")) {
-hasMalformedAnnoInDecl = true;
+setWarning(WarningKind.MALFORMED_SAFEVARARGS);
 }
 }
+void setWarning(WarningKind wk) {
+if (!warnings.add(wk)) {
+throw new AssertionError("Duplicate warning of kind " + wk + " in source:\n" + source);
+}
+}
+boolean hasWarning(WarningKind wk) {
+return warnings.contains(wk);
+}
 }
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: test/tools/javac/varargs/warning/Warn5.java

test/tools/javac/varargs/warning/Warn5.java