| /* |
| * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @bug 8294942 |
| * @summary Check compilation outcomes for various combinations of case label element. |
| * @library /tools/lib /tools/javac/lib |
| * @modules |
| * jdk.compiler/com.sun.tools.javac.api |
| * jdk.compiler/com.sun.tools.javac.file |
| * jdk.compiler/com.sun.tools.javac.main |
| * jdk.compiler/com.sun.tools.javac.util |
| * @build toolbox.ToolBox toolbox.JavacTask |
| * @compile NewCaseStructureTest.java |
| * @run main NewCaseStructureTest |
| */ |
| |
| import java.io.IOException; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.*; |
| import toolbox.JavacTask; |
| import toolbox.Task; |
| import toolbox.TestRunner; |
| import toolbox.ToolBox; |
| |
| public class NewCaseStructureTest extends TestRunner { |
| |
| private static final String JAVA_VERSION = System.getProperty("java.specification.version"); |
| |
| ToolBox tb; |
| |
| public static void main(String... args) throws Exception { |
| new NewCaseStructureTest().runTests(); |
| } |
| |
| NewCaseStructureTest() { |
| super(System.err); |
| tb = new ToolBox(); |
| } |
| |
| public void runTests() throws Exception { |
| runTests(m -> new Object[] { Paths.get(m.getName()) }); |
| } |
| |
| @Test |
| public void testCorrectMultiLabelCaseStructure(Path base) throws Exception { |
| for (String pattern : new String[] {"String s", |
| "R(int i)", |
| "null, default", |
| "null", |
| "1", |
| "1, 2", |
| "1, 2, 3"}) { |
| for (String sep : new String[] {":", "->"}) { |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(${switchType} obj) { |
| return switch (obj) { |
| case ${pattern} ${sep} { yield 0; } |
| ${default} |
| }; |
| } |
| } |
| record R(int i) {} |
| """.replace("${switchType}", pattern.contains("1") ? "Integer" : "Object") |
| .replace("${pattern}", pattern) |
| .replace("${sep}", sep) |
| .replace("${default}", pattern.contains("default") ? "" : "default " + sep + " { yield 1; }"), |
| false); |
| } |
| } |
| } |
| |
| @Test |
| public void testMalformedCaseStructure(Path base) throws Exception { |
| for (String pattern : new String[] {"String s, Integer i", |
| "String s, R(int i)", |
| "E1(), E2()", |
| "String s, null", |
| "String s, default", |
| "String s, null, default", |
| "null, String s", |
| "null, default, String s", |
| "default, String s", |
| "1, Integer i", |
| "1, 2, 3, Integer i", |
| "Integer i, 1, 2, 3", |
| "1, null", |
| "1, 2, 3, null", |
| "null, 1, 2, 3", |
| "default, null", |
| "default"}) { |
| for (String sep : new String[] {":", "->"}) { |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(${switchType} obj) { |
| return switch (obj) { |
| case ${pattern} ${sep} { yield 0; } |
| ${default} |
| }; |
| } |
| } |
| record R(int i) {} |
| record E1() {} |
| record E2() {} |
| """.replace("${switchType}", pattern.contains("1") ? "Integer" : "Object") |
| .replace("${pattern}", pattern) |
| .replace("${sep}", sep) |
| .replace("${default}", pattern.contains("default") ? "" : "default " + sep + " { yield 1; }"), |
| true); |
| } |
| } |
| } |
| |
| @Test |
| public void testSwitchLabeledStatementGroups(Path base) throws Exception { |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Object o) { |
| return switch (o) { |
| case null: |
| case Object obj: System.err.println(); yield 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:6:18: compiler.err.flows.through.to.pattern", |
| "1 error"); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Object o) { |
| return switch (o) { |
| case null: System.err.println(); |
| case Object obj: System.err.println(); yield 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:6:18: compiler.err.flows.through.to.pattern", |
| "1 error"); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Object o) { |
| return switch (o) { |
| case Object obj: |
| case null: System.err.println(); yield 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:5:18: compiler.err.flows.through.from.pattern", |
| "1 error"); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Object o) { |
| return switch (o) { |
| case Object obj: System.err.println(); |
| case null: System.err.println(); |
| yield 0; |
| }; |
| } |
| } |
| """); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Object o) { |
| return switch (o) { |
| case String s: System.err.println(); |
| case E1(): System.err.println(); yield 0; |
| default: yield 0; |
| }; |
| } |
| } |
| record E1() {} |
| """); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Object o) { |
| return switch (o) { |
| case String s: System.err.println(); |
| default: System.err.println(); yield 0; |
| }; |
| } |
| } |
| """); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private void test(Object o) { |
| switch (o) { |
| case String s: |
| case Integer i: |
| case Object obj: |
| } |
| } |
| } |
| """); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private void test(Object o) { |
| switch (o) { |
| case Object obj: System.err.println(); |
| case null: System.err.println(obj); |
| } |
| } |
| } |
| """, |
| "Test.java:6:43: compiler.err.cant.resolve.location: kindname.variable, obj, , , (compiler.misc.location: kindname.class, test.Test, null)", |
| "1 error"); |
| |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Integer o) { |
| return switch (o) { |
| case default -> 0; |
| case 0 -> 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:5:18: compiler.err.default.label.not.allowed", |
| "1 error"); |
| } |
| |
| @Test |
| public void testDominance(Path base) throws Exception { |
| //A case label with a case pattern p (guarded or unguarded) dominates another case label with a case constant c if p dominates c, which is defined as follows: |
| // (unguarded case with) A type pattern that declares a pattern variable of type T dominates a constant c of a primitive type P if the wrapper class of P ([5.1.7]) is a subtype of the erasure of T. |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Integer o) { |
| return switch (o) { |
| case Integer i when i > 0 -> 0; |
| case 0 -> 0; |
| case Integer i -> 0; |
| }; |
| } |
| } |
| """); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Integer o) { |
| return switch (o) { |
| case Integer i -> 0; |
| case 0 -> 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:6:18: compiler.err.pattern.dominated", |
| "1 error"); |
| // (unguarded case with) A type pattern that declares a pattern variable of type T dominates an enum constant c of type E if E is a subtype of the erasure of the type of T. |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(E o) { |
| return switch (o) { |
| case E e when e == E.A -> 0; |
| case B -> 0; |
| case E e -> 0; |
| }; |
| } |
| } |
| enum E {A, B;} |
| """); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(E o) { |
| return switch (o) { |
| case E e -> 0; |
| case B -> 0; |
| }; |
| } |
| } |
| enum E {A, B;} |
| """, |
| "Test.java:6:18: compiler.err.pattern.dominated", |
| "1 error"); |
| //dtto for String: |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(String o) { |
| return switch (o) { |
| case String s when s.isEmpty() -> 0; |
| case "a" -> 0; |
| case String s -> 0; |
| }; |
| } |
| } |
| """); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(String o) { |
| return switch (o) { |
| case String s -> 0; |
| case "a" -> 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:6:18: compiler.err.pattern.dominated", |
| "1 error"); |
| // A default label dominates a case label with a case pattern, and it also dominates a case label with a null case constant. |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Integer o) { |
| return switch (o) { |
| default -> 0; |
| case Integer i when i > 0 -> 0; |
| case Integer i when i > 0 -> 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:6:18: compiler.err.pattern.dominated", |
| "1 error"); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Integer o) { |
| return switch (o) { |
| case Integer i when i > 0 -> 0; |
| default -> 0; |
| case null -> 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:7:18: compiler.err.pattern.dominated", |
| "1 error"); |
| // case label with a default dominates all other switch labels. |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Integer o) { |
| return switch (o) { |
| case null, default -> 0; |
| case Integer i when i > 0 -> 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:6:18: compiler.err.pattern.dominated", |
| "1 error"); |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Integer o) { |
| return switch (o) { |
| case null, default -> 0; |
| case 0 -> 0; |
| case 1 -> 0; |
| }; |
| } |
| } |
| """, |
| "Test.java:6:18: compiler.err.pattern.dominated", |
| "1 error"); |
| |
| doTest(base, |
| """ |
| package test; |
| public class Test { |
| private int test(Integer o) { |
| return switch (o) { |
| default -> 0; |
| case 0 -> 0; |
| }; |
| } |
| } |
| """); |
| } |
| |
| private void doTest(Path base, String testCode, boolean expectErrors) throws IOException { |
| doTest(base, testCode, expectErrors, (String[]) null); |
| } |
| |
| private void doTest(Path base, String testCode, String... output) throws IOException { |
| doTest(base, testCode, output != null && output.length > 0, output); |
| } |
| |
| private void doTest(Path base, String testCode, boolean expectErrors, String... output) throws IOException { |
| Path current = base.resolve("."); |
| Path src = current.resolve("src"); |
| |
| tb.writeJavaFiles(src, testCode); |
| |
| Path classes = current.resolve("classes"); |
| |
| Files.createDirectories(classes); |
| |
| List<String> actual = new JavacTask(tb) |
| .options("-XDrawDiagnostics", |
| "-Xlint:-preview", |
| "-XDshould-stop.at=FLOW") |
| .outdir(classes) |
| .files(tb.findJavaFiles(src)) |
| .run(expectErrors? Task.Expect.FAIL : Task.Expect.SUCCESS) |
| .writeAll() |
| .getOutputLines(Task.OutputKind.DIRECT); |
| |
| if (output != null) { |
| actual.remove("- compiler.note.preview.filename: Test.java, DEFAULT"); |
| actual.remove("- compiler.note.preview.recompile"); |
| actual.remove(""); |
| |
| List<String> expected = List.of(output); |
| |
| if (!Objects.equals(expected, actual)) { |
| throw new AssertionError("Unexpected output: " + actual); |
| } |
| } |
| } |
| } |
