Google Git
Sign in
eclipse / jdt / eclipse.jdt.core / refs/tags/Y20210914-1110 / . / org.eclipse.jdt.core.tests.compiler / src / org / eclipse / jdt / core / tests / compiler / regression / SwitchPatternTest.java
blob: b75ce3932ceb10cba3599789649209698d658b88 [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2021 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;
import java.util.Map;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import junit.framework.Test;
public class SwitchPatternTest extends AbstractRegressionTest9 {
static {
// TESTS_NUMBERS = new int [] { 40 };
// TESTS_RANGE = new int[] { 1, -1 };
// TESTS_NAMES = new String[] { "testBug575737"};
}
private static String previewLevel = "17";
public static Class<?> testClass() {
return SwitchPatternTest.class;
}
public static Test suite() {
return buildMinimalComplianceTestSuite(testClass(), F_17);
}
public SwitchPatternTest(String testName){
super(testName);
}
// Enables the tests to run individually
protected Map<String, String> getCompilerOptions() {
Map<String, String> defaultOptions = super.getCompilerOptions();
defaultOptions.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_17); // FIXME
defaultOptions.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_17);
defaultOptions.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_17);
defaultOptions.put(CompilerOptions.OPTION_EnablePreviews, CompilerOptions.ENABLED);
defaultOptions.put(CompilerOptions.OPTION_ReportPreviewFeatures, CompilerOptions.IGNORE);
defaultOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED);
return defaultOptions;
}
@Override
protected void runConformTest(String[] testFiles, String expectedOutput) {
runConformTest(testFiles, expectedOutput, "", getCompilerOptions());
}
@Override
protected void runConformTest(String[] testFiles, String expectedOutput, Map<String, String> customOptions) {
runConformTest(testFiles, expectedOutput, "", customOptions);
}
protected void runConformTest(String[] testFiles, String expectedOutput, String errorOutput) {
runConformTest(testFiles, expectedOutput, errorOutput, getCompilerOptions());
}
protected void runConformTest(String[] testFiles, String expectedOutput, String expectedErrorOutput, Map<String, String> customOptions) {
Runner runner = new Runner();
runner.testFiles = testFiles;
runner.expectedOutputString = expectedOutput;
runner.expectedErrorString = expectedErrorOutput;
runner.vmArguments = new String[] {"--enable-preview"};
runner.customOptions = customOptions;
runner.javacTestOptions = JavacTestOptions.forReleaseWithPreview(SwitchPatternTest.previewLevel);
runner.runConformTest();
}
@Override
protected void runNegativeTest(String[] testFiles, String expectedCompilerLog) {
runNegativeTest(testFiles, expectedCompilerLog, "");
}
protected void runNegativeTest(String[] testFiles, String expectedCompilerLog, String javacLog) {
Runner runner = new Runner();
runner.testFiles = testFiles;
runner.expectedCompilerLog = expectedCompilerLog;
runner.expectedJavacOutputString = expectedCompilerLog;
runner.vmArguments = new String[] {"--enable-preview"};
runner.customOptions = getCompilerOptions();
runner.javacTestOptions = JavacTestOptions.forReleaseWithPreview(SwitchPatternTest.previewLevel);
runner.runNegativeTest();
runNegativeTest(testFiles, expectedCompilerLog, JavacTestOptions.forReleaseWithPreview(SwitchPatternTest.previewLevel));
}
protected void runWarningTest(String[] testFiles, String expectedCompilerLog) {
runWarningTest(testFiles, expectedCompilerLog, null);
}
protected void runWarningTest(String[] testFiles, String expectedCompilerLog, Map<String, String> customOptions) {
runWarningTest(testFiles, expectedCompilerLog, customOptions, null);
}
protected void runWarningTest(String[] testFiles, String expectedCompilerLog,
Map<String, String> customOptions, String javacAdditionalTestOptions) {
Runner runner = new Runner();
runner.testFiles = testFiles;
runner.expectedCompilerLog = expectedCompilerLog;
runner.customOptions = customOptions;
runner.vmArguments = new String[] {"--enable-preview"};
runner.javacTestOptions = javacAdditionalTestOptions == null ? JavacTestOptions.forReleaseWithPreview(SwitchPatternTest.previewLevel) :
JavacTestOptions.forReleaseWithPreview(SwitchPatternTest.previewLevel, javacAdditionalTestOptions);
runner.runWarningTest();
}
public void testBug573516_001() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer i -> System.out.println(\"String:\");\n"+
" case String s -> System.out.println(\"String: Hello World!\");\n"+
" default -> System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" }\n"+
"}",
},
"String: Hello World!");
}
public void testBug573516_002() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case String s -> System.out.println(\"String:\");\n"+
" default -> System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_003() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case String s : System.out.println(\"String:\"); break;\n"+
" case Integer i : System.out.println(\"Integer:\");break;\n"+
" default : System.out.println(\"Object\");break;\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 11)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_004() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer t && t > 0 -> System.out.println(\"Integer && t > 0\");\n"+
" default -> System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_005() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer t, String s, X x : System.out.println(\"Integer, String or X\");\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}\n"+
"class Y {}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer t, String s, X x : System.out.println(\"Integer, String or X\");\n" +
" ^^^^^^^^\n" +
"A switch label may not have more than one pattern case label element\n" +
"----------\n" +
"3. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_006() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer t, String s && s.length > 0, X x && x.hashCode() > 10 : System.out.println(\"Integer, String or X\");\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}\n"+
"class Y {}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer t, String s && s.length > 0, X x && x.hashCode() > 10 : System.out.println(\"Integer, String or X\");\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^\n" +
"A switch label may not have more than one pattern case label element\n" +
"----------\n" +
"2. ERROR in X.java (at line 4)\n" +
" case Integer t, String s && s.length > 0, X x && x.hashCode() > 10 : System.out.println(\"Integer, String or X\");\n" +
" ^^^^^^\n" +
"length cannot be resolved or is not a field\n" +
"----------\n" +
"3. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_007() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer t, String : System.out.println(\"Error should be flagged for String\");\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}\n"+
"class Y {}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer t, String : System.out.println(\"Error should be flagged for String\");\n" +
" ^^^^^^\n" +
"String cannot be resolved to a variable\n" +
"----------\n" +
"2. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_008() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o.hashCode()) {\n"+
" case Integer t, String : System.out.println(\"Error should be flagged for Integer and String\");\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}\n"+
"class Y {}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer t, String : System.out.println(\"Error should be flagged for Integer and String\");\n" +
" ^^^^^^^^^\n" +
"Type mismatch: cannot convert from int to Integer\n" +
"----------\n" +
"2. ERROR in X.java (at line 4)\n" +
" case Integer t, String : System.out.println(\"Error should be flagged for Integer and String\");\n" +
" ^^^^^^\n" +
"String cannot be resolved to a variable\n" +
"----------\n" +
"3. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_009() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o.hashCode()) {\n"+
" case default : System.out.println(\"Default\");\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}\n"+
"class Y {}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" default : System.out.println(\"Object\");\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n" +
"2. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_010() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o.hashCode()) {\n"+
" case String s, default : System.out.println(\"Error should be flagged for String and default\");\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}\n"+
"class Y {}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case String s, default : System.out.println(\"Error should be flagged for String and default\");\n" +
" ^^^^^^^^\n" +
"Type mismatch: cannot convert from int to String\n" +
"----------\n" +
"2. ERROR in X.java (at line 4)\n" +
" case String s, default : System.out.println(\"Error should be flagged for String and default\");\n" +
" ^^^^^^^\n" +
"A switch label may not have both a pattern case label element and a default case label element\n" +
"----------\n" +
"3. ERROR in X.java (at line 5)\n" +
" default : System.out.println(\"Object\");\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n" +
"4. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573516_011() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o.hashCode()) {\n"+
" case var s : System.out.println(\"Error should be ANY_PATTERN\");\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}\n"+
"class Y {}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case var s : System.out.println(\"Error should be ANY_PATTERN\");\n" +
" ^^^\n" +
"'var' is not allowed here\n" +
"----------\n" +
"2. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug574228_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case 1: System.out.println(\"Integer\"); break;\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case 1: System.out.println(\"Integer\"); break;\n" +
" ^\n" +
"Type mismatch: cannot convert from int to Object\n" +
"----------\n" +
"2. ERROR in X.java (at line 10)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573936_01() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer I: \n"+
" System.out.println(\"Integer\"); \n"+
" System.out.println(I); \n"+
" case String s && s.length()>1: \n"+
" System.out.println(\"String s && s.length()>1\"); \n"+
" System.out.println(s); \n"+
" break;// error no fallthrough allowed in pattern\n"+
" case X x:\n"+
" System.out.println(\"X\"); \n"+
" System.out.println(x);\n"+
" break;\n"+
" default : System.out.println(\"Object\"); \n"+
" }\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" foo(\"H\");\n"+
" foo(bar());\n"+
" }\n"+
" public static Object bar() { return new Object();}\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case String s && s.length()>1: \n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n");
}
public void testBug573939_01() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer s : System.out.println(\"Integer\");\n"+
" case String s1: System.out.println(\"String \");\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World\");\n"+
" Zork();\n"+
" }\n"+
"}\n"+
"class Y {}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case String s1: System.out.println(\"String \");\n" +
" ^^^^^^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n" +
"2. ERROR in X.java (at line 11)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug573939_02() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer I: System.out.println(\"Integer\"); break;\n"+
" case String s && s.length()>1: System.out.println(\"String > 1\"); break;\n"+
" case String s1: System.out.println(\"String\"); break;\n"+
" case X x: System.out.println(\"X\"); break;\n"+
" default : System.out.println(\"Object\");\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" foo(\"H\");\n"+
" foo(bar());\n"+
" }\n"+
" public static Object bar() { return new Object();}\n"+
"}",
},
"String > 1\n" +
"String\n" +
"Object");
}
public void testBug573939_03() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer I: \n"+
" System.out.println(\"Integer\"); \n"+
" System.out.println(I); \n"+
" break; \n"+
" case String s && s.length()>1: \n"+
" System.out.println(\"String s && s.length()>1\"); \n"+
" System.out.println(s); \n"+
" break;\n"+
" case String s1: \n"+
" System.out.println(\"String\"); \n"+
" System.out.println(s1);\n"+
" break; \n"+
" case X x:\n"+
" System.out.println(\"X\"); \n"+
" System.out.println(x);\n"+
" break;\n"+
" default : System.out.println(\"Object\"); \n"+
" }\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" foo(\"H\");\n"+
" foo(bar());\n"+
" }\n"+
" public static Object bar() { return new Object();}\n"+
"}",
},
"String s && s.length()>1\n" +
"Hello World!\n" +
"String\n" +
"H\n" +
"Object");
}
public void testBug573939_03b() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer I: \n"+
" System.out.println(\"Integer\"); \n"+
" System.out.println(I); \n"+
" break; \n"+
" case String s && s.length()>1: \n"+
" System.out.println(\"String s && s.length()>1\"); \n"+
" System.out.println(s); \n"+
" break;\n"+
" case String s: \n"+
" System.out.println(\"String\"); \n"+
" System.out.println(s);\n"+
" break; \n"+
" case X x:\n"+
" System.out.println(\"X\"); \n"+
" System.out.println(x);\n"+
" break;\n"+
" default : System.out.println(\"Object\"); \n"+
" }\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" foo(\"H\");\n"+
" foo(bar());\n"+
" }\n"+
" public static Object bar() { return new Object();}\n"+
"}",
},
"String s && s.length()>1\n" +
"Hello World!\n" +
"String\n" +
"H\n" +
"Object");
}
public void test045() {
this.runNegativeTest(
new String[] {
"X.java",
"public abstract class X {\n" +
" public static void main(String[] args) {\n" +
" switch (args.length) {\n" +
" case 1:\n" +
" final int j = 1;\n" +
" case 2:\n" +
" switch (5) {\n" +
" case j:\n" +
" }\n" +
" }\n" +
" }\n" +
"}\n",
},
"----------\n" +
"1. ERROR in X.java (at line 8)\n" +
" case j:\n" +
" ^\n" +
"The local variable j may not have been initialized\n" +
"----------\n");
}
public void testBug574525_01() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer I: \n"+
" System.out.println(\"Integer\"); \n"+
" System.out.println(I); \n"+
" break; \n"+
" case null:\n"+
" System.out.println(\"NULL\"); \n"+
" break;\n"+
" default : System.out.println(\"Object\"); \n"+
" }\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" foo(null);\n"+
" }\n"+
"}",
},
"NULL");
}
public void testBug574525_02() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer I: \n"+
" System.out.println(\"Integer\"); \n"+
" System.out.println(I); \n"+
" break; \n"+
" case String s && s.length()>1: \n"+
" System.out.println(\"String s && s.length()>1\"); \n"+
" System.out.println(s); \n"+
" break;\n"+
" case String s1: \n"+
" System.out.println(\"String\"); \n"+
" System.out.println(s1);\n"+
" break; \n"+
" case X x:\n"+
" System.out.println(\"X\"); \n"+
" System.out.println(x);\n"+
" break;\n"+
" case null:\n"+
" System.out.println(\"NULL\"); \n"+
" break;\n"+
" default : System.out.println(\"Object\"); \n"+
" }\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" foo(null);\n"+
" foo(bar());\n"+
" }\n"+
" public static Object bar() { return new Object();}\n"+
"}",
},
"String s && s.length()>1\n" +
"Hello World!\n" +
"NULL\n" +
"Object");
}
public void testBug574525_03() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case 10: \n"+
" System.out.println(\"Integer\"); \n"+
" System.out.println(o); \n"+
" break; \n"+
" case null:\n"+
" System.out.println(\"NULL\"); \n"+
" break;\n"+
" default : System.out.println(o); \n"+
" }\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" foo(0);\n"+
" }\n"+
"}",
},
"0");
}
public void testBug574525_04() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(int o) {\n"+
" switch (o) {\n"+
" case 10: \n"+
" System.out.println(\"Integer\"); \n"+
" System.out.println(o); \n"+
" break; \n"+
" case null:\n"+
" System.out.println(\"NULL\"); \n"+
" break;\n"+
" default : System.out.println(o); \n"+
" }\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" foo(0);\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 8)\n" +
" case null:\n" +
" ^^^^\n" +
"Type mismatch: cannot convert from null to int\n" +
"----------\n");
}
public void testBug574538_01() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(Integer.valueOf(11));\n"+
" foo(Integer.valueOf(9));\n"+
" }\n"+
"\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer i && i>10:\n"+
" System.out.println(\"Greater than 10:\" + o);\n"+
" break;\n"+
" case Integer j && j>0:\n"+
" System.out.println(\"Greater than 0:\" + o);\n"+
" break;\n"+
" default:\n"+
" System.out.println(\"Object\" + o);\n"+
" }\n"+
" }\n"+
"}",
},
"Greater than 10:11\n" +
"Greater than 0:9");
}
public void testBug574538_02() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo1(Integer.valueOf(10));\n"+
" foo1(Integer.valueOf(11));\n"+
" foo1(\"Hello World!\");\n"+
" }\n"+
"\n"+
" private static void foo1(Object o) {\n"+
" switch (o) {\n"+
" case Integer i&&i>10 -> System.out.println(\"Greater than 10:\");\n"+
" case String s&&s.equals(\"ff\") -> System.out.println(\"String:\" + s);\n"+
" default -> System.out.println(\"Object:\" + o);\n"+
" }\n"+
" }\n"+
"}",
},
"Object:10\n" +
"Greater than 10:\n" +
"Object:Hello World!");
}
public void testBug574549_01() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" }\n"+
"\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case default:\n"+
" System.out.println(\"Object: \" + o);\n"+
" }\n"+
" }\n"+
"}",
},
"Object: Hello World!");
}
public void testBug574549_02() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(Integer.valueOf(11));\n"+
" foo(Integer.valueOf(9));\n"+
" foo(\"Hello World!\");\n"+
" }\n"+
"\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer i && i>10:\n"+
" System.out.println(\"Greater than 10:\" + o);\n"+
" break;\n"+
" case Integer j && j>0:\n"+
" System.out.println(\"Greater than 0:\" + o);\n"+
" break;\n"+
" case default:\n"+
" System.out.println(\"Give Me Some SunShine:\" + o);\n"+
" }\n"+
" }\n"+
"}",
},
"Greater than 10:11\n" +
"Greater than 0:9\n" +
"Give Me Some SunShine:Hello World!");
}
public void testBug574549_03() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" }\n"+
"\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer i :\n"+
" System.out.println(\"Integer:\" + o);\n"+
" break;\n"+
" case default:\n"+
" System.out.println(\"Object\" + o);\n"+
" case default:\n"+
" System.out.println(\"Give me Some Sunshine\" + o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 13)\n" +
" case default:\n" +
" ^^^^^^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
public void testBug574549_04() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" }\n"+
"\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer i :\n"+
" System.out.println(\"Integer:\" + o);\n"+
" break;\n"+
" case default:\n"+
" System.out.println(\"Object\" + o);\n"+
" default:\n"+
" System.out.println(\"Give me Some Sunshine\" + o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 13)\n" +
" default:\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
// Test that when a pattern variable is unused and when the OPTION_PreserveUnusedLocal
// option is used, no issue is reported at runtime.
public void testBug573937_1() {
Map<String,String> options = getCompilerOptions();
String opt = options.get(CompilerOptions.OPTION_PreserveUnusedLocal);
try {
options.put(CompilerOptions.OPTION_PreserveUnusedLocal, CompilerOptions.DISABLED);
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void main(String[] args) {\n"
+ " System.out.println(\"Hello\");\n"
+ " }\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case String s:\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "}",
},
"Hello",
options);
} finally {
options.put(CompilerOptions.OPTION_PreserveUnusedLocal, opt);
}
}
// A simple pattern variable in a case is not visible in the
// following case statement
public void testBug573937_2() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case String s:\n"
+ " System.out.println(s);\n"
+ " break;\n"
+ " case Integer i:\n"
+ " System.out.println(s);\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "}",
},
"----------\n" +
"1. ERROR in X.java (at line 8)\n" +
" System.out.println(s);\n" +
" ^\n" +
"s cannot be resolved to a variable\n" +
"----------\n");
}
// Same as above, but without break statement
public void testBug573937_3() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case String s:\n"
+ " System.out.println(s);\n"
+ " case Integer i:\n"
+ " System.out.println(s);\n"
+ " default:\n"
+ " System.out.println(s);\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" System.out.println(s);\n" +
" ^\n" +
"s cannot be resolved to a variable\n" +
"----------\n" +
"2. ERROR in X.java (at line 9)\n" +
" System.out.println(s);\n" +
" ^\n" +
"s cannot be resolved to a variable\n" +
"----------\n");
}
// Test that compiler rejects attempts to redeclare local variable
// with same name as a pattern variable
public void testBug573937_4() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case String s:\n"
+ " String s = null;\n"
+ " System.out.println(s);\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" String s = null;\n" +
" ^\n" +
"Duplicate local variable s\n" +
"----------\n");
}
// Test that compiler allows local variable with same name as a
// pattern variable in a different case statement
public void testBug573937_5() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case String s:\n"
+ " System.out.println(s);\n"
+ " break;\n"
+ " default:\n"
+ " String s = null;\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ " public static void main(String[] args) {\n"
+ " foo(\"hello\");\n"
+ " }\n"
+ "}",
},
"hello");
}
// Test that a pattern variable can't use name of an already existing local
// variable
public void testBug573937_6() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case String o:\n"
+ " System.out.println(o);\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case String o:\n" +
" ^\n" +
"Duplicate local variable o\n" +
"----------\n");
}
// Test that compiler rejects attempts to redeclare another pattern
// variable (instanceof) with same name as that a pattern variable in
// that case statement
public void testBug573937_7() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case String s1:\n"
+ " if (o instanceof String s1) {\n"
+ " System.out.println(s1);\n"
+ " }\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "} ",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" if (o instanceof String s1) {\n" +
" ^^\n" +
"Duplicate local variable s1\n" +
"----------\n");
}
// Test that when multiple case statements declare pattern variables
// with same name, correct ones are used in their respective scopes.
public void testBug573937_8() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case String s1:\n"
+ " System.out.println(s1.length());\n"
+ " break;\n"
+ " case Integer s1:\n"
+ " System.out.println(s1.length());\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "} ",
},
"----------\n" +
"1. ERROR in X.java (at line 8)\n" +
" System.out.println(s1.length());\n" +
" ^^^^^^\n" +
"The method length() is undefined for the type Integer\n" +
"----------\n");
}
// Test that a pattern variable declared in the preceding case statement
// can't be used in the case statement itself
public void testBug573937_9() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " switch (o) {\n"
+ " case Integer i1:\n"
+ " break;\n"
+ " case String s1 && s1.length() > i1:\n"
+ " System.out.println(s1.length());\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "} ",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" case String s1 && s1.length() > i1:\n" +
" ^^\n" +
"i1 cannot be resolved to a variable\n" +
"----------\n");
}
// Test that redefining pattern variables with null is allowed
// and produce expected result (NPE) when run.
public void testBug573937_10() {
Runner runner = new Runner();
runner.testFiles = new String[] {
"X.java",
"public class X {\n"
+ "@SuppressWarnings(\"null\")"
+ " public static void foo(Object o) {\n"
+ " try {\n"
+ " switch (o) {\n"
+ " case String s1 && s1.length() == 0:\n"
+ " break;"
+ " case String s1:\n"
+ " s1 = null;\n"
+ " System.out.println(s1.length());\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " } catch(Exception e) {\n"
+ " System.out.println(e.getMessage());\n"
+ " };\n"
+ " }\n"
+ " public static void main(String[] args) {\n"
+ " foo(\"hello\");\n"
+ " }\n"
+ "}",
};
runner.expectedOutputString = "Cannot invoke \"String.length()\" because \"s1\" is null";
runner.expectedJavacOutputString = "Cannot invoke \"String.length()\" because \"<local4>\" is null";
runner.vmArguments = new String[] {"--enable-preview"};
runner.customOptions = getCompilerOptions();
runner.javacTestOptions = JavacTestOptions.forReleaseWithPreview(SwitchPatternTest.previewLevel);
runner.runConformTest();
}
// Test that a pattern variable is allowed in a switch label throw
// statement and when run, produces expected result
public void testBug573937_11() {
Runner runner = new Runner();
runner.testFiles = new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) throws Exception {\n"
+ " switch (o) {\n"
+ " case String s1:\n"
+ " throw new Exception(s1);\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ " public static void main(String[] args) throws Exception {\n"
+ " try {\n"
+ " foo(\"hello\");\n"
+ " } catch(Exception e) {\n"
+ " e.printStackTrace(System.out);\n"
+ " };\n"
+ " }\n"
+ "} ",
};
runner.expectedOutputString = "java.lang.Exception: hello\n" +
" at X.foo(X.java:5)\n" +
" at X.main(X.java:12)";
runner.expectedJavacOutputString = "java.lang.Exception: hello\n"
+ " at X.foo(X.java:5)\n"
+ " at X.main(X.java:12)";
runner.vmArguments = new String[] {"--enable-preview"};
runner.customOptions = getCompilerOptions();
runner.javacTestOptions = JavacTestOptions.forReleaseWithPreview(SwitchPatternTest.previewLevel);
runner.runConformTest();
}
// A non effectively final referenced from the RHS of the guarding expression
// is reported by the compiler.
public void testBug574612_1() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " int len = 2;\n"
+ " switch (o) {\n"
+ " case String o1 && o1.length() > len:\n"
+ " len = 0;\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "} ",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case String o1 && o1.length() > len:\n" +
" ^^^\n" +
"Local variable len referenced from a guard must be final or effectively final\n" +
"----------\n");
}
// A non effectively final referenced from the LHS of the guarding expression
// is reported by the compiler.
public void testBug574612_2() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " int len = 2;\n"
+ " switch (o) {\n"
+ " case String o1 && len < o1.length():\n"
+ " len = 0;\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "} ",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case String o1 && len < o1.length():\n" +
" ^^^\n" +
"Local variable len referenced from a guard must be final or effectively final\n" +
"----------\n");
}
// An explicitly final local variable, also referenced in a guarding expression of a pattern
// and later on re-assigned is only reported for the explicit final being modified
public void testBug574612_3() {
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " final int len = 2;\n"
+ " switch (o) {\n"
+ " case String o1 && len < o1.length():\n"
+ " len = 0;\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ "} ",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" len = 0;\n" +
" ^^^\n" +
"The final local variable len cannot be assigned. It must be blank and not using a compound assignment\n" +
"----------\n");
}
public void testBug574612_4() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Object o) {\n"
+ " int len = 2;\n"
+ " switch (o) {\n"
+ " case String o1 && len < o1.length():\n"
+ " System.out.println(o1);\n"
+ " break;\n"
+ " default:\n"
+ " break;\n"
+ " }\n"
+ " }\n"
+ " public static void main(String[] args) throws Exception {\n"
+ " foo(\"hello\");\n"
+ " }\n"
+ "} ",
},
"hello");
}
public void testBug574719_001() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case 0, default : k = 1;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100 ));\n"+
" }\n"+
"}",
},
"1");
}
public void testBug574719_002() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case 0, default, 1 : k = 1;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100 ));\n"+
" }\n"+
"}",
},
"1");
}
public void testBug574719_003() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case default, 1 : k = 1;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100));\n"+
" System.out.println(foo(0));\n"+
" }\n"+
"}",
},
"1\n" +
"1");
}
public void testBug574719_004() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case 0 : k = 2; break;\n"+
" case default, 1 : k = 1;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100));\n"+
" System.out.println(foo(0));\n"+
" }\n"+
"}",
},
"1\n" +
"2");
}
public void testBug574719_005() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case 0 : k = 2; break;\n"+
" case 1, default : k = 1;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100));\n"+
" System.out.println(foo(0));\n"+
" }\n"+
"}",
},
"1\n" +
"2");
}
public void testBug574719_006() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case 0 : k = 2; break;\n"+
" case 1, default, default : k = 1;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100));\n"+
" System.out.println(foo(0));\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" case 1, default, default : k = 1;\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
public void testBug574719_007() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case 10, default: k = 1;break;\n"+
" case 0 : k = 2; break;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100));\n"+
" System.out.println(foo(0));\n"+
" System.out.println(foo(10));\n"+
" }\n"+
"}",
},
"1\n"+
"2\n"+
"1");
}
public void testBug574561_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" default, default : k = 2; break;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100));\n"+
" System.out.println(foo(0));\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" default, default : k = 2; break;\n" +
" ^\n" +
"Syntax error on token \",\", : expected\n" +
"----------\n");
}
public void testBug574561_002() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case default, 1, default : k = 1;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100));\n"+
" System.out.println(foo(0));\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case default, 1, default : k = 1;\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
public void testBug574561_003() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static int foo(Integer o) {\n"+
" int k = 0;\n"+
" switch (o) {\n"+
" case default, 1, default : k = 1;\n"+
" }\n"+
" return k;\n"+
" } \n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(100));\n"+
" System.out.println(foo(0));\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case default, 1, default : k = 1;\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
public void testBug574793_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {}\n"+
" private static void foo1(int o) {\n"+
" switch (o) {\n"+
" case null -> System.out.println(\"null\");\n"+
" case 20 -> System.out.println(\"20\");\n"+
" }\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case \"F\" :\n"+
" break;\n"+
" case 2 :\n"+
" break;\n"+
" default:\n"+
" break;\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" switch (o) {\n" +
" ^\n" +
"An enhanced switch statement should be exhaustive; a default label expected\n" +
"----------\n" +
"2. ERROR in X.java (at line 5)\n" +
" case null -> System.out.println(\"null\");\n" +
" ^^^^\n" +
"Type mismatch: cannot convert from null to int\n" +
"----------\n" +
"3. ERROR in X.java (at line 11)\n" +
" case \"F\" :\n" +
" ^^^\n" +
"Type mismatch: cannot convert from String to Object\n" +
"----------\n" +
"4. ERROR in X.java (at line 13)\n" +
" case 2 :\n" +
" ^\n" +
"Type mismatch: cannot convert from int to Object\n" +
"----------\n");
}
public void testBug574559_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {}\n"+
" public static void foo1(Integer o) {\n"+
" switch (o) {\n"+
" case 1, Integer i -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case 1, Integer i -> System.out.println(o);\n" +
" ^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n");
}
public void testBug574559_002() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {}\n"+
" private static void foo1(Integer o) {\n"+
" switch (o) {\n"+
" case Integer i, 30 -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case Integer i, 30 -> System.out.println(o);\n" +
" ^^\n" +
"This case label is dominated by one of the preceding case label\n" +
"----------\n");
}
// Test that fall-through to a pattern is not allowed (label statement group has one statement)
public void testBug573940_1() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
"public void foo(Number n) {\n"
+ " switch (n) {\n"
+ " case Integer i :\n"
+ " System.out.println(i);\n"
+ " case Float f :\n"
+ " System.out.println(f);\n"
+ " case Object o : break;\n"
+ " }\n"
+ "}\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" case Float f :\n" +
" ^^^^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n" +
"2. ERROR in X.java (at line 8)\n" +
" case Object o : break;\n" +
" ^^^^^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n");
}
// Test that fall-through to a pattern is not allowed (label statement group has zero statement)
public void testBug573940_2() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
"public void foo(Number n) {\n"
+ " switch (n) {\n"
+ " case Integer i :\n"
+ " case Float f :\n"
+ " System.out.println(f);\n"
+ " break;\n"
+ " default : break;\n"
+ " }\n"
+ "}\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case Float f :\n" +
" ^^^^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n");
}
// Test that fall-through to a pattern is not allowed (label statement group has zero statement)
public void testBug573940_2a() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
"public void foo(Number n) {\n"
+ " switch (n) {\n"
+ " default :\n"
+ " case Float f :\n"
+ " System.out.println(f);\n"
+ " break;\n"
+ " }\n"
+ "}\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case Float f :\n" +
" ^^^^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n");
}
// Test that falling through from a pattern to a default is allowed
public void testBug573940_3() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"
+ "public static void foo(Number n) {\n"
+ " switch (n) {\n"
+ " case Integer i :\n"
+ " System.out.println(i);\n"
+ " default:\n"
+ " System.out.println(\"null\");\n"
+ " }\n"
+ " }\n"
+ "public static void main(String[] args) {\n"
+ " foo(Integer.valueOf(5));\n"
+ " }\n"
+ "}",
},
"5\n" +
"null");
}
// Test that a case statement with pattern is allowed when statement group ends
// with an Throw statement instead of a break statement
public void testBug573940_4() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"
+ "public static void foo(Number n) {\n"
+ " switch (n) {\n"
+ " case Integer i :\n"
+ " throw new IllegalArgumentException();\n"
+ " default:\n"
+ " System.out.println(\"null\");\n"
+ " }\n"
+ " }\n"
+ "public static void main(String[] args) {\n"
+ " try{\n"
+ " foo(Integer.valueOf(5));\n"
+ " } catch(Exception e) {\n"
+ " e.printStackTrace(System.out);\n"
+ " }\n"
+ " }\n"
+ "}",
},
"java.lang.IllegalArgumentException\n" +
" at X.foo(X.java:5)\n" +
" at X.main(X.java:12)");
}
// Test that switch expression with pattern variables is reported when a case statement
// doesn't return any value.
public void testBug573940_5() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"
+ " public static void foo(Number n) {\n"
+ " int j = \n"
+ " switch (n) {\n"
+ " case Integer i -> {\n"
+ " }\n"
+ " default -> {\n"
+ " yield 1;\n"
+ " }\n"
+ " };\n"
+ " }\n"
+ "}",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" }\n" +
" ^^\n" +
"A switch labeled block in a switch expression should not complete normally\n" +
"----------\n");
}
public void testBug574564_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(new String(\"Hello\"));\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case var i -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case var i -> System.out.println(0);\n" +
" ^^^\n" +
"'var' is not allowed here\n" +
"----------\n");
}
public void testBug574564_002() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(new String(\"Hello\"));\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case var i, var j, var k -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case var i, var j, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n" +
"2. ERROR in X.java (at line 7)\n" +
" case var i, var j, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n" +
"3. ERROR in X.java (at line 7)\n" +
" case var i, var j, var k -> System.out.println(0);\n" +
" ^^^^^\n" +
"A switch label may not have more than one pattern case label element\n" +
"----------\n" +
"4. ERROR in X.java (at line 7)\n" +
" case var i, var j, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n");
}
public void testBug574564_003() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(10);\n"+
" }\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case var i, 10 -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case var i, 10 -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n");
}
public void testBug574564_004() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(10);\n"+
" }\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case var i, 10, var k -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case var i, 10, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n" +
"3. ERROR in X.java (at line 7)\n" +
" case var i, 10, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n" +
"4. ERROR in X.java (at line 7)\n" +
" case var i, 10, var k -> System.out.println(0);\n" +
" ^^^^^\n" +
"A switch label may not have more than one pattern case label element\n" +
"----------\n");
}
public void testBug574564_005() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(10);\n"+
" }\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case 10, null, var k -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case 10, null, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n");
}
public void testBug574564_006() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(10);\n"+
" }\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case default, var k -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case default, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n" +
"2. ERROR in X.java (at line 7)\n" +
" case default, var k -> System.out.println(0);\n" +
" ^^^^^\n" +
"A switch label may not have both a pattern case label element and a default case label element\n" +
"----------\n" +
"3. ERROR in X.java (at line 8)\n" +
" default -> System.out.println(o);\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
public void testBug574564_007() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(10);\n"+
" }\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case default, default, var k -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case default, default, var k -> System.out.println(0);\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n" +
"2. ERROR in X.java (at line 7)\n" +
" case default, default, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n" +
"3. ERROR in X.java (at line 7)\n" +
" case default, default, var k -> System.out.println(0);\n" +
" ^^^^^\n" +
"A switch label may not have both a pattern case label element and a default case label element\n" +
"----------\n" +
"4. ERROR in X.java (at line 8)\n" +
" default -> System.out.println(o);\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
public void testBug574564_008() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(10);\n"+
" }\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case default, 1, var k -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case default, 1, var k -> System.out.println(0);\n" +
" ^^^\n" +
"\'var\' is not allowed here\n" +
"----------\n" +
"3. ERROR in X.java (at line 7)\n" +
" case default, 1, var k -> System.out.println(0);\n" +
" ^^^^^\n" +
"A switch label may not have both a pattern case label element and a default case label element\n" +
"----------\n" +
"5. ERROR in X.java (at line 8)\n" +
" default -> System.out.println(o);\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
public void testBug574564_009() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case String s, default, Integer i -> System.out.println(0);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case String s, default, Integer i -> System.out.println(0);\n" +
" ^^^^^^^\n" +
"A switch label may not have both a pattern case label element and a default case label element\n" +
"----------\n" +
"2. ERROR in X.java (at line 4)\n" +
" case String s, default, Integer i -> System.out.println(0);\n" +
" ^^^^^^^^^\n" +
"A switch label may not have more than one pattern case label element\n" +
"----------\n");
}
public void testBug574564_010() {
Map<String, String> options = getCompilerOptions();
options.put(CompilerOptions.OPTION_EnablePreviews, CompilerOptions.DISABLED);
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case String s, default, Integer i -> System.out.println(0);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case String s, default, Integer i -> System.out.println(0);\n" +
" ^\n" +
"Syntax error on token \"s\", delete this token\n" +
"----------\n" +
"2. ERROR in X.java (at line 4)\n" +
" case String s, default, Integer i -> System.out.println(0);\n" +
" ^\n" +
"Syntax error on token \"i\", delete this token\n" +
"----------\n",
null,
true,
options);
}
public void testBug574564_011() {
Map<String, String> options = getCompilerOptions();
options.put(CompilerOptions.OPTION_EnablePreviews, CompilerOptions.DISABLED);
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case null -> System.out.println(0);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case null -> System.out.println(0);\n" +
" ^^^^\n" +
"Pattern Matching in Switch is a preview feature and disabled by default. Use --enable-preview to enable\n" +
"----------\n",
null,
true,
options);
}
public void testBug574564_012() {
Map<String, String> options = getCompilerOptions();
options.put(CompilerOptions.OPTION_EnablePreviews, CompilerOptions.DISABLED);
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Integer o) {\n"+
" switch (o) {\n"+
" case 1, default, null -> System.out.println(0);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case 1, default, null -> System.out.println(0);\n" +
" ^^^^^^^\n" +
"Pattern Matching in Switch is a preview feature and disabled by default. Use --enable-preview to enable\n" +
"----------\n" +
"2. ERROR in X.java (at line 4)\n" +
" case 1, default, null -> System.out.println(0);\n" +
" ^^^^\n" +
"Pattern Matching in Switch is a preview feature and disabled by default. Use --enable-preview to enable\n" +
"----------\n",
null,
true,
options);
}
public void testBug574564_013() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case default, default -> System.out.println(0);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case default, default -> System.out.println(0);\n" +
" ^^^^^^^\n" +
"The default case is already defined\n" +
"----------\n");
}
public void testBug574563_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {}\n"+
" private static void foo1(Integer o) {\n"+
" switch (o) {\n"+
" case null, null -> System.out.println(o);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case null, null -> System.out.println(o);\n" +
" ^^^^^^^^^^^^^^^\n" +
"Duplicate case\n" +
"----------\n");
}
public void testBug574563_002() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case null, Integer i -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug574563_003() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer i, null -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug574563_004() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case null, Integer i && i > 10 -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case null, Integer i && i > 10 -> System.out.println(0);\n" +
" ^^^^^^^^^^^^^^^^^^^\n" +
"A null case label and patterns can co-exist only if the pattern is a type pattern\n" +
"----------\n" +
"2. ERROR in X.java (at line 7)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug574563_005() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer i && i > 10, null -> System.out.println(0);\n"+
" default -> System.out.println(o);\n"+
" }\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer i && i > 10, null -> System.out.println(0);\n" +
" ^^^^\n" +
"A null case label and patterns can co-exist only if the pattern is a type pattern\n" +
"----------\n" +
"2. ERROR in X.java (at line 7)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug575030_01() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello World!\");\n"+
" }\n"+
"\n"+
" private static void foo(String o) {\n"+
" switch (o) {\n"+
" case String s -> System.out.println(s);\n"+
" }\n"+
" }\n"+
"}",
},
"Hello World!");
}
public void testBug574614_001() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(Long.valueOf(10));\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" String s1 = \" Hello \";\n"+
" String s2 = \"World!\";\n"+
" switch (o) {\n"+
" case Integer I && I > 10: break;\n"+
" case X J: break;\n"+
" case String s : break;\n"+
" default:\n"+
" s1 = new StringBuilder(String.valueOf(s1)).append(String.valueOf(s2)).toString();\n"+
" System.out.println(s1);\n"+
" break; \n"+
" }\n"+
" }\n"+
"}",
},
"Hello World!");
}
public void testBug574614_002() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(Long.valueOf(0));\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer I:\n"+
" break;\n"+
" case String s :\n"+
" break;\n"+
" case X J:\n"+
" break;\n"+
" default:\n"+
" String s1 = \"Hello \";\n"+
" String s2 = \"World!\";\n"+
" s1 = s1 +s2; \n"+
" System.out.println(s1);\n"+
" break;\n"+
" }\n"+
" } \n"+
"}",
},
"Hello World!");
}
public void testBug573921_1() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch(o) {\n" +
" case CharSequence cs ->\n" +
" System.out.println(\"A sequence of length \" + cs.length());\n" +
" case String s && s.length() > 0 -> \n" +
" System.out.println(\"A string: \" + s);\n" +
" default -> {\n" +
" break;\n" +
" } \n" +
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" case String s && s.length() > 0 -> \n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
"This case label is dominated by one of the preceding case label\n" +
"----------\n");
}
public void testBug573921_2() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" private static void foo(Object o) {\n"+
" switch(o) {\n" +
" case CharSequence cs:\n" +
" System.out.println(\"A sequence of length \" + cs.length());\n" +
" break;\n" +
" case String s:\n" +
" System.out.println(\"A string: \" + s);\n" +
" break;\n" +
" default: \n" +
" break;\n" +
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" case String s:\n" +
" ^^^^^^^^\n" +
"This case label is dominated by one of the preceding case label\n" +
"----------\n");
}
public void testBug573921_3() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello!\");\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" switch(o) {\n" +
" case String s:\n" +
" System.out.println(\"String:\" + s);\n" +
" break;\n" +
" case CharSequence cs:\n" +
" System.out.println(\"A CS:\" + cs);\n" +
" break;\n" +
" default: \n" +
" break;\n" +
" }\n"+
" }\n"+
"}",
},
"String:Hello!");
}
public void testBug573921_4() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(new StringBuffer(\"Hello!\"));\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" switch(o) {\n" +
" case String s:\n" +
" System.out.println(\"String:\" + s);\n" +
" break;\n" +
" case CharSequence cs:\n" +
" System.out.println(\"A CS:\" + cs.toString());\n" +
" break;\n" +
" default: \n" +
" break;\n" +
" }\n"+
" }\n"+
"}",
},
"A CS:Hello!");
}
public void testBug573921_5() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello\");\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" switch(o) {\n" +
" case String s && s.length() < 5 :\n" +
" System.out.println(\"1:\" + s);\n" +
" break;\n" +
" case String s && s.length() == 5:\n" +
" System.out.println(\"2:\" + s);\n" +
" break;\n" +
" default : System.out.println(\"Object\");\n" +
" }\n"+
" }\n"+
"}",
},
"2:Hello");
}
public void testBug573921_6() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" public static void main(String[] args) {\n"+
" foo(\"\");\n"+
" }\n"+
" private static void foo(Object o) {\n"+
" switch(o) {\n" +
" case String s && s.length() < 5 :\n" +
" System.out.println(\"1:\" + s);\n" +
" break;\n" +
" case String s && s.length() == 5:\n" +
" System.out.println(\"2:\" + s);\n" +
" break;\n" +
" default : System.out.println(\"Object\");\n" +
" }\n"+
" }\n"+
"}",
},
"1:");
}
public void testBug573921_7() {
runNegativeTest(
new String[] {
"X.java",
"import java.util.*;\n" +
"public class X {\n"+
" @SuppressWarnings(\"rawtypes\")\n" +
" private static void foo(Object o) {\n"+
" switch(o) {\n"+
" case List cs:\n"+
" System.out.println(\"A sequence of length \" + cs.size());\n"+
" break;\n"+
" case List<String> s: \n"+
" System.out.println(\"A string: \" + s);\n"+
" break;\n"+
" } "+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" switch(o) {\n" +
" ^\n" +
"An enhanced switch statement should be exhaustive; a default label expected\n" +
"----------\n" +
"2. ERROR in X.java (at line 9)\n" +
" case List<String> s: \n" +
" ^^^^^^^^^^^^^^\n" +
"Type Object cannot be safely cast to List<String>\n" +
"----------\n" +
"3. ERROR in X.java (at line 9)\n" +
" case List<String> s: \n" +
" ^^^^^^^^^^^^^^\n" +
"This case label is dominated by one of the preceding case label\n" +
"----------\n");
}
public void testBug573921_8() {
runNegativeTest(
new String[] {
"X.java",
"import java.util.*;\n" +
"public class X {\n"+
" @SuppressWarnings(\"rawtypes\")\n" +
" private static void foo(Object o) {\n"+
" switch(o.hashCode()) {\n"+
" case String s:\n"+
" break;\n"+
" default: \n"+
" break;\n"+
" } "+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" case String s:\n" +
" ^^^^^^^^\n" +
"Type mismatch: cannot convert from int to String\n" +
"----------\n");
}
public void testBug573921_9() {
runNegativeTest(
new String[] {
"X.java",
"import java.util.*;\n" +
"public class X {\n"+
" @SuppressWarnings(\"rawtypes\")\n" +
" private static void foo(Object o) {\n"+
" switch(o) {\n"+
" case Object o1:\n"+
" break;\n"+
" default: \n"+
" break;\n"+
" } "+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 8)\n" +
" default: \n" +
" ^^^^^^^\n" +
"Switch case cannot have both a total pattern and default label\n" +
"----------\n");
}
public void testBug573921_10() {
runNegativeTest(
new String[] {
"X.java",
"import java.util.*;\n" +
"public class X {\n"+
" @SuppressWarnings(\"rawtypes\")\n" +
" private static void foo(List<String> o) {\n"+
" switch(o) {\n"+
" case List o1:\n"+
" break;\n"+
" default: \n"+
" break;\n"+
" } "+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 8)\n" +
" default: \n" +
" ^^^^^^^\n" +
"Switch case cannot have both a total pattern and default label\n" +
"----------\n");
}
public void testBug573921_11() {
runNegativeTest(
new String[] {
"X.java",
"import java.util.*;\n" +
"public class X {\n"+
" @SuppressWarnings(\"rawtypes\")\n" +
" private static void foo(String s) {\n"+
" switch(s) {\n"+
" case CharSequence cs:\n"+
" break;\n"+
" default: \n"+
" break;\n"+
" } "+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 8)\n" +
" default: \n" +
" ^^^^^^^\n" +
"Switch case cannot have both a total pattern and default label\n" +
"----------\n");
}
public void testBug575049_001() {
runConformTest(
new String[] {
"X.java",
"sealed interface I permits A,B,C {}\n"+
"final class A implements I {}\n"+
"final class B implements I {}\n"+
"record C(int j) implements I {} // Implicitly final\n"+
"public class X {\n"+
" static int testSealedCoverage(I i) {\n"+
" return switch (i) {\n"+
" case A a -> 0;\n"+
" case B b -> 1;\n"+
" case C c -> 2; // No default required!\n"+
" default -> 3;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" A a = new A();\n"+
" System.out.println(testSealedCoverage(a));\n"+
" }\n"+
"}",
},
"0");
}
public void testBug575049_002() {
runConformTest(
new String[] {
"X.java",
"sealed interface I permits A,B,C {}\n"+
"final class A implements I {}\n"+
"final class B implements I {}\n"+
"record C(int j) implements I {} // Implicitly final\n"+
"public class X {\n"+
" static int testSealedCoverage(I i) {\n"+
" return switch (i) {\n"+
" case A a -> 0;\n"+
" case B b -> 1;\n"+
" case C c -> 2; // No default required!\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" A a = new A();\n"+
" System.out.println(testSealedCoverage(a));\n"+
" }\n"+
"}",
},
"0");
}
public void testBug575049_003() {
runConformTest(
new String[] {
"X.java",
"sealed interface I permits A,B,C {}\n"+
"final class A implements I {}\n"+
"final class B implements I {}\n"+
"record C(int j) implements I {} // Implicitly final\n"+
"public class X {\n"+
" static int testSealedCoverage(I i) {\n"+
" return switch (i) {\n"+
" case A a -> 0;\n"+
" case B b -> 1;\n"+
" default -> 2; // No default required!\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" A a = new A();\n"+
" System.out.println(testSealedCoverage(a));\n"+
" }\n"+
"}",
},
"0");
}
public void testBug575049_004() {
runNegativeTest(
new String[] {
"X.java",
"sealed interface I permits A,B,C {}\n"+
"final class A implements I {}\n"+
"final class B implements I {}\n"+
"record C(int j) implements I {} // Implicitly final\n"+
"public class X {\n"+
" static int testSealedCoverage(I i) {\n"+
" return switch (i) {\n"+
" case A a -> 0;\n"+
" case B b -> 1;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" A a = new A();\n"+
" System.out.println(testSealedCoverage(a));\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" return switch (i) {\n" +
" ^\n" +
"A switch expression should have a default case\n" +
"----------\n");
}
public void testBug575048_01() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Integer i) {\n"+
" return switch (i) {\n"+
" default -> 2;\n"+
" case Integer i1 -> 0;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(1));\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case Integer i1 -> 0;\n" +
" ^^^^^^^^^^^^^^^\n" +
"Switch case cannot have both a total pattern and default label\n" +
"----------\n");
}
public void testBug575053_001() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" public void foo(String o) {\n" +
" switch (o) {\n" +
" case String s && s.length() > 0 -> {}\n" +
" default -> {}\n" +
" } \n" +
" }\n" +
" public static void main(String[] args) {\n" +
" try{\n" +
" (new X()).foo(null);\n" +
" } catch(Exception e) {\n" +
" e.printStackTrace(System.out);\n" +
" }\n" +
" }\n"+
"}",
},
"java.lang.NullPointerException\n" +
" at java.base/java.util.Objects.requireNonNull(Objects.java:208)\n" +
" at X.foo(X.java:3)\n" +
" at X.main(X.java:10)");
}
public void testBug575053_002() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" public void foo(Object o) {\n" +
" switch (o) {\n" +
" case String s -> {}\n" +
" default -> {}\n" +
" } \n" +
" }\n" +
" public static void main(String[] args) {\n" +
" try{\n" +
" (new X()).foo(null);\n" +
" } catch(Exception t) {\n" +
" t.printStackTrace();\n" +
" }\n" +
" }\n"+
"}",
},
"",
"java.lang.NullPointerException\n" +
" at java.base/java.util.Objects.requireNonNull(Objects.java:208)\n" +
" at X.foo(X.java:3)\n" +
" at X.main(X.java:10)");
}
public void testBug575249_01() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" public static int foo(Object o) {\n" +
" return switch (o) {\n" +
" case (String s) : yield 0;\n" +
" default : yield 1;\n" +
" };\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" System.out.println(foo(\"Hello\"));\n" +
" }\n"+
"}",
},
"0");
}
public void testBug575249_02() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" public static int foo(Object o) {\n" +
" return switch (o) {\n" +
" case (String s && s.length() < 10) : yield 0;\n" +
" default : yield 1;\n" +
" };\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" System.out.println(foo(\"Hello\"));\n" +
" }\n"+
"}",
},
"0");
}
public void testBug575249_03() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" public static int foo(Object o) {\n" +
" return switch (o) {\n" +
" case (String s) -> 0;\n" +
" default -> 1;\n" +
" };\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" System.out.println(foo(\"Hello\"));\n" +
" }\n"+
"}",
},
"0");
}
public void testBug575249_04() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" public static int foo(Object o) {\n" +
" return switch (o) {\n" +
" case (String s && s.length() < 10) -> 0;\n" +
" default -> 1;\n" +
" };\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" System.out.println(foo(\"Hello\"));\n" +
" }\n"+
"}",
},
"0");
}
public void testBug575241_01() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Integer i) {\n"+
" return switch (i) {\n"+
" case Integer i1 -> 0;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(1));\n"+
" }\n"+
"}",
},
"0");
}
public void testBug575241_02() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Integer i) {\n"+
" return switch (i) {\n"+
" case Object o -> 0;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(1));\n"+
" }\n"+
"}",
},
"0");
}
public void testBug575241_03() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Object myVar) {\n"+
" return switch (myVar) {\n"+
" case null -> 0;\n"+
" case Integer o -> 1;\n"+
" case Object obj ->2;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(Integer.valueOf(0)));\n"+
" System.out.println(foo(null));\n"+
" }\n"+
"}",
},
"1\n" +
"0");
}
public void testBug575241_04() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Object myVar) {\n"+
" return switch (myVar) {\n"+
" case Integer o -> 1;\n"+
" case Object obj ->2;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(Integer.valueOf(0)));\n"+
" System.out.println(foo(null));\n"+
" }\n"+
"}",
},
"1\n" +
"2");
}
public void testBug575241_05() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Integer myVar) {\n"+
" switch (myVar) {\n"+
" case null -> System.out.println(100);\n"+
" case Integer o -> System.out.println(o);\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(Integer.valueOf(0));\n"+
" foo(null);\n"+
" }\n"+
"}",
},
"0\n" +
"100");
}
public void testBug575241_06() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Integer myVar) {\n"+
" switch (myVar) {\n"+
" case Integer o -> System.out.println(o);\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(Integer.valueOf(0));\n"+
" foo(null);\n"+
" }\n"+
"}",
},
"0\n" +
"null");
}
public void testBug575241_07() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(String myVar) {\n"+
" switch (myVar) {\n"+
" case null -> System.out.println(100);\n"+
" case String o -> System.out.println(o);\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello\");\n"+
" foo(null);\n"+
" }\n"+
"}",
},
"Hello\n" +
"100");
}
public void testBug575241_08() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(String myVar) {\n"+
" switch (myVar) {\n"+
" case String o -> System.out.println(o);\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello\");\n"+
" foo(null);\n"+
" }\n"+
"}",
},
"Hello\n" +
"null");
}
public void testBug575356_01() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Integer myVar) {\n"+
" switch (myVar) {\n"+
" case default -> System.out.println(\"hello\");\n"+
" }; \n"+
" } \n"+
"\n"+
" public static void main(String[] args) {\n"+
" foo(Integer.valueOf(10)); \n"+
" } \n"+
"}",
},
"hello");
}
public void testBug575356_02() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Integer myVar) {\n"+
" switch (myVar) {\n"+
" case null, default -> System.out.println(\"hello\");\n"+
" }; \n"+
" } \n"+
"\n"+
" public static void main(String[] args) {\n"+
" foo(Integer.valueOf(10)); \n"+
" } \n"+
"}",
},
"hello");
}
public void testBug575356_03() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Integer myVar) {\n"+
" switch (myVar) {\n"+
" case default, null -> System.out.println(\"hello\");\n"+
" }; \n"+
" } \n"+
"\n"+
" public static void main(String[] args) {\n"+
" foo(Integer.valueOf(10)); \n"+
" } \n"+
"}",
},
"hello");
}
public void testBug575356_04() {
this.runConformTest(
new String[] {
"X.java",
"public class X {\n"+
"private static void foo(Object o) {\n"+
" switch (o) {\n"+
" case Integer i ->\n"+
" System.out.println(\"Integer:\"+ i );\n"+
" case default -> System.out.println(o.toString() );\n"+
" }\n"+
"}\n"+
"\n"+
" public static void main(String[] args) {\n"+
" foo(Integer.valueOf(10)); \n"+
" foo(new String(\"Hello\")); \n"+
" } \n"+
"}",
},
"Integer:10\n" +
"Hello");
}
public void testBug575052_001() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Object o) {\n"+
" switch (o) {\n"+
" case String s -> System.out.println(s);\n"+
" default -> System.out.println(0);\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello\");\n"+
" }\n"+
"}",
},
"Hello");
}
public void testBug575052_002() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Object o) {\n"+
" switch (o) {\n"+
" case String s -> System.out.println(s);\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello\");\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 3)\n" +
" switch (o) {\n" +
" ^\n" +
"An enhanced switch statement should be exhaustive; a default label expected\n" +
"----------\n");
}
public void testBug575052_003() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Object o) {\n"+
" switch (o) {\n"+
" case null -> System.out.println(0);\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello\");\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 3)\n" +
" switch (o) {\n" +
" ^\n" +
"An enhanced switch statement should be exhaustive; a default label expected\n" +
"----------\n");
}
public void testBug575052_004() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" private static int foo(int i) {\n"+
" switch (i) {\n"+
" case 1:\n"+
" break;\n"+
" }\n"+
" return 0;\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(X.foo(0));\n"+
" }\n"+
"}",
},
"0");
}
public void testBug575050_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Object o) {\n"+
" return switch (o) {\n"+
" case String s -> 0;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello\");\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 3)\n" +
" return switch (o) {\n" +
" ^\n" +
"A switch expression should have a default case\n" +
"----------\n");
}
public void testBug575050_002() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Object o) {\n"+
" return switch (o) {\n"+
" case null -> 0;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" foo(\"Hello\");\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 3)\n" +
" return switch (o) {\n" +
" ^\n" +
"A switch expression should have a default case\n" +
"----------\n");
}
// From 14.11.1: A switch label that has a pattern case label element p that is
// total for the type of the selector expression of the enclosing
// switch statement or switch expression dominates a switch label that has
// a null case label element.
public void testBug575047_01() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Integer i) {\n"+
" return switch (i) {\n"+
" case Integer i1 -> 0;\n"+
" case null -> 2;\n"+
" };\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case null -> 2;\n" +
" ^^^^\n" +
"This case label is dominated by one of the preceding case label\n" +
"----------\n");
}
// A switch label that has a pattern case label element p dominates another
// switch label that has a constant case label element c if either of the
// following is true:
// * the type of c is a primitive type and its wrapper class (5.1.7) is a subtype of the erasure of the type of p.
// * the type of c is a reference type and is a subtype of the erasure of the type of p.
public void testBug575047_02() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Integer i) {\n"+
" return switch (i) {\n"+
" case Integer i1 -> i1;\n"+
" case 0 -> 0;\n"+
" };\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case 0 -> 0;\n" +
" ^\n" +
"This case label is dominated by one of the preceding case label\n" +
"----------\n");
}
public void testBug575047_03() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Color c) {\n"+
" switch (c) {\n" +
" case Color c1 : \n" +
" break;\n" +
" case Blue :\n" +
" break;\n" +
" }\n"+
" }\n"+
"enum Color { Blue, Red; }\n" +
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" case Blue :\n" +
" ^^^^\n" +
"This case label is dominated by one of the preceding case label\n" +
"----------\n");
}
public void testBug575047_04() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Integer i) {\n"+
" return switch (i) {\n"+
" case null -> 2;\n"+
" case Integer i1 -> 0;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(null));\n"+
" System.out.println(foo(Integer.valueOf(0)));\n"+
" }\n"+
"}",
},
"2\n" +
"0");
}
public void testBug575047_05() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(float c) {\n"+
" switch (c) {\n" +
" case 0 : \n" +
" break;\n" +
" default :\n" +
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case 0 : \n" +
" ^\n" +
"Type mismatch: cannot convert from int to float\n" +
"----------\n");
}
public void testBug575047_06() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(String o) {\n"+
" return switch (o) {\n" +
" case String s && s.length() > 0 -> 3;\n" +
" case String s1 -> 1;\n" +
" case String s -> -1;\n"+
" };\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 6)\n" +
" case String s -> -1;\n" +
" ^^^^^^^^\n" +
"The switch statement cannot have more than one total pattern\n" +
"----------\n" +
"2. ERROR in X.java (at line 6)\n" +
" case String s -> -1;\n" +
" ^^^^^^^^\n" +
"This case label is dominated by one of the preceding case label\n" +
"----------\n");
}
// Test that when a literal is used as case constant
// we report type mismatch error against the literal's type and
// not on other types the case statement may have resolved too
public void testBug575047_07() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(Number i) {\n"+
" switch (i) {\n"+
" case Integer j, \"\":\n"+
" System.out.println(0);\n"+
" default:\n"+
" }\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer j, \"\":\n" +
" ^^\n" +
"Type mismatch: cannot convert from String to Number\n" +
"----------\n");
}
public void testBug575047_08() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(Integer i) {\n"+
" return switch (i) {\n"+
" case 0 -> 0;\n"+
" case Integer i1 -> i1;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(3));\n"+
" System.out.println(foo(0));\n"+
" }\n"+
"}",
},
"3\n"+
"0");
}
public void testBug575047_09() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static int foo(String i) {\n"+
" return switch (i) {\n"+
" case \"\" -> 0;\n"+
" case String s -> -1;\n"+
" };\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" System.out.println(foo(\"\"));\n"+
" System.out.println(foo(\"abc\"));\n"+
" }\n"+
"}",
},
"0\n" +
"-1");
}
public void testBug575047_10() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static String foo(Object o) {\n" +
" return switch (o) {\n" +
" case String i && i.length() == 0 -> \"empty\";\n" +
" case String i && i.length() > 0 -> \"zero+\";\n" +
" case Color s -> s.toString();\n" +
" default -> \"unknown\";\n" +
" };\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" System.out.println(foo(\"abc\"));\n" +
" System.out.println(foo(\"\"));\n" +
" System.out.println(Color.Blue);\n" +
" System.out.println(foo(args));\n" +
" }\n" +
"} \n" +
"enum Color {\n" +
" Blue, Red; \n" +
"}",
},
"zero+\n" +
"empty\n" +
"Blue\n" +
"unknown");
}
// Positive - Mix enum constants as well as suitable pattern var
public void testBug575047_11() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static String foo(Color o) {\n" +
" return switch (o) {\n" +
" case Red -> \"Red\";\n" +
" case Color s -> s.toString();\n" +
" };\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" System.out.println(Color.Red);\n" +
" System.out.println(Color.Blue);\n" +
" }\n" +
"} \n" +
"enum Color {\n" +
" Blue, Red; \n" +
"}",
},
"Red\n" +
"Blue");
}
public void testBug575047_12() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static String foo(Color o) {\n" +
" return switch (o) {\n" +
" case Red -> \"Red\";\n" +
" case Color s && s == Color.Blue -> s.toString();" +
" case Color s -> s.toString();\n" +
" };\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" System.out.println(Color.Red);\n" +
" System.out.println(Color.Blue);\n" +
" }\n" +
"} \n" +
"enum Color {\n" +
" Blue, Red; \n" +
"}",
},
"Red\n" +
"Blue");
}
public void testBug575047_13() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static String foo(Color o) {\n" +
" return switch (o) {\n" +
" case Color s && s == Color.Blue -> s.toString();" +
" case Red -> \"Red\";\n" +
" case null -> \"\";\n" +
" };\n" +
" }\n" +
"} \n" +
"enum Color {\n" +
" Blue, Red; \n" +
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 3)\n" +
" return switch (o) {\n" +
" ^\n" +
"A Switch expression should cover all possible values\n" +
"----------\n");
}
public void testBug575047_14() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static String foo(Color o) {\n" +
" return switch (o) {\n" +
" case Color s && s == Color.Blue -> s.toString();" +
" case Red -> \"Red\";\n" +
" };\n" +
" }\n" +
"} \n" +
"enum Color {\n" +
" Blue, Red; \n" +
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 3)\n" +
" return switch (o) {\n" +
" ^\n" +
"A Switch expression should cover all possible values\n" +
"----------\n");
}
public void testBug575047_15() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" static void foo(Integer o) {\n" +
" switch (o) {\n" +
" case 1: break;\n" +
" case Integer s && s == 2:\n" +
" System.out.println(s);break;\n" +
" case null, default:\n" +
" System.out.println(\"null/default\");\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" foo(null);\n" +
" }\n" +
"}",
},
"null/default");
}
public void testBug575360_001() {
runConformTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo(String myVar) { // String\n"+
" switch (myVar) {\n"+
" case null, default : System.out.println(\"hello\");\n"+
" }; \n"+
" }\n"+
" public static void main(String[] args) { \n"+
" foo(new String(\"Hello\")); \n"+
" }\n"+
"}",
},
"hello");
}
public void testBug575055_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" public int foo(CharSequence c) {\n" +
" return switch (c) {\n" +
" case CharSequence c1 && (c instanceof String c1 && c1.length() > 0) -> 0;\n" +
" default -> 0;\n" +
" };\n" +
" }" +
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case CharSequence c1 && (c instanceof String c1 && c1.length() > 0) -> 0;\n" +
" ^^\n" +
"Duplicate local variable c1\n" +
"----------\n");
}
// Fails with Javac as it prints Javac instead of throwing NPE
// https://bugs.openjdk.java.net/browse/JDK-8272776
public void testBug575051_1() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" public void foo(Object o) {\n" +
" try{\n" +
" switch (o) {\n" +
" default:\n" +
" break;\n" +
" case String s :\n" +
" System.out.println(s);\n" +
" } \n" +
" } catch(Exception t) {\n" +
" t.printStackTrace(System.out);\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" (new X()).foo(null);\n" +
" }\n" +
"}",
},
"java.lang.NullPointerException\n"
+ " at java.base/java.util.Objects.requireNonNull(Objects.java:208)\n"
+ " at X.foo(X.java:4)\n"
+ " at X.main(X.java:15)");
}
// Test we don't report any illegal fall-through to null case
public void testBug575051_2() {
runConformTest(
new String[] {
"X.java",
"public class X {\n" +
" public void foo(Object o) {\n" +
" switch (o) {\n" +
" case String s :\n" +
" System.out.println(s);\n" +
" //$FALL-THROUGH$\n" +
" case null:\n" +
" break;\n" +
" default : \n" +
" break;\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" (new X()).foo(null);\n" +
" }\n" +
"}",
},
"");
}
// Test we do report illegal fall-through to pattern
public void testBug575051_3() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n" +
" public void foo(Object o) {\n" +
" switch (o) {\n" +
" default : \n" +
" case String s :\n" +
" System.out.println();\n" +
" break;\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {\n" +
" (new X()).foo(null);\n" +
" }\n" +
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case String s :\n" +
" ^^^^^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n",
"");
}
public void testBug575571_1() {
Map<String, String> options = getCompilerOptions();
options.put(CompilerOptions.OPTION_ReportMissingDefaultCase, CompilerOptions.WARNING);
runWarningTest(
new String[] {
"X.java",
"public class X {\n" +
" public void foo(Color o) {\n" +
" switch (o) {\n" +
" case Blue:\n" +
" break;\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {}\n" +
"}\n" +
"enum Color { Blue; }\n",
},
"----------\n" +
"1. WARNING in X.java (at line 3)\n" +
" switch (o) {\n" +
" ^\n" +
"The switch over the enum type Color should have a default case\n" +
"----------\n",
options);
}
public void testBug575571_2() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n" +
" public void foo(Color o) {\n" +
" switch (o) {\n" +
" case Blue:\n" +
" case Color c:\n" +
" break;\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {}\n" +
"}\n" +
"enum Color { Blue, Red; }\n",
},
"----------\n" +
"1. ERROR in X.java (at line 5)\n" +
" case Color c:\n" +
" ^^^^^^^^^^^^\n" +
"Illegal fall-through to a pattern\n" +
"----------\n");
}
public void testBug575714_01() {
runNegativeTest(
new String[] {
"X.java",
"class X {\n"+
" static Object foo(Object o) {\n"+
" switch (o) {\n"+
" case Object __ -> throw new AssertionError(); \n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 8)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n");
}
public void testBug575714_02() {
runNegativeTest(
new String[] {
"X.java",
"class X {\n"+
" static Object foo(Object o) {\n"+
" switch (o) {\n"+
" case Object __ -> System.out.println(\"Hello\"); \n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" X.foo(new X());\n"+
" }\n"+
"}",
},
"----------\n" +
"1. ERROR in X.java (at line 2)\n" +
" static Object foo(Object o) {\n" +
" ^^^^^^^^^^^^^\n" +
"This method must return a result of type Object\n" +
"----------\n");
}
public void testBug575714_03() {
runConformTest(
new String[] {
"X.java",
"class X {\n"+
" static Object foo(Object o) {\n"+
" switch (o) {\n"+
" case Object __ -> System.out.println(\"Hello\"); \n"+
" }\n"+
" return null;\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" X.foo(new X());\n"+
" }\n"+
"}",
},
"Hello");
}
public void testBug575714_04() {
runConformTest(
new String[] {
"X.java",
"class X {\n"+
" static Object foo(Object o) throws Exception {\n"+
" switch (o) {\n"+
" case Object __ -> throw new Exception(); \n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" try {\n"+
" X.foo(new X());\n"+
" } catch (Exception e) {\n"+
" System.out.println(\"Hello\");\n"+
" }\n"+
" }\n"+
"}",
},
"Hello");
}
public void testBug575687_1() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n" +
" static void number(Number i) {\n" +
" switch (i) {\n" +
" case Integer i2, 4.5:\n" +
" case 4.3: System.out.println();\n" +
" default: System.out.println(\"nothing\");\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {}\n" +
"}\n" +
"enum Color { Blue, Red; }\n",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer i2, 4.5:\n" +
" ^^^\n" +
"Type mismatch: cannot convert from double to Number\n" +
"----------\n" +
"2. ERROR in X.java (at line 5)\n" +
" case 4.3: System.out.println();\n" +
" ^^^\n" +
"Type mismatch: cannot convert from double to Number\n" +
"----------\n");
}
public void testBug575686_1() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n" +
" void m(Object o) {\n" +
" switch (o) {\n" +
" case Integer i1, String s1 ->\n" +
" System.out.print(s1);\n" +
" default -> System.out.print(\"default\");\n" +
" case Number n, null ->\n" +
" System.out.print(o);\n" +
" case null, Class c ->\n" +
" System.out.print(o);\n" +
" }\n" +
" }\n" +
" public static void main(String[] args) {}\n" +
"}\n" +
"enum Color { Blue, Red; }\n",
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer i1, String s1 ->\n" +
" ^^^^^^^^^\n" +
"A switch label may not have more than one pattern case label element\n" +
"----------\n" +
"2. ERROR in X.java (at line 7)\n" +
" case Number n, null ->\n" +
" ^^^^\n" +
"Duplicate case\n" +
"----------\n" +
"3. ERROR in X.java (at line 9)\n" +
" case null, Class c ->\n" +
" ^^^^\n" +
"Duplicate case\n" +
"----------\n" +
"4. WARNING in X.java (at line 9)\n" +
" case null, Class c ->\n" +
" ^^^^^\n" +
"Class is a raw type. References to generic type Class<T> should be parameterized\n" +
"----------\n");
}
public void testBug575737_001() {
Map<String, String> options =getCompilerOptions();
options.put(CompilerOptions.OPTION_ReportPreviewFeatures, CompilerOptions.WARNING);
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo1(String o) {\n"+
" switch (o) {\n"+
" case null -> System.out.println(\"null\");\n"+
" case String s -> String.format(\"String %s\", s);\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. WARNING in X.java (at line 4)\n" +
" case null -> System.out.println(\"null\");\n" +
" ^^^^\n" +
"You are using a preview language feature that may or may not be supported in a future release\n" +
"----------\n" +
"2. WARNING in X.java (at line 5)\n" +
" case String s -> String.format(\"String %s\", s);\n" +
" ^^^^^^^^\n" +
"You are using a preview language feature that may or may not be supported in a future release\n" +
"----------\n" +
"3. ERROR in X.java (at line 9)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n",
null,
true,
options
);
}
public void testBug575737_002() {
Map<String, String> options =getCompilerOptions();
options.put(CompilerOptions.OPTION_ReportPreviewFeatures, CompilerOptions.INFO);
this.runNegativeTest(
new String[] {
"X.java",
"public class X {\n"+
" static void foo1(String o) {\n"+
" switch (o) {\n"+
" case null -> System.out.println(\"null\");\n"+
" case String s -> String.format(\"String %s\", s);\n"+
" }\n"+
" }\n"+
" public static void main(String[] args) {\n"+
" Zork();\n"+
" }\n"+
"}",
},
"----------\n" +
"1. INFO in X.java (at line 4)\n" +
" case null -> System.out.println(\"null\");\n" +
" ^^^^\n" +
"You are using a preview language feature that may or may not be supported in a future release\n" +
"----------\n" +
"2. INFO in X.java (at line 5)\n" +
" case String s -> String.format(\"String %s\", s);\n" +
" ^^^^^^^^\n" +
"You are using a preview language feature that may or may not be supported in a future release\n" +
"----------\n" +
"3. ERROR in X.java (at line 9)\n" +
" Zork();\n" +
" ^^^^\n" +
"The method Zork() is undefined for the type X\n" +
"----------\n",
null,
true,
options
);
}
public void testBug575738_001() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n" +
" private static void foo(Object o) {\n" +
" switch (o.hashCode()) {\n" +
" case int t: System.out.println(\"Integer\"); \n" +
" default : System.out.println(\"Object\"); \n" +
" }\n" +
" }\n" +
" public static void main(String[] args) { \n" +
" foo(\"Hello World\");\n" +
" }\n" +
"}"
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case int t: System.out.println(\"Integer\"); \n" +
" ^^^^^\n" +
"Unexpected type int, expected class or array type\n" +
"----------\n");
}
public void testBug575738_002() {
runNegativeTest(
new String[] {
"X.java",
"public class X {\n" +
" private static void foo(Object o) {\n" +
" switch (o.hashCode()) {\n" +
" case Integer t: System.out.println(\"Integer\"); \n" +
" default : System.out.println(\"Object\"); \n" +
" }\n" +
" }\n" +
" public static void main(String[] args) { \n" +
" foo(\"Hello World\");\n" +
" }\n" +
"}"
},
"----------\n" +
"1. ERROR in X.java (at line 4)\n" +
" case Integer t: System.out.println(\"Integer\"); \n" +
" ^^^^^^^^^\n" +
"Type mismatch: cannot convert from int to Integer\n" +
"----------\n");
}
}