1 /*
  2  * Copyright (c) 2017, 2018, 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 8182450
 27  * @summary Bad classfiles should not abort compilations
 28  * @library /tools/lib
 29  * @modules
 30  *      jdk.compiler/com.sun.tools.javac.api
 31  *      jdk.compiler/com.sun.tools.javac.code
 32  *      jdk.compiler/com.sun.tools.javac.comp
 33  *      jdk.compiler/com.sun.tools.javac.jvm
 34  *      jdk.compiler/com.sun.tools.javac.main
 35  *      jdk.compiler/com.sun.tools.javac.processing
 36  *      jdk.compiler/com.sun.tools.javac.util
 37  * @build toolbox.ToolBox toolbox.JavacTask
 38  * @run main NoAbortForBadClassFile
 39  */
 40 
 41 import java.nio.file.Files;
 42 import java.nio.file.Path;
 43 import java.nio.file.Paths;
 44 import java.util.ArrayList;
 45 import java.util.Arrays;
 46 import java.util.Collections;
 47 import java.util.List;
 48 import java.util.stream.Collectors;
 49 import java.util.stream.Stream;
 50 
 51 import com.sun.tools.javac.api.JavacTaskImpl;
 52 import com.sun.tools.javac.api.JavacTool;
 53 import com.sun.tools.javac.code.DeferredCompletionFailureHandler;
 54 import com.sun.tools.javac.code.Flags;
 55 import com.sun.tools.javac.code.Symbol.ClassSymbol;
 56 import com.sun.tools.javac.code.Symbol.CompletionFailure;
 57 import com.sun.tools.javac.code.Symtab;
 58 import com.sun.tools.javac.jvm.ClassReader;
 59 import com.sun.tools.javac.util.Context;
 60 import com.sun.tools.javac.util.Context.Factory;
 61 import com.sun.tools.javac.util.Names;
 62 import com.sun.tools.javac.util.Options;
 63 import toolbox.Task;
 64 import toolbox.Task.Expect;
 65 
 66 import toolbox.TestRunner;
 67 import toolbox.ToolBox;
 68 
 69 public class NoAbortForBadClassFile extends TestRunner {
 70 
 71     private ToolBox tb = new ToolBox();
 72 
 73     public NoAbortForBadClassFile() {
 74         super(System.out);
 75     }
 76 
 77     public static void main(String... args) throws Exception {
 78         new NoAbortForBadClassFile().runTests(m -> new Object[] { Paths.get(m.getName()) });
 79     }
 80 
 81     @Test
 82     public void testBrokenClassFile(Path base) throws Exception {
 83         Path classes = base.resolve("classes");
 84         Path brokenClassFile = classes.resolve("test").resolve("Broken.class");
 85 
 86         Files.createDirectories(brokenClassFile.getParent());
 87         Files.newOutputStream(brokenClassFile).close();
 88 
 89         Path src = base.resolve("src");
 90         tb.writeJavaFiles(src,
 91                           "package test; public class Test { private void test() { Broken b; String.unknown(); } }");
 92         Path out = base.resolve("out");
 93         tb.createDirectories(out);
 94 
 95         List<String> log = new toolbox.JavacTask(tb)
 96                 .options("-classpath", classes.toString(),
 97                          "-XDrawDiagnostics")
 98                 .outdir(out)
 99                 .files(tb.findJavaFiles(src))
100                 .run(Expect.FAIL)
101                 .writeAll()
102                 .getOutputLines(Task.OutputKind.DIRECT);
103 
104         List<String> expectedOut = Arrays.asList(
105                 "Test.java:1:57: compiler.err.cant.access: test.Broken, (compiler.misc.bad.class.file.header: Broken.class, (compiler.misc.class.file.wrong.class: java.lang.AutoCloseable))",
106                  "Test.java:1:73: compiler.err.cant.resolve.location.args: kindname.method, unknown, , , (compiler.misc.location: kindname.class, java.lang.String, null)",
107                  "2 errors"
108         );
109 
110         if (!expectedOut.equals(log))
111             throw new Exception("expected output not found: " + log);
112     }
113 
114     @Test
115     public void testLoading(Path base) throws Exception {
116         Path src = base.resolve("src");
117         tb.writeJavaFiles(src,
118                           "public class Test { static { new Object() {}; } public static class I { public static class II { } } }");
119         Path out = base.resolve("out");
120         tb.createDirectories(out);
121 
122         new toolbox.JavacTask(tb)
123                 .outdir(out)
124                 .options("-source", "10", "-target", "10")
125                 .files(tb.findJavaFiles(src))
126                 .run(Expect.SUCCESS)
127                 .writeAll()
128                 .getOutputLines(Task.OutputKind.DIRECT);
129 
130         List<Path> files;
131         try (Stream<Path> dir = Files.list(out)) {
132             files = dir.collect(Collectors.toList());
133         }
134 
135         List<List<Path>> result = new ArrayList<>();
136 
137         permutations(files, Collections.emptyList(), result);
138 
139         int testNum = 0;
140 
141         for (List<Path> order : result) {
142             for (Path missing : order) {
143                 Path test = base.resolve(String.valueOf(testNum++)).resolve("test");
144 
145                 tb.createDirectories(test);
146 
147                 for (Path p : order) {
148                     Files.copy(p, test.resolve(p.getFileName()));
149                 }
150 
151                 List<String> actual = complete(test, order, missing, true);
152 
153                 Files.delete(test.resolve(missing.getFileName()));
154 
155                 List<String> expected = complete(test, order, missing, false);
156 
157                 if (!actual.equals(expected)) {
158                     throw new AssertionError("Unexpected state, actual=\n" + actual + "\nexpected=\n" + expected + "\norder=" + order + "\nmissing=" + missing);
159                 }
160             }
161         }
162     }
163 
164     private static void permutations(List<Path> todo, List<Path> currentList, List<List<Path>> result) {
165         if (todo.isEmpty()) {
166             result.add(currentList);
167             return ;
168         }
169 
170         for (Path p : todo) {
171             List<Path> nextTODO = new ArrayList<>(todo);
172 
173             nextTODO.remove(p);
174 
175             List<Path> nextList = new ArrayList<>(currentList);
176 
177             nextList.add(p);
178 
179             permutations(nextTODO, nextList, result);
180         }
181     }
182 
183     private List<String> complete(Path test, List<Path> order, Path missing, boolean badClassFile) {
184         Context context = new Context();
185         if (badClassFile) {
186             TestClassReader.preRegister(context);
187         }
188         JavacTool tool = JavacTool.create();
189         JavacTaskImpl task = (JavacTaskImpl) tool.getTask(null, null, null, List.of("-classpath", test.toString(), "-XDblockClass=" + flatName(missing)), null, null, context);
190         Symtab syms = Symtab.instance(context);
191         Names names = Names.instance(context);
192 
193         DeferredCompletionFailureHandler dcfh = DeferredCompletionFailureHandler.instance(context);
194 
195         dcfh.setHandler(dcfh.javacCodeHandler);
196 
197         task.getElements().getTypeElement("java.lang.Object");
198 
199         if (!badClassFile) {
200             //to ensure the same paths taken in ClassFinder.completeEnclosing in case the file is missing:
201             syms.enterClass(syms.unnamedModule, names.fromString(flatName(missing)));
202         }
203 
204         List<String> result = new ArrayList<>();
205 
206         for (Path toCheck : order) {
207             ClassSymbol sym = syms.enterClass(syms.unnamedModule, names.fromString(flatName(toCheck)));
208 
209             try {
210                 sym.complete();
211             } catch (CompletionFailure ignore) {
212             }
213 
214             long flags = sym.flags_field;
215 
216             flags &= ~(Flags.CLASS_SEEN | Flags.SOURCE_SEEN | Flags.IDENTITY_TYPE); // earlier ACC_SUPER was dropped by javac.
217 
218             result.add("sym: " + sym.flatname + ", " + sym.owner.flatName() +
219                        ", " + sym.type + ", " + sym.members_field + ", " + flags);
220         }
221 
222         return result;
223     }
224 
225     private String flatName(Path p) {
226         return p.getFileName().toString().replace(".class", "");
227     }
228 
229     private static class TestClassReader extends ClassReader {
230         public static void preRegister(Context ctx) {
231             ctx.put(classReaderKey, (Factory<ClassReader>) c -> new TestClassReader(ctx));
232         }
233 
234         private final String block;
235 
236         public TestClassReader(Context context) {
237             super(context);
238             block = Options.instance(context).get("blockClass");
239         }
240 
241         @Override
242         public void readClassFile(ClassSymbol c) {
243             super.readClassFile(c);
244 
245             if (c.flatname.contentEquals(block)) {
246                 throw badClassFile("blocked");
247             }
248         }
249 
250     }
251 
252 }