1 /*
2 * Copyright (c) 2015, 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 package compiler.compilercontrol.matcher;
25
26 import jdk.test.lib.Pair;
27 import compiler.compilercontrol.share.method.MethodDescriptor;
28 import compiler.compilercontrol.share.method.MethodGenerator;
29 import pool.PoolHelper;
30 import sun.hotspot.WhiteBox;
31
32 import java.lang.reflect.Executable;
33 import java.util.ArrayList;
34 import java.util.List;
35 import java.util.concurrent.Callable;
36 import java.util.regex.Matcher;
37 import java.util.regex.Pattern;
38
39 /*
40 * @test
41 * @bug 8135068
42 * @summary Tests CompilerCommand's method matcher
43 * @library /testlibrary /test/lib /compiler/whitebox ../share /
44 * @build compiler.compilercontrol.matcher.MethodMatcherTest
45 * @run driver ClassFileInstaller sun.hotspot.WhiteBox
46 * sun.hotspot.WhiteBox$WhiteBoxPermission
47 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
48 * -XX:+WhiteBoxAPI compiler.compilercontrol.matcher.MethodMatcherTest
49 */
50 public class MethodMatcherTest {
51 private static final WhiteBox WB = WhiteBox.getWhiteBox();
52 private static final PoolHelper POOL = new PoolHelper();
53 private static final List<Pair<Executable, Callable<?>>> METHODS =
54 POOL.getAllMethods();
55 private static final int AMOUNT = Integer.parseInt(System
56 .getProperty("test.amount", "25"));
57
58 public static void main(String[] args) {
59 MethodGenerator gen = new MethodGenerator();
60 List<Pair<Executable, Callable<?>>> testMethods =
61 POOL.getAllMethods(PoolHelper.METHOD_FILTER);
62 for (Pair<Executable, Callable<?>> pair : testMethods) {
63 for (int i = 0; i < AMOUNT; i++) {
64 MethodDescriptor md = gen.generateRandomDescriptor(pair.first);
65 check(md);
66 }
67 }
68 }
69
70 /**
71 * Check method matcher with given test case
72 *
73 * @param methodDescriptor method descriptor to check matcher's pattern
74 */
75 private static void check(MethodDescriptor methodDescriptor) {
76 System.out.println("Test case: " + methodDescriptor.getString());
77 System.out.println("Regex: " + methodDescriptor.getRegexp());
78 Pattern pattern = Pattern.compile(methodDescriptor.getRegexp());
79 boolean isValidDesc = methodDescriptor.isValid();
80 List<MethodDescriptor> failList = new ArrayList<>();
81 // walk through all methods in pool to check match with test pattern
82 for (Pair<Executable, Callable<?>> pair : METHODS) {
83 MethodDescriptor m = MethodGenerator.commandDescriptor(pair.first);
84 Matcher matcher = pattern.matcher(m.getCanonicalString());
85 // get expected result
86 MatcherResult expected;
87 if (isValidDesc) {
88 expected = matcher.matches() ?
89 MatcherResult.MATCH : MatcherResult.NO_MATCH;
90 } else {
91 expected = MatcherResult.PARSING_FAILURE;
92 }
93 // get MethodMatcher's result
94 MatcherResult matchResult = MatcherResult.fromCode(WB.matchesMethod(
95 pair.first, methodDescriptor.getString()));
96 // compare
97 if (matchResult != expected) {
98 System.out.printf("- Method: %s%n-- FAILED: result: %s, " +
99 "but expected: %s%n", m.getCanonicalString(),
100 matchResult, expected);
101 failList.add(m);
102 }
103 }
104 int size = failList.size();
105 if (size != 0) {
106 System.err.println("FAILED test case: " + methodDescriptor
107 .getString());
108 if (size == METHODS.size()) {
109 System.err.println("-- All methods failed to match");
110 } else {
111 for (MethodDescriptor md : failList) {
112 System.err.println("-- FAILED match: " + md.getString());
113 }
114 }
115 throw new AssertionError("FAIL: " + methodDescriptor.getString());
116 }
117 System.out.println("--PASSED");
118 }
119
120 /**
121 * Represents MethodMatcher's matching result
122 */
123 public enum MatcherResult {
124 PARSING_FAILURE(-1, "Parsing failed"),
125 NO_MATCH(0, "No match"),
126 MATCH(1, "Match");
127
128 public final int code;
129 private final String message;
130
131 private MatcherResult(int code, String message) {
132 this.code = code;
133 this.message = message;
134 }
135
136 public static MatcherResult fromCode(int code) {
137 switch (code) {
138 case -1: return PARSING_FAILURE;
139 case 0: return NO_MATCH;
140 case 1: return MATCH;
141 default:
142 throw new IllegalArgumentException("MATCHER FAILURE:"
143 + "Wrong code: " + code);
144 }
145 }
146
147 @Override
148 public String toString() {
149 return message;
150 }
151 }
152 }