jdk8-mips64-public/langtools: comparison test/tools/javac/lambda/FunctionalInterfaceConversionTest.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 8003280 8004102
 * @summary Add lambda tests
 *  perform several automated checks in lambda conversion, esp. around accessibility
 * @author  Maurizio Cimadamore
+* @library ../lib
+* @build JavacTestingAbstractThreadedTest
 * @run main FunctionalInterfaceConversionTest
 */
-import com.sun.source.util.JavacTask;
+import java.io.IOException;
 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;
+import com.sun.source.util.JavacTask;
-public class FunctionalInterfaceConversionTest {
+public class FunctionalInterfaceConversionTest
+extends JavacTestingAbstractThreadedTest
+implements Runnable {
 enum PackageKind {
 NO_PKG(""),
 PKG_A("a");
 replaceAll("#T", thrownType.typeStr);
 }
 }
 public static void main(String[] args) throws Exception {
-final JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
-StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
 for (PackageKind samPkg : PackageKind.values()) {
 for (ModifierKind modKind : ModifierKind.values()) {
 for (SamKind samKind : SamKind.values()) {
 for (MethodKind samMeth : MethodKind.values()) {
 for (MethodKind clientMeth : MethodKind.values()) {
 for (TypeKind retType : TypeKind.values()) {
 for (TypeKind argType : TypeKind.values()) {
 for (TypeKind thrownType : TypeKind.values()) {
 for (ExprKind exprKind : ExprKind.values()) {
-new FunctionalInterfaceConversionTest(samPkg, modKind, samKind,
+pool.execute(
-samMeth, clientMeth, retType, argType, thrownType, exprKind).test(comp, fm);
+new FunctionalInterfaceConversionTest(
+samPkg, modKind, samKind,
+samMeth, clientMeth, retType,
+argType, thrownType, exprKind));
 }
 }
 }
 }
 }
 }
 }
 }
 }
+checkAfterExec(false);
 }
 PackageKind samPkg;
 ModifierKind modKind;
 SamKind samKind;
 TypeKind thrownType;
 ExprKind exprKind;
 DiagnosticChecker dc;
 SourceFile samSourceFile = new SourceFile("Sam.java", "#P \n #C") {
+@Override
 public String toString() {
 return template.replaceAll("#P", samPkg.getPkgDecl()).
-replaceAll("#C", samKind.getSam(samMeth.getMethod(retType, argType, thrownType)));
+replaceAll("#C", samKind.getSam(
+samMeth.getMethod(retType, argType, thrownType)));
 }
 };
-SourceFile pkgClassSourceFile = new SourceFile("PackageClass.java",
+SourceFile pkgClassSourceFile =
-"#P\n #M class PackageClass extends Exception { }") {
+new SourceFile("PackageClass.java",
+"#P\n #M class PackageClass extends Exception { }") {
+@Override
 public String toString() {
 return template.replaceAll("#P", samPkg.getPkgDecl()).
 replaceAll("#M", modKind.modifier_str);
 }
 };
-SourceFile clientSourceFile = new SourceFile("Client.java",
+SourceFile clientSourceFile =
-"#I\n abstract class Client { \n" +
+new SourceFile("Client.java",
-"  Sam s = #E;\n" +
+"#I\n abstract class Client { \n" +
-"  #M \n }") {
+"  Sam s = #E;\n" +
+"  #M \n }") {
+@Override
 public String toString() {
 return template.replaceAll("#I", samPkg.getImportStat())
 .replaceAll("#E", exprKind.exprStr)
 .replaceAll("#M", clientMeth.getMethod(retType, argType, thrownType));
 }
 };
-FunctionalInterfaceConversionTest(PackageKind samPkg, ModifierKind modKind, SamKind samKind,
+FunctionalInterfaceConversionTest(PackageKind samPkg, ModifierKind modKind,
-MethodKind samMeth, MethodKind clientMeth, TypeKind retType, TypeKind argType,
+SamKind samKind, MethodKind samMeth, MethodKind clientMeth,
-TypeKind thrownType, ExprKind exprKind) {
+TypeKind retType, TypeKind argType, TypeKind thrownType,
+ExprKind exprKind) {
 this.samPkg = samPkg;
 this.modKind = modKind;
 this.samKind = samKind;
 this.samMeth = samMeth;
 this.clientMeth = clientMeth;
 this.thrownType = thrownType;
 this.exprKind = exprKind;
 this.dc = new DiagnosticChecker();
 }
-void test(JavaCompiler comp, StandardJavaFileManager fm) throws Exception {
+@Override
-JavacTask ct = (JavacTask)comp.getTask(null, fm, dc,
+public void run() {
-null, null, Arrays.asList(samSourceFile, pkgClassSourceFile, clientSourceFile));
+final JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
-ct.analyze();
+JavacTask ct = (JavacTask)tool.getTask(null, fm.get(), dc, null, null,
+Arrays.asList(samSourceFile, pkgClassSourceFile, clientSourceFile));
+try {
+ct.analyze();
+} catch (IOException ex) {
+throw new AssertionError("Test failing with cause", ex.getCause());
+}
 if (dc.errorFound == checkSamConversion()) {
-throw new AssertionError(samSourceFile + "\n\n" + pkgClassSourceFile + "\n\n" + clientSourceFile);
+throw new AssertionError(samSourceFile + "\n\n" +
+pkgClassSourceFile + "\n\n" + clientSourceFile);
 }
 }
 boolean checkSamConversion() {
 if (samKind != SamKind.INTERFACE) {
 @Override
 public CharSequence getCharContent(boolean ignoreEncodingErrors) {
 return toString();
 }
+@Override
 public abstract String toString();
 }
-static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
+static class DiagnosticChecker
+implements javax.tools.DiagnosticListener<JavaFileObject> {
 boolean errorFound = false;
+@Override
 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/lambda/FunctionalInterfaceConversionTest.java

test/tools/javac/lambda/FunctionalInterfaceConversionTest.java