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

 /*

  * Copyright (c) 2010, 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.

  */

 import java.io.PrintWriter;

 import java.io.StringWriter;

 import java.util.concurrent.ExecutorService;

 import java.util.concurrent.Executors;

 import java.util.concurrent.ThreadFactory;

 import java.util.concurrent.TimeUnit;

 import java.util.concurrent.atomic.AtomicInteger;

 import javax.tools.JavaCompiler;

 import javax.tools.StandardJavaFileManager;

 import javax.tools.ToolProvider;

 /**

  * An abstract superclass for threaded tests.

  *

  * This class will try to read a property named test.concurrency.

  * The property can be provided by passing this option to jtreg:

  * -javaoption:-Dtest.concurrency=#

  *

  * If the property is not set the class will use a heuristic to determine the

  * maximum number of threads that can be fired to execute a given test.

  */

 public abstract class JavacTestingAbstractThreadedTest {

     protected static int getThreadPoolSize() {

         Integer testConc = Integer.getInteger("test.concurrency");

         if (testConc != null) return testConc;

         int cores = Runtime.getRuntime().availableProcessors();

         return Math.max(2, Math.min(8, cores / 2));

     }

     protected static void checkAfterExec() throws InterruptedException {

         checkAfterExec(true);

     };

     protected static boolean throwAssertionOnError = true;

     protected static boolean printAll = false;

     protected static StringWriter errSWriter = new StringWriter();

     protected static PrintWriter errWriter = new PrintWriter(errSWriter);

     protected static StringWriter outSWriter = new StringWriter();

     protected static PrintWriter outWriter = new PrintWriter(outSWriter);

     protected static void checkAfterExec(boolean printCheckCount)

             throws InterruptedException {

         pool.shutdown();

         pool.awaitTermination(15, TimeUnit.MINUTES);

         if (errCount.get() > 0) {

             if (throwAssertionOnError) {

                 closePrinters();

                 System.err.println(errSWriter.toString());

                 throw new AssertionError(

                     String.format("%d errors found", errCount.get()));

             } else {

                 System.err.println(

                         String.format("%d errors found", errCount.get()));

             }

         } else if (printCheckCount) {

             outWriter.println("Total check executed: " + checkCount.get());

         }

         closePrinters();

         if (printAll) {

             System.out.println(errSWriter.toString());

             System.out.println(outSWriter.toString());

         }

     }

     protected static void closePrinters() {

         errWriter.close();

         outWriter.close();

     }

     protected static void processException(Throwable t) {

         errCount.incrementAndGet();

         t.printStackTrace(errWriter);

         pool.shutdown();

     }

     //number of checks executed

     protected static AtomicInteger checkCount = new AtomicInteger();

     //number of errors found while running combo tests

     protected static AtomicInteger errCount = new AtomicInteger();

     //create default shared JavaCompiler - reused across multiple compilations

     protected static JavaCompiler comp = ToolProvider.getSystemJavaCompiler();

     protected static ExecutorService pool = Executors.newFixedThreadPool(

             getThreadPoolSize(), new ThreadFactory() {

         @Override

         public Thread newThread(Runnable r) {

             Thread t = new Thread(r);

             t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

                 @Override

                 public void uncaughtException(Thread t, Throwable e) {

                     pool.shutdown();

                     errCount.incrementAndGet();

                     e.printStackTrace(System.err);

                 }

             });

             return t;

         }

     });

     /*

      * File manager is not thread-safe so it cannot be re-used across multiple

      * threads. However we cache per-thread FileManager to avoid excessive

      * object creation

      */

     protected static final ThreadLocal<StandardJavaFileManager> fm =

         new ThreadLocal<StandardJavaFileManager>() {

             @Override protected StandardJavaFileManager initialValue() {

                 return comp.getStandardFileManager(null, null, null);

             }

         };

 }