Mercurial > jdk8-mips64-public > langtools / file revision
test/tools/javac/defaultMethods/syntax/TestDefaultMethodsSyntax.java@998b10c43157
test/tools/javac/defaultMethods/syntax/TestDefaultMethodsSyntax.java
Tue, 24 Dec 2013 09:17:37 -0800
- author
- ksrini
- date
- Tue, 24 Dec 2013 09:17:37 -0800
- changeset 2227
- 998b10c43157
- parent 1513
- cf84b07a82db
- child 2525
- 2eb010b6cb22
- permissions
- -rw-r--r--
8029230: Update copyright year to match last edit in jdk8 langtools repository for 2013
Reviewed-by: ksrini
Contributed-by: steve.sides@oracle.com
1 /*
2 * Copyright (c) 2012, 2013, 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 */
24 /*
25 * @test
26 * @bug 7192245 8005851 8005166
27 * @summary Automatic test for checking set of allowed modifiers on interface methods
28 */
30 import com.sun.source.util.JavacTask;
31 import java.net.URI;
32 import java.util.Arrays;
33 import java.util.List;
34 import javax.tools.Diagnostic;
35 import javax.tools.JavaCompiler;
36 import javax.tools.JavaFileObject;
37 import javax.tools.SimpleJavaFileObject;
38 import javax.tools.StandardJavaFileManager;
39 import javax.tools.ToolProvider;
42 public class TestDefaultMethodsSyntax {
44 static int checkCount = 0;
46 enum VersionKind {
47 PRE_LAMBDA("7"),
48 LAMBDA("8");
50 String versionString;
52 VersionKind(String versionString) {
53 this.versionString = versionString;
54 }
56 List<String> getOptions() {
57 return Arrays.asList("-XDallowStaticInterfaceMethods", "-source", versionString);
58 }
59 }
61 enum ModifierKind {
62 NONE(""),
63 PUBLIC("public"),
64 PROTECTED("protected"),
65 PRIVATE("private"),
66 ABSTRACT("abstract"),
67 STATIC("static"),
68 NATIVE("native"),
69 SYNCHRONIZED("synchronized"),
70 FINAL("final"),
71 STRICTFP("strictfp"),
72 DEFAULT("default");
74 String modStr;
76 private ModifierKind(String modStr) {
77 this.modStr = modStr;
78 }
80 static boolean intersect(ModifierKind mk, ModifierKind... mks) {
81 for (ModifierKind mk2 : mks) {
82 if (mk == mk2) return true;
83 }
84 return false;
85 }
87 static boolean compatible(MethodKind mk, ModifierKind mod1, ModifierKind mod2, EnclosingKind ek) {
88 if (intersect(ABSTRACT, mod1, mod2) || intersect(NATIVE, mod1, mod2)) {
89 return mk == MethodKind.NO_BODY;
90 } else if (intersect(DEFAULT, mod1, mod2) || intersect(STATIC, mod1, mod2)) {
91 return mk == MethodKind.BODY;
92 } else {
93 return ek == EnclosingKind.INTERFACE ?
94 mk == MethodKind.NO_BODY : mk == MethodKind.BODY;
95 }
96 }
98 boolean compatible(EnclosingKind ek) {
99 switch (this) {
100 case PRIVATE:
101 case PROTECTED:
102 return ek != EnclosingKind.INTERFACE;
103 default:
104 return true;
105 }
106 }
108 static boolean compatible(ModifierKind m1, ModifierKind m2, EnclosingKind ek) {
109 Result res1 = allowedModifierPairs[m1.ordinal()][m2.ordinal()];
110 Result res2 = allowedModifierPairs[m2.ordinal()][m1.ordinal()];
111 if (res1 != res2) {
112 throw new AssertionError(String.format("Ill-formed table: [%s,%s] != [%s,%s]", m1, m2, m2, m1));
113 } else {
114 return res1.compatible(ek, m1, m2);
115 }
116 }
118 interface Result {
119 boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2);
120 }
122 static final Result T = new Result() {
123 @Override
124 public boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2) {
125 return true;
126 }
127 };
129 static final Result F = new Result() {
130 @Override
131 public boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2) {
132 return false;
133 }
134 };
136 static final Result C = new Result() {
137 @Override
138 public boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2) {
139 return ek != EnclosingKind.INTERFACE;
140 }
141 };
143 static final Result I = new Result() {
144 @Override
145 public boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2) {
146 return ek == EnclosingKind.INTERFACE;
147 }
148 };
150 static Result[][] allowedModifierPairs = {
151 /* NONE PUBLIC PROTECTED PRIVATE ABSTRACT STATIC NATIVE SYNCHRONIZED FINAL STRICTFP DEFAULT */
152 /* NONE */ { T , T , C , C , T , T , C , C , C , C , I },
153 /* PUBLIC */ { T , F , F , F , T , T , C , C , C , C , I },
154 /* PROTECTED */ { C , F , F , F , C , C , C , C , C , C , F },
155 /* PRIVATE */ { C , F , F , F , F , C , C , C , C , C , F },
156 /* ABSTRACT */ { T , T , C , F , F , F , F , F , F , F , F },
157 /* STATIC */ { T , T , C , C , F , F , C , C , C , T , F },
158 /* NATIVE */ { C , C , C , C , F , C , F , C , C , F , F },
159 /* SYNCHRONIZED */ { C , C , C , C , F , C , C , F , C , C , F },
160 /* FINAL */ { C , C , C , C , F , C , C , C , F , C , F },
161 /* STRICTFP */ { C , C , C , C , F , T , F , C , C , F , I },
162 /* DEFAULT */ { I , I , F , F , F , F , F , F , F , I , F }};
163 }
165 enum MethodKind {
166 NO_BODY("void m();"),
167 BODY("void m() { }");
169 String methStr;
171 private MethodKind(String methStr) {
172 this.methStr = methStr;
173 }
174 }
176 enum EnclosingKind {
177 ABSTRACT_CLASS("abstract class Test "),
178 INTERFACE("interface Test ");
180 String enclStr;
182 EnclosingKind(String enclStr) {
183 this.enclStr = enclStr;
184 }
185 }
187 public static void main(String... args) throws Exception {
189 //create default shared JavaCompiler - reused across multiple compilations
190 JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
191 StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
193 for (VersionKind vk : VersionKind.values()) {
194 for (EnclosingKind ek : EnclosingKind.values()) {
195 for (MethodKind mk : MethodKind.values()) {
196 for (ModifierKind modk1 : ModifierKind.values()) {
197 for (ModifierKind modk2 : ModifierKind.values()) {
198 new TestDefaultMethodsSyntax(vk, ek, mk, modk1, modk2).run(comp, fm);
199 }
200 }
201 }
202 }
203 }
204 System.out.println("Total check executed: " + checkCount);
205 }
207 VersionKind vk;
208 EnclosingKind ek;
209 MethodKind mk;
210 ModifierKind modk1, modk2;
211 JavaSource source;
212 DiagnosticChecker diagChecker;
214 TestDefaultMethodsSyntax(VersionKind vk, EnclosingKind ek, MethodKind mk, ModifierKind modk1, ModifierKind modk2) {
215 this.vk = vk;
216 this.ek = ek;
217 this.mk = mk;
218 this.modk1 = modk1;
219 this.modk2 = modk2;
220 this.source = new JavaSource();
221 this.diagChecker = new DiagnosticChecker();
222 }
224 class JavaSource extends SimpleJavaFileObject {
226 String template = "#EK {\n" +
227 " #MOD1 #MOD2 #METH\n" +
228 "}\n";
230 String source;
232 public JavaSource() {
233 super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
234 source = template.replaceAll("#EK", ek.enclStr)
235 .replaceAll("#MOD1", modk1.modStr)
236 .replaceAll("#MOD2", modk2.modStr)
237 .replaceAll("#METH", mk.methStr);
238 }
240 @Override
241 public CharSequence getCharContent(boolean ignoreEncodingErrors) {
242 return source;
243 }
244 }
246 void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
247 JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
248 vk.getOptions(), null, Arrays.asList(source));
249 try {
250 ct.analyze();
251 } catch (Throwable ex) {
252 throw new AssertionError("Error thrown when analyzing the following source:\n" + source.getCharContent(true));
253 }
254 check();
255 }
257 void check() {
258 boolean errorExpected = !ModifierKind.compatible(modk1, modk2, ek);
260 errorExpected |= !ModifierKind.compatible(mk, modk1, modk2, ek);
262 errorExpected |= !modk1.compatible(ek) || !modk2.compatible(ek);
264 errorExpected |= ModifierKind.intersect(ModifierKind.DEFAULT, modk1, modk2) &&
265 vk == VersionKind.PRE_LAMBDA;
267 errorExpected |= ModifierKind.intersect(ModifierKind.STATIC, modk1, modk2) &&
268 ek == EnclosingKind.INTERFACE && vk == VersionKind.PRE_LAMBDA;
270 checkCount++;
271 if (diagChecker.errorFound != errorExpected) {
272 throw new AssertionError("Problem when compiling source:\n" + source.getCharContent(true) +
273 "\nfound error: " + diagChecker.errorFound);
274 }
275 }
277 static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
279 boolean errorFound;
281 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
282 if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
283 errorFound = true;
284 }
285 }
286 }
287 }
