jdk8-mips64-public/langtools: comparison test/tools/javac/cast/intersection/IntersectionTypeCastTest.java

-:d07340b61e6a
+:954541f13717
 /*
-* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 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.
 /*
 * @test
 * @bug 8002099
 * @summary Add support for intersection types in cast expression
+* @library ../../lib
+* @build JavacTestingAbstractThreadedTest
+* @run main/timeout=360 IntersectionTypeCastTest
 */
-import com.sun.source.util.JavacTask;
-import com.sun.tools.javac.util.List;
-import com.sun.tools.javac.util.ListBuffer;
 import java.net.URI;
 import java.util.Arrays;
 import javax.tools.Diagnostic;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 import javax.tools.SimpleJavaFileObject;
-import javax.tools.StandardJavaFileManager;
 import javax.tools.ToolProvider;
-public class IntersectionTypeCastTest {
+import com.sun.source.util.JavacTask;
+import com.sun.tools.javac.util.List;
-static int checkCount = 0;
+import com.sun.tools.javac.util.ListBuffer;
+public class IntersectionTypeCastTest
+extends JavacTestingAbstractThreadedTest
+implements Runnable {
 interface Type {
 boolean subtypeOf(Type that);
 String asString();
 boolean isClass();
 String declStr;
 String typeStr;
 InterfaceKind superInterface;
-InterfaceKind(String declStr, String typeStr, InterfaceKind superInterface) {
+InterfaceKind(String declStr, String typeStr,
+InterfaceKind superInterface) {
 this.declStr = declStr;
 this.typeStr = typeStr;
 this.superInterface = superInterface;
 }
 @Override
 public boolean subtypeOf(Type that) {
-return this == that || superInterface == that || that == ClassKind.OBJECT;
+return this == that || superInterface == that ||
+that == ClassKind.OBJECT;
 }
 @Override
 public String asString() {
 return typeStr;
 }
 }
 enum ClassKind implements Type {
 OBJECT(null, "Object"),
-CA("#M class CA implements A { }\n", "CA", InterfaceKind.A),
+CA("#M class CA implements A { }\n", "CA",
-CB("#M class CB implements B { }\n", "CB", InterfaceKind.B),
+InterfaceKind.A),
-CAB("#M class CAB implements A, B { }\n", "CAB", InterfaceKind.A, InterfaceKind.B),
+CB("#M class CB implements B { }\n", "CB",
-CC("#M class CC implements C { }\n", "CC", InterfaceKind.C, InterfaceKind.A),
+InterfaceKind.B),
-CCA("#M class CCA implements C, A { }\n", "CCA", InterfaceKind.C, InterfaceKind.A),
+CAB("#M class CAB implements A, B { }\n", "CAB",
-CCB("#M class CCB implements C, B { }\n", "CCB", InterfaceKind.C, InterfaceKind.A, InterfaceKind.B),
+InterfaceKind.A, InterfaceKind.B),
-CCAB("#M class CCAB implements C, A, B { }\n", "CCAB", InterfaceKind.C, InterfaceKind.A, InterfaceKind.B);
+CC("#M class CC implements C { }\n", "CC",
+InterfaceKind.C, InterfaceKind.A),
+CCA("#M class CCA implements C, A { }\n", "CCA",
+InterfaceKind.C, InterfaceKind.A),
+CCB("#M class CCB implements C, B { }\n", "CCB",
+InterfaceKind.C, InterfaceKind.A, InterfaceKind.B),
+CCAB("#M class CCAB implements C, A, B { }\n", "CCAB",
+InterfaceKind.C, InterfaceKind.A, InterfaceKind.B);
 String declTemplate;
 String typeStr;
 List<InterfaceKind> superInterfaces;
-ClassKind(String declTemplate, String typeStr, InterfaceKind... superInterfaces) {
+ClassKind(String declTemplate, String typeStr,
+InterfaceKind... superInterfaces) {
 this.declTemplate = declTemplate;
 this.typeStr = typeStr;
 this.superInterfaces = List.from(superInterfaces);
 }
 "";
 }
 @Override
 public boolean subtypeOf(Type that) {
-return this == that || superInterfaces.contains(that) || that == OBJECT;
+return this == that || superInterfaces.contains(that) ||
+that == OBJECT;
 }
 @Override
 public String asString() {
 return typeStr;
 this.kind = kind;
 this.types = types;
 }
 String getCast() {
-String temp = kind.castTemplate.replaceAll("#C", types[0].asString());
+String temp = kind.castTemplate.replaceAll("#C",
+types[0].asString());
 for (int i = 0; i < kind.interfaceBounds ; i++) {
-temp = temp.replace(String.format("#I%d", i), types[i + 1].asString());
+temp = temp.replace(String.format("#I%d", i),
+types[i + 1].asString());
 }
 return temp;
 }
 boolean hasDuplicateTypes() {
 for (Type t2 : that.types) {
 boolean compat =
 t1.subtypeOf(t2) ||
 t2.subtypeOf(t1) ||
 (t1.isInterface() && t2.isInterface()) || //side-cast (1)
-(mod == ModifierKind.NONE && (t1.isInterface() != t2.isInterface())); //side-cast (2)
+(mod == ModifierKind.NONE &&
+(t1.isInterface() != t2.isInterface())); //side-cast (2)
 if (!compat) return false;
 }
 }
 return true;
 }
 }
 public static void main(String... args) throws Exception {
-//create default shared JavaCompiler - reused across multiple compilations
-JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
-StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
 for (ModifierKind mod : ModifierKind.values()) {
 for (CastInfo cast1 : allCastInfo()) {
 for (CastInfo cast2 : allCastInfo()) {
-new IntersectionTypeCastTest(mod, cast1, cast2).run(comp, fm);
+pool.execute(
+new IntersectionTypeCastTest(mod, cast1, cast2));
 }
 }
 }
-System.out.println("Total check executed: " + checkCount);
+checkAfterExec();
 }
 static List<CastInfo> allCastInfo() {
 ListBuffer<CastInfo> buf = ListBuffer.lb();
 for (CastKind kind : CastKind.values()) {
 buf.append(new CastInfo(kind, clazz, intf1));
 continue;
 } else {
 for (InterfaceKind intf2 : InterfaceKind.values()) {
 if (kind.interfaceBounds == 2) {
-buf.append(new CastInfo(kind, clazz, intf1, intf2));
+buf.append(
+new CastInfo(kind, clazz, intf1, intf2));
 continue;
 } else {
 for (InterfaceKind intf3 : InterfaceKind.values()) {
-buf.append(new CastInfo(kind, clazz, intf1, intf2, intf3));
+buf.append(
+new CastInfo(kind, clazz, intf1,
+intf2, intf3));
 continue;
 }
 }
 }
 }
 this.cast2 = cast2;
 this.source = new JavaSource();
 this.diagChecker = new DiagnosticChecker();
 }
+@Override
+public void run() {
+final JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
+JavacTask ct = (JavacTask)tool.getTask(null, fm.get(), diagChecker,
+Arrays.asList("-XDallowIntersectionTypes"),
+null, Arrays.asList(source));
+try {
+ct.analyze();
+} catch (Throwable ex) {
+throw new AssertionError("Error thrown when compiling the following code:\n" +
+source.getCharContent(true));
+}
+check();
+}
 class JavaSource extends SimpleJavaFileObject {
 String bodyTemplate = "class Test {\n" +
 "   void test() {\n" +
 "      Object o = #C1#C2null;\n" +
 source += ck.getDecl(mod);
 }
 for (InterfaceKind ik : InterfaceKind.values()) {
 source += ik.declStr;
 }
-source += bodyTemplate.replaceAll("#C1", cast1.getCast()).replaceAll("#C2", cast2.getCast());
+source += bodyTemplate.replaceAll("#C1", cast1.getCast()).
+replaceAll("#C2", cast2.getCast());
 }
 @Override
 public CharSequence getCharContent(boolean ignoreEncodingErrors) {
 return source;
 }
 }
-void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
-JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
-Arrays.asList("-XDallowIntersectionTypes"), null, Arrays.asList(source));
-try {
-ct.analyze();
-} catch (Throwable ex) {
-throw new AssertionError("Error thrown when compiling the following code:\n" + source.getCharContent(true));
-}
-check();
-}
 void check() {
-checkCount++;
+checkCount.incrementAndGet();
-boolean errorExpected = cast1.hasDuplicateTypes() || cast2.hasDuplicateTypes();
+boolean errorExpected = cast1.hasDuplicateTypes() ||
+cast2.hasDuplicateTypes();
 errorExpected |= !cast2.compatibleWith(mod, cast1);
 if (errorExpected != diagChecker.errorFound) {
 throw new Error("invalid diagnostics for source:\n" +
 "\nFound error: " + diagChecker.errorFound +
 "\nExpected error: " + errorExpected);
 }
 }
-static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
+static class DiagnosticChecker
+implements javax.tools.DiagnosticListener<JavaFileObject> {
 boolean errorFound;
 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
 if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
 errorFound = true;
 }
 }
 }
 }

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

comparison: test/tools/javac/cast/intersection/IntersectionTypeCastTest.java

test/tools/javac/cast/intersection/IntersectionTypeCastTest.java