1 /*
2 * Copyright (c) 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 import javax.tools.Diagnostic;
25 import javax.tools.DiagnosticListener;
26 import javax.tools.FileObject;
27 import javax.tools.ForwardingJavaFileManager;
28 import javax.tools.JavaCompiler;
29 import javax.tools.JavaFileObject;
30 import javax.tools.SimpleJavaFileObject;
31 import javax.tools.StandardJavaFileManager;
32 import javax.tools.StandardLocation;
33 import javax.tools.ToolProvider;
34 import java.io.BufferedReader;
35 import java.io.ByteArrayOutputStream;
36 import java.io.IOException;
37 import java.io.InputStreamReader;
38 import java.io.OutputStream;
39 import java.io.UncheckedIOException;
40 import java.lang.reflect.Method;
41 import java.net.URI;
42 import java.nio.charset.Charset;
43 import java.util.ArrayList;
44 import java.util.HashMap;
45 import java.util.List;
46 import java.util.Locale;
47 import java.util.Map;
48 import java.util.regex.Pattern;
49 import java.util.stream.Collectors;
50 import java.util.stream.IntStream;
51 import java.util.stream.Stream;
52
53 import static java.util.stream.Collectors.joining;
54 import static java.util.stream.Collectors.toMap;
55
56 /*
57 * @test
58 * @bug 8062389
59 * @summary Nearly exhaustive test of Class.getMethod() and Class.getMethods()
60 * @run main PublicMethodsTest
61 */
62 public class PublicMethodsTest {
63
64 public static void main(String[] args) {
65 Case c = new Case1();
66
67 int[] diffs = new int[1];
68 try (Stream<Map.Entry<int[], Map<String, String>>>
69 expected = expectedResults(c)) {
70 diffResults(c, expected)
71 .forEach(diff -> {
72 System.out.println(diff);
73 diffs[0]++;
74 });
75 }
76
77 if (diffs[0] > 0) {
78 throw new RuntimeException(
79 "There were " + diffs[0] + " differences.");
80 }
81 }
82
83 // use this to generate .results file for particular case
84 public static class Generate {
85 public static void main(String[] args) {
86 Case c = new Case1();
87 dumpResults(generateResults(c))
88 .forEach(System.out::println);
89 }
90 }
91
92 interface Case {
93 Pattern PLACEHOLDER_PATTERN = Pattern.compile("\\$\\{(.+?)}");
94
95 // possible variants of interface method
96 List<String> INTERFACE_METHODS = List.of(
97 "", "void m();", "default void m() {}", "static void m() {}"
98 );
99
100 // possible variants of class method
101 List<String> CLASS_METHODS = List.of(
102 "", "public abstract void m();",
103 "public void m() {}", "public static void m() {}"
104 );
105
106 // template with placeholders parsed with PLACEHOLDER_PATTERN
107 String template();
108
109 // map of replacementKey (== PLACEHOLDER_PATTERN captured group #1) ->
110 // list of possible replacements
111 Map<String, List<String>> replacements();
112
113 // ordered list of replacement keys
114 List<String> replacementKeys();
115
116 // names of types occurring in the template
117 List<String> classNames();
118 }
119
120 static class Case1 implements Case {
121
122 private static final String TEMPLATE = Stream.of(
123 "interface I { ${I} }",
124 "interface J { ${J} }",
125 "interface K extends I, J { ${K} }",
126 "abstract class C { ${C} }",
127 "abstract class D extends C implements I { ${D} }",
128 "abstract class E extends D implements J, K { ${E} }"
129 ).collect(joining("\n"));
130
131 private static final Map<String, List<String>> REPLACEMENTS = Map.of(
132 "I", INTERFACE_METHODS,
133 "J", INTERFACE_METHODS,
134 "K", INTERFACE_METHODS,
135 "C", CLASS_METHODS,
136 "D", CLASS_METHODS,
137 "E", CLASS_METHODS
138 );
139
140 private static final List<String> REPLACEMENT_KEYS = REPLACEMENTS
141 .keySet().stream().sorted().collect(Collectors.toList());
142
143 @Override
144 public String template() {
145 return TEMPLATE;
146 }
147
148 @Override
149 public Map<String, List<String>> replacements() {
150 return REPLACEMENTS;
151 }
152
153 @Override
154 public List<String> replacementKeys() {
155 return REPLACEMENT_KEYS;
156 }
157
158 @Override
159 public List<String> classNames() {
160 // just by accident, names of classes are equal to replacement keys
161 // (this need not be the case in general)
162 return REPLACEMENT_KEYS;
163 }
164 }
165
166 // generate all combinations as a tuple of indexes into lists of
167 // replacements. The index of the element in int[] tuple represents the index
168 // of the key in replacementKeys() list. The value of the element in int[] tuple
169 // represents the index of the replacement string in list of strings in the
170 // value of the entry of replacements() map with the corresponding key.
171 static Stream<int[]> combinations(Case c) {
172 int[] sizes = c.replacementKeys().stream()
173 .mapToInt(key -> c.replacements().get(key).size())
174 .toArray();
175
176 return Stream.iterate(
177 new int[sizes.length],
178 state -> state != null,
179 state -> {
180 int[] newState = state.clone();
181 for (int i = 0; i < state.length; i++) {
182 if (++newState[i] < sizes[i]) {
183 return newState;
184 }
185 newState[i] = 0;
186 }
187 // wrapped-around
188 return null;
189 }
190 );
191 }
192
193 // given the combination of indexes, return the expanded template
194 static String expandTemplate(Case c, int[] combination) {
195
196 // 1st create a map: key -> replacement string
197 Map<String, String> map = new HashMap<>(combination.length * 4 / 3 + 1);
198 for (int i = 0; i < combination.length; i++) {
199 String key = c.replacementKeys().get(i);
200 String repl = c.replacements().get(key).get(combination[i]);
201 map.put(key, repl);
202 }
203
204 return Case.PLACEHOLDER_PATTERN
205 .matcher(c.template())
206 .replaceAll(match -> map.get(match.group(1)));
207 }
208
209 /**
210 * compile expanded template into a ClassLoader that sees compiled classes
211 */
212 static ClassLoader compile(String source) throws CompileException {
213 JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
214 if (javac == null) {
215 throw new AssertionError("No Java compiler tool found.");
216 }
217
218 ErrorsCollector errorsCollector = new ErrorsCollector();
219 StandardJavaFileManager standardJavaFileManager =
220 javac.getStandardFileManager(errorsCollector, Locale.ROOT,
221 Charset.forName("UTF-8"));
222 TestFileManager testFileManager = new TestFileManager(
223 standardJavaFileManager, source);
224
225 JavaCompiler.CompilationTask javacTask;
226 try {
227 javacTask = javac.getTask(
228 null, // use System.err
229 testFileManager,
230 errorsCollector,
231 null,
232 null,
233 List.of(testFileManager.getJavaFileForInput(
234 StandardLocation.SOURCE_PATH,
235 TestFileManager.TEST_CLASS_NAME,
236 JavaFileObject.Kind.SOURCE))
237 );
238 } catch (IOException e) {
239 throw new UncheckedIOException(e);
240 }
241
242 javacTask.call();
243
244 if (errorsCollector.hasError()) {
245 throw new CompileException(errorsCollector.getErrors());
246 }
247
248 return new TestClassLoader(ClassLoader.getSystemClassLoader(),
249 testFileManager);
250 }
251
252 static class CompileException extends Exception {
253 CompileException(List<Diagnostic<?>> diagnostics) {
254 super(diagnostics.stream()
255 .map(diag -> diag.toString())
256 .collect(Collectors.joining("\n")));
257 }
258 }
259
260 static class TestFileManager
261 extends ForwardingJavaFileManager<StandardJavaFileManager> {
262 static final String TEST_CLASS_NAME = "Test";
263
264 private final String testSource;
265 private final Map<String, ClassFileObject> classes = new HashMap<>();
266
267 TestFileManager(StandardJavaFileManager fileManager, String source) {
268 super(fileManager);
269 testSource = "public class " + TEST_CLASS_NAME + " {}\n" +
270 source; // the rest of classes are package-private
271 }
272
273 @Override
274 public JavaFileObject getJavaFileForInput(Location location,
275 String className,
276 JavaFileObject.Kind kind)
277 throws IOException {
278 if (location == StandardLocation.SOURCE_PATH &&
279 kind == JavaFileObject.Kind.SOURCE &&
280 TEST_CLASS_NAME.equals(className)) {
281 return new SourceFileObject(className, testSource);
282 }
283 return super.getJavaFileForInput(location, className, kind);
284 }
285
286 private static class SourceFileObject extends SimpleJavaFileObject {
287 private final String source;
288
289 SourceFileObject(String className, String source) {
290 super(
291 URI.create("memory:/src/" +
292 className.replace('.', '/') + ".java"),
293 Kind.SOURCE
294 );
295 this.source = source;
296 }
297
298 @Override
299 public CharSequence getCharContent(boolean ignoreEncodingErrors) {
300 return source;
301 }
302 }
303
304 @Override
305 public JavaFileObject getJavaFileForOutput(Location location,
306 String className,
307 JavaFileObject.Kind kind,
308 FileObject sibling)
309 throws IOException {
310 if (kind == JavaFileObject.Kind.CLASS) {
311 ClassFileObject cfo = new ClassFileObject(className);
312 classes.put(className, cfo);
313 return cfo;
314 }
315 return super.getJavaFileForOutput(location, className, kind, sibling);
316 }
317
318 private static class ClassFileObject extends SimpleJavaFileObject {
319 final String className;
320 ByteArrayOutputStream byteArrayOutputStream;
321
322 ClassFileObject(String className) {
323 super(
324 URI.create("memory:/out/" +
325 className.replace('.', '/') + ".class"),
326 Kind.CLASS
327 );
328 this.className = className;
329 }
330
331 @Override
332 public OutputStream openOutputStream() throws IOException {
333 return byteArrayOutputStream = new ByteArrayOutputStream();
334 }
335
336 byte[] getBytes() {
337 if (byteArrayOutputStream == null) {
338 throw new IllegalStateException(
339 "No class file written for class: " + className);
340 }
341 return byteArrayOutputStream.toByteArray();
342 }
343 }
344
345 byte[] getClassBytes(String className) {
346 ClassFileObject cfo = classes.get(className);
347 return (cfo == null) ? null : cfo.getBytes();
348 }
349 }
350
351 static class ErrorsCollector implements DiagnosticListener<JavaFileObject> {
352 private final List<Diagnostic<?>> errors = new ArrayList<>();
353
354 @Override
355 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
356 if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
357 errors.add(diagnostic);
358 }
359 }
360
361 boolean hasError() {
362 return !errors.isEmpty();
363 }
364
365 List<Diagnostic<?>> getErrors() {
366 return errors;
367 }
368 }
369
370 static class TestClassLoader extends ClassLoader {
371 private final TestFileManager fileManager;
372
373 public TestClassLoader(ClassLoader parent, TestFileManager fileManager) {
374 super(parent);
375 this.fileManager = fileManager;
376 }
377
378 @Override
379 protected Class<?> findClass(String name) throws ClassNotFoundException {
380 byte[] classBytes = fileManager.getClassBytes(name);
381 if (classBytes == null) {
382 throw new ClassNotFoundException(name);
383 }
384 return defineClass(name, classBytes, 0, classBytes.length);
385 }
386 }
387
388 static Map<String, String> generateResult(Case c, ClassLoader cl) {
389 return
390 c.classNames()
391 .stream()
392 .map(cn -> {
393 try {
394 return Class.forName(cn, false, cl);
395 } catch (ClassNotFoundException e) {
396 throw new RuntimeException("Class not found: " + cn, e);
397 }
398 })
399 .flatMap(clazz -> Stream.of(
400 Map.entry(clazz.getName() + ".gM", generateGetMethodResult(clazz)),
401 Map.entry(clazz.getName() + ".gMs", generateGetMethodsResult(clazz))
402 ))
403 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
404 }
405
406 static String generateGetMethodResult(Class<?> clazz) {
407 try {
408 Method m = clazz.getMethod("m");
409 return m.getDeclaringClass().getName() + "." + m.getName();
410 } catch (NoSuchMethodException e) {
411 return "-";
412 }
413 }
414
415 static String generateGetMethodsResult(Class<?> clazz) {
416 return Stream.of(clazz.getMethods())
417 .filter(m -> m.getDeclaringClass() != Object.class)
418 .map(m -> m.getDeclaringClass().getName()
419 + "." + m.getName())
420 .collect(Collectors.joining(", ", "[", "]"));
421 }
422
423 static Stream<Map.Entry<int[], Map<String, String>>> generateResults(Case c) {
424 return combinations(c)
425 .flatMap(comb -> {
426 String src = expandTemplate(c, comb);
427 ClassLoader cl;
428 try {
429 cl = compile(src);
430 } catch (CompileException e) {
431 // ignore uncompilable combinations
432 return Stream.empty();
433 }
434 // compilation was successful -> generate result
435 return Stream.of(Map.entry(
436 comb,
437 generateResult(c, cl)
438 ));
439 });
440 }
441
442 static Stream<Map.Entry<int[], Map<String, String>>> expectedResults(Case c) {
443 try {
444 BufferedReader r = new BufferedReader(new InputStreamReader(
445 c.getClass().getResourceAsStream(
446 c.getClass().getSimpleName() + ".results"),
447 "UTF-8"
448 ));
449
450 return parseResults(r.lines())
451 .onClose(() -> {
452 try {
453 r.close();
454 } catch (IOException ioe) {
455 throw new UncheckedIOException(ioe);
456 }
457 });
458 } catch (IOException e) {
459 throw new UncheckedIOException(e);
460 }
461 }
462
463 static Stream<Map.Entry<int[], Map<String, String>>> parseResults(
464 Stream<String> lines
465 ) {
466 return lines
467 .map(l -> l.split(Pattern.quote("#")))
468 .map(lkv -> Map.entry(
469 Stream.of(lkv[0].split(Pattern.quote(",")))
470 .mapToInt(Integer::parseInt)
471 .toArray(),
472 Stream.of(lkv[1].split(Pattern.quote("|")))
473 .map(e -> e.split(Pattern.quote("=")))
474 .collect(toMap(ekv -> ekv[0], ekv -> ekv[1]))
475 ));
476 }
477
478 static Stream<String> dumpResults(
479 Stream<Map.Entry<int[], Map<String, String>>> results
480 ) {
481 return results
482 .map(le ->
483 IntStream.of(le.getKey())
484 .mapToObj(String::valueOf)
485 .collect(joining(","))
486 + "#" +
487 le.getValue().entrySet().stream()
488 .map(e -> e.getKey() + "=" + e.getValue())
489 .collect(joining("|"))
490 );
491 }
492
493 static Stream<String> diffResults(
494 Case c,
495 Stream<Map.Entry<int[], Map<String, String>>> expectedResults
496 ) {
497 return expectedResults
498 .flatMap(exp -> {
499 int[] comb = exp.getKey();
500 Map<String, String> expected = exp.getValue();
501
502 String src = expandTemplate(c, comb);
503 ClassLoader cl;
504 try {
505 cl = compile(src);
506 } catch (CompileException ce) {
507 return Stream.of(src + "\n" +
508 "got compilation error: " + ce);
509 }
510
511 Map<String, String> actual = generateResult(c, cl);
512 if (actual.equals(expected)) {
513 return Stream.empty();
514 } else {
515 Map<String, String> diff = new HashMap<>(expected);
516 diff.entrySet().removeAll(actual.entrySet());
517 return Stream.of(
518 diff.entrySet()
519 .stream()
520 .map(e -> "expected: " + e.getKey() + ": " +
521 e.getValue() + "\n" +
522 " actual: " + e.getKey() + ": " +
523 actual.get(e.getKey()) + "\n")
524 .collect(joining("\n", src + "\n\n", "\n"))
525 );
526 }
527 });
528 }
529 }