Mercurial > jdk8-mips64-public > langtools / file revision
test/tools/javac/defaultMethods/syntax/TestDefaultMethodsSyntax.java@b12ffdfa1341
test/tools/javac/defaultMethods/syntax/TestDefaultMethodsSyntax.java
Mon, 21 Jan 2013 20:15:16 +0000
- author
- mcimadamore
- date
- Mon, 21 Jan 2013 20:15:16 +0000
- changeset 1512
- b12ffdfa1341
- parent 1415
- 01c9d4161882
- child 1513
- cf84b07a82db
- permissions
- -rw-r--r--
8005851: Remove support for synchronized interface methods
Summary: Synchronized default methods are no longer supported
Reviewed-by: jjg
1 /*
2 * Copyright (c) 2012, 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
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("-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 boolean isAllowed(EnclosingKind ek, ModifierKind otherMod) {
81 if (this == otherMod) return false;
82 switch (this) {
83 case NONE:
84 return true;
85 case ABSTRACT:
86 return otherMod != PRIVATE;
87 case NATIVE:
88 return otherMod != ABSTRACT &&
89 otherMod != STRICTFP;
90 case FINAL:
91 case STATIC:
92 case SYNCHRONIZED:
93 case STRICTFP:
94 return otherMod != ABSTRACT;
95 case PUBLIC:
96 return true;
97 case PROTECTED:
98 return ek == EnclosingKind.ABSTRACT_CLASS;
99 case DEFAULT:
100 return otherMod != ABSTRACT;
101 default:
102 return true;
103 }
104 }
106 static boolean intersect(ModifierKind mk, ModifierKind... mks) {
107 for (ModifierKind mk2 : mks) {
108 if (mk == mk2) return true;
109 }
110 return false;
111 }
113 static boolean compatible(MethodKind mk, ModifierKind mod1, ModifierKind mod2, EnclosingKind ek) {
114 if (intersect(ABSTRACT, mod1, mod2) || intersect(NATIVE, mod1, mod2)) {
115 return mk == MethodKind.NO_BODY;
116 } else if (intersect(DEFAULT, mod1, mod2)) {
117 return mk == MethodKind.BODY;
118 } else {
119 return ek == EnclosingKind.INTERFACE ?
120 mk == MethodKind.NO_BODY : mk == MethodKind.BODY;
121 }
122 }
124 boolean compatible(EnclosingKind ek) {
125 switch (this) {
126 case STATIC:
127 case PRIVATE:
128 case PROTECTED:
129 return ek != EnclosingKind.INTERFACE;
130 default:
131 return true;
132 }
133 }
135 static boolean compatible(ModifierKind m1, ModifierKind m2, EnclosingKind ek) {
136 Result res1 = allowedModifierPairs[m1.ordinal()][m2.ordinal()];
137 Result res2 = allowedModifierPairs[m2.ordinal()][m1.ordinal()];
138 if (res1 != res2) {
139 throw new AssertionError(String.format("Ill-formed table: [%s,%s] != [%s,%s]", m1, m2, m2, m1));
140 } else {
141 return res1.compatible(ek, m1, m2);
142 }
143 }
145 interface Result {
146 boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2);
147 }
149 static final Result T = new Result() {
150 @Override
151 public boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2) {
152 return true;
153 }
154 };
156 static final Result F = new Result() {
157 @Override
158 public boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2) {
159 return false;
160 }
161 };
163 static final Result C = new Result() {
164 @Override
165 public boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2) {
166 return ek != EnclosingKind.INTERFACE;
167 }
168 };
170 static final Result I = new Result() {
171 @Override
172 public boolean compatible(EnclosingKind ek, ModifierKind m1, ModifierKind m2) {
173 return ek == EnclosingKind.INTERFACE;
174 }
175 };
177 static Result[][] allowedModifierPairs = {
178 /* NONE PUBLIC PROTECTED PRIVATE ABSTRACT STATIC NATIVE SYNCHRONIZED FINAL STRICTFP DEFAULT */
179 /* NONE */ { T , T , C , C , T , C , C , C , C , C , I },
180 /* PUBLIC */ { T , F , F , F , T , C , C , C , C , C , I },
181 /* PROTECTED */ { C , F , F , F , C , C , C , C , C , C , F },
182 /* PRIVATE */ { C , F , F , F , F , C , C , C , C , C , F },
183 /* ABSTRACT */ { T , T , C , F , F , F , F , F , F , F , F },
184 /* STATIC */ { C , C , C , C , F , F , C , C , C , C , F },
185 /* NATIVE */ { C , C , C , C , F , C , F , C , C , F , F },
186 /* SYNCHRONIZED */ { C , C , C , C , F , C , C , F , C , C , F },
187 /* FINAL */ { C , C , C , C , F , C , C , C , F , C , F },
188 /* STRICTFP */ { C , C , C , C , F , C , F , C , C , F , I },
189 /* DEFAULT */ { I , I , F , F , F , F , F , F , F , I , F }};
190 }
192 enum MethodKind {
193 NO_BODY("void m();"),
194 BODY("void m() { }");
196 String methStr;
198 private MethodKind(String methStr) {
199 this.methStr = methStr;
200 }
201 }
203 enum EnclosingKind {
204 ABSTRACT_CLASS("abstract class Test "),
205 INTERFACE("interface Test ");
207 String enclStr;
209 EnclosingKind(String enclStr) {
210 this.enclStr = enclStr;
211 }
212 }
214 public static void main(String... args) throws Exception {
216 //create default shared JavaCompiler - reused across multiple compilations
217 JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
218 StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
220 for (VersionKind vk : VersionKind.values()) {
221 for (EnclosingKind ek : EnclosingKind.values()) {
222 for (MethodKind mk : MethodKind.values()) {
223 for (ModifierKind modk1 : ModifierKind.values()) {
224 for (ModifierKind modk2 : ModifierKind.values()) {
225 new TestDefaultMethodsSyntax(vk, ek, mk, modk1, modk2).run(comp, fm);
226 }
227 }
228 }
229 }
230 }
231 System.out.println("Total check executed: " + checkCount);
232 }
234 VersionKind vk;
235 EnclosingKind ek;
236 MethodKind mk;
237 ModifierKind modk1, modk2;
238 JavaSource source;
239 DiagnosticChecker diagChecker;
241 TestDefaultMethodsSyntax(VersionKind vk, EnclosingKind ek, MethodKind mk, ModifierKind modk1, ModifierKind modk2) {
242 this.vk = vk;
243 this.ek = ek;
244 this.mk = mk;
245 this.modk1 = modk1;
246 this.modk2 = modk2;
247 this.source = new JavaSource();
248 this.diagChecker = new DiagnosticChecker();
249 }
251 class JavaSource extends SimpleJavaFileObject {
253 String template = "#EK {\n" +
254 " #MOD1 #MOD2 #METH\n" +
255 "}\n";
257 String source;
259 public JavaSource() {
260 super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
261 source = template.replaceAll("#EK", ek.enclStr)
262 .replaceAll("#MOD1", modk1.modStr)
263 .replaceAll("#MOD2", modk2.modStr)
264 .replaceAll("#METH", mk.methStr);
265 }
267 @Override
268 public CharSequence getCharContent(boolean ignoreEncodingErrors) {
269 return source;
270 }
271 }
273 void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
274 JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
275 vk.getOptions(), null, Arrays.asList(source));
276 try {
277 ct.analyze();
278 } catch (Throwable ex) {
279 throw new AssertionError("Error thrown when analyzing the following source:\n" + source.getCharContent(true));
280 }
281 check();
282 }
284 void check() {
285 boolean errorExpected = !ModifierKind.compatible(modk1, modk2, ek);
287 errorExpected |= !ModifierKind.compatible(mk, modk1, modk2, ek);
289 errorExpected |= !modk1.compatible(ek) || !modk2.compatible(ek);
291 errorExpected |= ModifierKind.intersect(ModifierKind.DEFAULT, modk1, modk2) &&
292 vk == VersionKind.PRE_LAMBDA;
294 checkCount++;
295 if (diagChecker.errorFound != errorExpected) {
296 throw new AssertionError("Problem when compiling source:\n" + source.getCharContent(true) +
297 "\nfound error: " + diagChecker.errorFound);
298 }
299 }
301 static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
303 boolean errorFound;
305 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
306 if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
307 errorFound = true;
308 }
309 }
310 }
311 }
