1 /*
   2  * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @bug     4813736 8013256
  27  * @summary Additional functionality test of task and JSR 269
  28  * @author  Peter von der Ah\u00e9
  29  * @library ./lib
  30  * @modules jdk.compiler/com.sun.tools.javac.api
  31  *          jdk.compiler/com.sun.tools.javac.code
  32  *          jdk.compiler/com.sun.tools.javac.parser
  33  *          jdk.compiler/com.sun.tools.javac.util
  34  * @build ToolTester
  35  * @run main TestJavacTaskScanner TestJavacTaskScanner.java
  36  */
  37 
  38 import com.sun.tools.javac.api.JavacTaskImpl;
  39 import com.sun.tools.javac.parser.*;
  40 import com.sun.tools.javac.parser.Tokens.Token;
  41 import com.sun.tools.javac.util.*;
  42 
  43 import java.io.*;
  44 import java.net.*;
  45 import java.nio.*;
  46 import java.nio.charset.Charset;
  47 import java.util.Arrays;
  48 
  49 import javax.lang.model.element.Element;
  50 import javax.lang.model.element.TypeElement;
  51 import javax.lang.model.type.DeclaredType;
  52 import javax.lang.model.type.TypeMirror;
  53 import javax.lang.model.util.ElementFilter;
  54 import javax.lang.model.util.Elements;
  55 import javax.lang.model.util.Types;
  56 import javax.tools.*;
  57 
  58 import static javax.tools.StandardLocation.CLASS_PATH;
  59 import static javax.tools.StandardLocation.SOURCE_PATH;
  60 import static javax.tools.StandardLocation.CLASS_OUTPUT;
  61 
  62 public class TestJavacTaskScanner extends ToolTester {
  63 
  64     final JavacTaskImpl task;
  65     final Elements elements;
  66     final Types types;
  67 
  68     int numTokens;
  69     int numParseTypeElements;
  70     int numAllMembers;
  71 
  72     TestJavacTaskScanner(File file) {
  73         final Iterable<? extends JavaFileObject> compilationUnits =
  74             fm.getJavaFileObjects(new File[] {file});
  75         StandardJavaFileManager fm = getLocalFileManager(tool, null, null);
  76         java.util.List<String> options = Arrays.asList(
  77                 "--add-exports", "jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
  78                 "--add-exports", "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
  79                 "--add-exports", "jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED",
  80                 "--add-exports", "jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED");
  81         task = (JavacTaskImpl)tool.getTask(null, fm, null, options, null, compilationUnits);
  82         task.getContext().put(ScannerFactory.scannerFactoryKey,
  83                 new MyScanner.Factory(task.getContext(), this));
  84         elements = task.getElements();
  85         types = task.getTypes();
  86     }
  87 
  88     public void run() {
  89         Iterable<? extends TypeElement> toplevels;
  90         toplevels = ElementFilter.typesIn(task.enter(task.parse()));
  91         for (TypeElement clazz : toplevels) {
  92             System.out.format("Testing %s:%n%n", clazz.getSimpleName());
  93             testParseType(clazz);
  94             testGetAllMembers(clazz);
  95             System.out.println();
  96             System.out.println();
  97             System.out.println();
  98         }
  99 
 100         System.out.println("#tokens: " + numTokens);
 101         System.out.println("#parseTypeElements: " + numParseTypeElements);
 102         System.out.println("#allMembers: " + numAllMembers);
 103 
 104         check(numTokens, "#Tokens", 1054);
 105         check(numParseTypeElements, "#parseTypeElements", 158);
 106         check(numAllMembers, "#allMembers", 52);
 107     }
 108 
 109     void check(int value, String name, int expected) {
 110         // allow some slop in the comparison to allow for minor edits in the
 111         // test and in the platform
 112         if (value < expected * 9 / 10)
 113             throw new Error(name + " lower than expected; expected " + expected + "; found: " + value);
 114         if (value > expected * 11 / 10)
 115             throw new Error(name + " higher than expected; expected " + expected + "; found: " + value);
 116     }
 117 
 118     void testParseType(TypeElement clazz) {
 119         DeclaredType type = (DeclaredType)task.parseType("List<String>", clazz);
 120         for (Element member : elements.getAllMembers((TypeElement)type.asElement())) {
 121             TypeMirror mt = types.asMemberOf(type, member);
 122             System.out.format("type#%d: %s : %s -> %s%n",
 123                 numParseTypeElements, member.getSimpleName(), member.asType(), mt);
 124             numParseTypeElements++;
 125         }
 126     }
 127 
 128     public static void main(String... args) throws IOException {
 129         String srcdir = System.getProperty("test.src");
 130         try (TestJavacTaskScanner t = new TestJavacTaskScanner(new File(srcdir, args[0]))) {
 131             t.run();
 132         }
 133     }
 134 
 135     private void testGetAllMembers(TypeElement clazz) {
 136         for (Element member : elements.getAllMembers(clazz)) {
 137             System.out.format("elem#%d: %s : %s%n",
 138                 numAllMembers, member.getSimpleName(), member.asType());
 139             numAllMembers++;
 140         }
 141     }
 142 
 143     /* Similar to ToolTester.getFileManager, except that this version also ensures
 144      * javac classes will be available on the classpath.  The javac classes are assumed
 145      * to be on the classpath used to run this test (this is true when using jtreg).
 146      * The classes are found by obtaining the URL for a sample javac class, using
 147      * getClassLoader().getResource(), and then deconstructing the URL to find the
 148      * underlying directory or jar file to place on the classpath.
 149      */
 150     public StandardJavaFileManager getLocalFileManager(JavaCompiler tool,
 151                                                         DiagnosticListener<JavaFileObject> dl,
 152                                                         Charset encoding) {
 153         StandardJavaFileManager fm = tool.getStandardFileManager(dl, null, encoding);
 154         try {
 155             fm.setLocation(SOURCE_PATH,  Arrays.asList(test_src));
 156             fm.setLocation(CLASS_PATH,   test_class_path);
 157             fm.setLocation(CLASS_OUTPUT, Arrays.asList(test_classes));
 158         } catch (IOException e) {
 159             throw new AssertionError(e);
 160         }
 161         return fm;
 162     }
 163 }
 164 
 165 class MyScanner extends Scanner {
 166 
 167     public static class Factory extends ScannerFactory {
 168         public Factory(Context context, TestJavacTaskScanner test) {
 169             super(context);
 170             this.test = test;
 171         }
 172 
 173         @Override
 174         public Scanner newScanner(CharSequence input, boolean keepDocComments) {
 175             if (input instanceof CharBuffer) {
 176                 return new MyScanner(this, (CharBuffer)input, test);
 177             } else {
 178                 char[] array = input.toString().toCharArray();
 179                 return newScanner(array, array.length, keepDocComments);
 180             }
 181         }
 182 
 183         @Override
 184         public Scanner newScanner(char[] input, int inputLength, boolean keepDocComments) {
 185             return new MyScanner(this, input, inputLength, test);
 186         }
 187 
 188         private TestJavacTaskScanner test;
 189     }
 190     protected MyScanner(ScannerFactory fac, CharBuffer buffer, TestJavacTaskScanner test) {
 191         super(fac, buffer);
 192         this.test = test;
 193     }
 194     protected MyScanner(ScannerFactory fac, char[] input, int inputLength, TestJavacTaskScanner test) {
 195         super(fac, input, inputLength);
 196         this.test = test;
 197     }
 198 
 199     public void nextToken() {
 200         super.nextToken();
 201         Token tk = token();
 202         System.err.format("Saw token %s %n", tk.kind);
 203         test.numTokens++;
 204     }
 205 
 206     private TestJavacTaskScanner test;
 207 
 208 }