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

 /*

  * 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.

  *

  * 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.File;

 import java.io.IOException;

 import java.lang.annotation.Annotation;

 import java.lang.annotation.Retention;

 import java.lang.annotation.RetentionPolicy;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.net.URI;

 import java.nio.file.DirectoryStream;

 import java.nio.file.Files;

 import java.nio.file.Path;

 import java.util.Arrays;

 import java.util.HashSet;

 import java.util.Set;

 import java.util.TreeSet;

 import javax.tools.JavaFileObject;

 import javax.tools.SimpleJavaFileObject;

 /*

  * Superclass with utility methods for API tests.

  */

 class APITest {

     protected APITest() { }

     /** Marker annotation for test cases. */

     @Retention(RetentionPolicy.RUNTIME)

     @interface Test { }

     /** Invoke all methods annotated with @Test. */

     protected void run() throws Exception {

         for (Method m: getClass().getDeclaredMethods()) {

             Annotation a = m.getAnnotation(Test.class);

             if (a != null) {

                 testCount++;

                 testName = m.getName();

                 System.err.println("test: " + testName);

                 try {

                     m.invoke(this, new Object[] { });

                 } catch (InvocationTargetException e) {

                     Throwable cause = e.getCause();

                     throw (cause instanceof Exception) ? ((Exception) cause) : e;

                 }

                 System.err.println();

             }

         }

         if (testCount == 0)

             error("no tests found");

         StringBuilder summary = new StringBuilder();

         if (testCount != 1)

             summary.append(testCount).append(" tests");

         if (errorCount > 0) {

             if (summary.length() > 0) summary.append(", ");

             summary.append(errorCount).append(" errors");

         }

         System.err.println(summary);

         if (errorCount > 0)

             throw new Exception(errorCount + " errors found");

     }

     /**

      * Create a directory in which to store generated doc files.

      * Avoid using the default (current) directory, so that we can

      * be sure that javadoc is writing in the intended location,

      * not a default location.

      */

     protected File getOutDir() {

         File dir = new File(testName);

         dir.mkdirs();

         return dir;

     }

     /**

      * Create a directory in which to store generated doc files.

      * Avoid using the default (current) directory, so that we can

      * be sure that javadoc is writing in the intended location,

      * not a default location.

      */

     protected File getOutDir(String path) {

         File dir = new File(testName, path);

         dir.mkdirs();

         return dir;

     }

     protected JavaFileObject createSimpleJavaFileObject() {

         return createSimpleJavaFileObject("pkg/C", "package pkg; public class C { }");

     }

     protected JavaFileObject createSimpleJavaFileObject(final String binaryName, final String content) {

         return new SimpleJavaFileObject(

                 URI.create("myfo:///" + binaryName + ".java"), JavaFileObject.Kind.SOURCE) {

             @Override

             public CharSequence getCharContent(boolean ignoreEncoding) {

                 return content;

             }

         };

     }

     protected void checkFiles(File dir, Set<String> expectFiles) {

         Set<File> files = new HashSet<File>();

         listFiles(dir, files);

         Set<String> foundFiles = new HashSet<String>();

         URI dirURI = dir.toURI();

         for (File f: files)

             foundFiles.add(dirURI.relativize(f.toURI()).getPath());

         checkFiles(foundFiles, expectFiles, dir);

     }

     protected void checkFiles(Path dir, Set<String> expectFiles) throws IOException {

         Set<Path> files = new HashSet<Path>();

         listFiles(dir, files);

         Set<String> foundFiles = new HashSet<String>();

         for (Path f: files) {

             foundFiles.add(dir.relativize(f).toString().replace(f.getFileSystem().getSeparator(), "/"));

         }

         checkFiles(foundFiles, expectFiles, dir);

     }

     private void checkFiles(Set<String> foundFiles, Set<String> expectFiles, Object where) {

         if (!foundFiles.equals(expectFiles)) {

             Set<String> missing = new TreeSet<String>(expectFiles);

             missing.removeAll(foundFiles);

             if (!missing.isEmpty())

                 error("the following files were not found in " + where + ": " + missing);

             Set<String> unexpected = new TreeSet<String>(foundFiles);

             unexpected.removeAll(expectFiles);

             if (!unexpected.isEmpty())

                 error("the following unexpected files were found in " + where + ": " + unexpected);

         }

     }

     protected void listFiles(File dir, Set<File> files) {

         for (File f: dir.listFiles()) {

             if (f.isDirectory())

                 listFiles(f, files);

             else if (f.isFile())

                 files.add(f);

         }

     }

     private void listFiles(Path dir, Set<Path> files) throws IOException {

         try (DirectoryStream<Path> ds = Files.newDirectoryStream(dir)) {

             for (Path f: ds) {

                 if (Files.isDirectory(f))

                     listFiles(f, files);

                 else if (Files.isRegularFile(f))

                     files.add(f);

             }

         }

     }

     protected void error(String msg) {

         System.err.println("Error: " + msg);

         errorCount++;

     }

     protected int testCount;

     protected int errorCount;

     protected String testName;

     /**

      * Standard files generated by processing a documented class pkg.C.

      */

     protected static Set<String> standardExpectFiles = new HashSet<String>(Arrays.asList(

         "allclasses-frame.html",

         "allclasses-noframe.html",

         "constant-values.html",

         "deprecated-list.html",

         "help-doc.html",

         "index-all.html",

         "index.html",

         "overview-tree.html",

         "package-list",

         "pkg/C.html",

         "pkg/package-frame.html",

         "pkg/package-summary.html",

         "pkg/package-tree.html",

         "script.js",

         "stylesheet.css"

     ));

 }