1 /* 2 * Copyright (c) 2011, 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 7025809 8028543 6415644 8028544 8029942 8187951 8193291 8196551 27 * @summary Test latest, latestSupported, underscore as keyword, etc. 28 * @author Joseph D. Darcy 29 * @modules java.compiler 30 * jdk.compiler 31 */ 32 33 import java.util.*; 34 import javax.lang.model.SourceVersion; 35 import static javax.lang.model.SourceVersion.*; 36 37 /** 38 * Verify latest[Supported] behavior. 39 */ 40 public class TestSourceVersion { 41 public static void main(String... args) { 42 testLatestSupported(); 43 testVersionVaryingKeywords(); 44 testRestrictedKeywords(); 45 testVar(); 46 } 47 48 private static void testLatestSupported() { 49 SourceVersion[] values = SourceVersion.values(); 50 SourceVersion last = values[values.length - 1]; 51 SourceVersion latest = SourceVersion.latest(); 52 SourceVersion latestSupported = SourceVersion.latestSupported(); 53 54 if (latest == last && 55 latestSupported == SourceVersion.valueOf("RELEASE_" + Runtime.version().feature()) && 56 (latest == latestSupported || (latest.ordinal() - latestSupported.ordinal() == 1)) ) 57 return; 58 else { 59 throw new RuntimeException("Unexpected release value(s) found:\n" + 60 "latest:\t" + latest + "\n" + 61 "latestSupported:\t" + latestSupported); 62 } 63 } 64 65 private static void testVersionVaryingKeywords() { 66 Map<String, SourceVersion> keyWordStart = 67 Map.of("strictfp", RELEASE_2, 68 "assert", RELEASE_4, 69 "enum", RELEASE_5, 70 "_", RELEASE_9); 71 72 for (Map.Entry<String, SourceVersion> entry : keyWordStart.entrySet()) { 73 String key = entry.getKey(); 74 SourceVersion value = entry.getValue(); 75 76 check(true, isKeyword(key), "keyword", latest()); 77 check(false, isName(key), "name", latest()); 78 79 for(SourceVersion version : SourceVersion.values()) { 80 boolean isKeyword = version.compareTo(value) >= 0; 81 82 check(isKeyword, isKeyword(key, version), "keyword", version); 83 check(!isKeyword, isName(key, version), "name", version); 84 } 85 } 86 } 87 88 private static void testRestrictedKeywords() { 89 // Restricted keywords are not full keywords 90 91 /* 92 * JLS 3.9 93 * " A further ten character sequences are restricted 94 * keywords: open, module, requires, transitive, exports, 95 * opens, to, uses, provides, and with" 96 */ 97 Set<String> restrictedKeywords = 98 Set.of("open", "module", "requires", "transitive", "exports", 99 "opens", "to", "uses", "provides", "with"); 100 101 for(String key : restrictedKeywords) { 102 for(SourceVersion version : SourceVersion.values()) { 103 check(false, isKeyword(key, version), "keyword", version); 104 check(true, isName(key, version), "name", version); 105 } 106 } 107 } 108 109 private static void testVar() { 110 111 for(SourceVersion version : SourceVersion.values()) { 112 check(false, isKeyword("var", version), "keyword", version); 113 check(false, isKeyword("foo.var", version), "keyword", version); 114 check(false, isKeyword("var.foo", version), "keyword", version); 115 116 check(true, isName("var", version), "name", version); 117 check(true, isName("foo.var", version), "name", version); 118 check(true, isName("var.foo", version), "name", version); 119 } 120 } 121 122 private static void check(boolean result, boolean expected, 123 String message, SourceVersion version) { 124 if (result != expected) { 125 throw new RuntimeException("Unexpected " + message + "-ness of _ on " + version); 126 } 127 } 128 } | 1 /* 2 * Copyright (c) 2011, 2019, 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 7025809 8028543 6415644 8028544 8029942 8187951 8193291 8196551 8233096 27 * @summary Test latest, latestSupported, underscore as keyword, etc. 28 * @author Joseph D. Darcy 29 * @modules java.compiler 30 * jdk.compiler 31 */ 32 33 import java.util.*; 34 import java.util.function.Predicate; 35 import javax.lang.model.SourceVersion; 36 import static javax.lang.model.SourceVersion.*; 37 38 /** 39 * Verify latest[Supported] behavior and other methods. 40 */ 41 public class TestSourceVersion { 42 public static void main(String... args) { 43 testLatestSupported(); 44 testVersionVaryingKeywords(); 45 testRestrictedKeywords(); 46 testVar(); 47 testYield(); 48 } 49 50 private static void testLatestSupported() { 51 SourceVersion[] values = SourceVersion.values(); 52 SourceVersion last = values[values.length - 1]; 53 SourceVersion latest = SourceVersion.latest(); 54 SourceVersion latestSupported = SourceVersion.latestSupported(); 55 56 if (latest == last && 57 latestSupported == SourceVersion.valueOf("RELEASE_" + Runtime.version().feature()) && 58 (latest == latestSupported || (latest.ordinal() - latestSupported.ordinal() == 1)) ) 59 return; 60 else { 61 throw new RuntimeException("Unexpected release value(s) found:\n" + 62 "latest:\t" + latest + "\n" + 63 "latestSupported:\t" + latestSupported); 64 } 65 } 66 67 private static void testVersionVaryingKeywords() { 68 Map<String, SourceVersion> keyWordStart = 69 Map.of("strictfp", RELEASE_2, 70 "assert", RELEASE_4, 71 "enum", RELEASE_5, 72 "_", RELEASE_9); 73 74 for (Map.Entry<String, SourceVersion> entry : keyWordStart.entrySet()) { 75 String key = entry.getKey(); 76 SourceVersion value = entry.getValue(); 77 78 check(true, key, (String s) -> isKeyword(s), "keyword", latest()); 79 check(false, key, (String s) -> isName(s), "name", latest()); 80 81 for(SourceVersion version : SourceVersion.values()) { 82 boolean isKeyword = version.compareTo(value) >= 0; 83 84 check(isKeyword, key, (String s) -> isKeyword(s, version), "keyword", version); 85 check(!isKeyword, key, (String s) -> isName(s, version), "name", version); 86 } 87 } 88 } 89 90 private static void testRestrictedKeywords() { 91 // Restricted keywords are not full keywords 92 93 /* 94 * JLS 3.9 95 * " A further ten character sequences are restricted 96 * keywords: open, module, requires, transitive, exports, 97 * opens, to, uses, provides, and with" 98 */ 99 Set<String> restrictedKeywords = 100 Set.of("open", "module", "requires", "transitive", "exports", 101 "opens", "to", "uses", "provides", "with"); 102 103 for(String key : restrictedKeywords) { 104 for(SourceVersion version : SourceVersion.values()) { 105 check(false, key, (String s) -> isKeyword(s, version), "keyword", version); 106 check(true, key, (String s) -> isName(s, version), "name", version); 107 } 108 } 109 } 110 111 private static void testVar() { 112 for(SourceVersion version : SourceVersion.values()) { 113 Predicate<String> isKeywordVersion = (String s) -> isKeyword(s, version); 114 Predicate<String> isNameVersion = (String s) -> isName(s, version); 115 116 check(false, "var", isKeywordVersion, "keyword", version); 117 check(false, "foo.var",isKeywordVersion, "keyword", version); 118 check(false, "var.foo",isKeywordVersion, "keyword", version); 119 120 check(true, "var", isNameVersion, "name", version); 121 check(true, "foo.var", isNameVersion, "name", version); 122 check(true, "var.foo", isNameVersion, "name", version); 123 } 124 } 125 126 private static void testYield() { 127 for(SourceVersion version : SourceVersion.values()) { 128 Predicate<String> isKeywordVersion = (String s) -> isKeyword(s, version); 129 Predicate<String> isNameVersion = (String s) -> isName(s, version); 130 131 check(false, "yield", isKeywordVersion, "keyword", version); 132 check(false, "foo.yield", isKeywordVersion, "keyword", version); 133 check(false, "yield.foo", isKeywordVersion, "keyword", version); 134 135 check(true, "yield", isNameVersion, "name", version); 136 check(true, "foo.yield", isNameVersion, "name", version); 137 check(true, "yield.foo", isNameVersion, "name", version); 138 } 139 } 140 141 private static void check(boolean expected, 142 String input, 143 Predicate<String> predicate, 144 String message, 145 SourceVersion version) { 146 boolean result = predicate.test(input); 147 if (result != expected) { 148 throw new RuntimeException("Unexpected " + message + "-ness of " + input + 149 " on " + version); 150 } 151 } 152 } |