diff -r 000000000000 -r 959103a6100f test/tools/javac/StringsInSwitch/OneCaseSwitches.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/StringsInSwitch/OneCaseSwitches.java Wed Apr 27 01:34:52 2016 +0800 @@ -0,0 +1,303 @@ +/* + * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 6827009 + * @summary Positive tests for strings in switch with few alternatives. + * @compile/fail -source 6 OneCaseSwitches.java + * @compile OneCaseSwitches.java + * @run main OneCaseSwitches + * @author Joseph D. Darcy + */ + +import java.lang.reflect.*; +import java.lang.annotation.*; +import java.util.*; +import static java.lang.annotation.RetentionPolicy.*; + +public class OneCaseSwitches { + @Retention(RUNTIME) + @interface TestMeForNull {} + + @TestMeForNull + public static int zeroCasesNoDefault(String s, Set stringSet, boolean expected) { + int failures = 0; + switch(s) { + } + return failures; + } + + @TestMeForNull + public static int zeroCasesWithDefault(String s, Set stringSet, boolean expected) { + int failures = 2; + boolean addResult; + + switch(s) { + default: + failures = 0; + addResult = stringSet.add(s); + if (addResult != expected) { + failures++; + System.err.println("zeroCaseWithDefault: Expectedly got add result of " + addResult + + " on string " + s); + } + } + + return failures; + } + + @TestMeForNull + public static int zeroCasesWithDefaultBreak(String s, Set stringSet, boolean expected) { + int failures = 2; + boolean addResult; + + switch(s) { + default: + failures = zeroCasesWithDefault(s, stringSet, expected); + break; + } + + return failures; + } + + @TestMeForNull + public static int oneCaseNoDefault(String s, Set stringSet, boolean expected) { + int failures = 2; + boolean addResult; + + switch(s) { + case "foo": + failures = 0; + addResult = stringSet.add(s); + if (addResult != expected) { + failures++; + System.err.println("oneCaseNoDefault: Unexpectedly got add result of " + addResult + + " on string " + s); + } + } + + return failures; + } + + @TestMeForNull + public static int oneCaseNoDefaultBreak(String s, Set stringSet, boolean expected) { + int failures = 2; + boolean addResult; + + switch(s) { + case "foo": + failures = oneCaseNoDefaultBreak(s, stringSet, expected); + break; + } + + return failures; + } + + @TestMeForNull + public static int oneCaseWithDefault(String s, Set stringSet, boolean expected) { + int failures = 2; + boolean addResult;; + + switch(s) { + case "foo": + failures = 0; + addResult = stringSet.add(s); + if (addResult != expected) { + failures++; + System.err.println("oneCaseNoDefault: Expectedly got add result of " + addResult + + " on string " + s); + } + break; + default: + break; + } + + return failures; + } + + @TestMeForNull + public static int oneCaseBreakOnly(String s, Set stringSet, boolean expected) { + int failures = 1; + switch(s) { + case "foo": + break; + } + failures = 0; + return failures; + } + + @TestMeForNull + public static int oneCaseDefaultBreakOnly(String s, Set stringSet, boolean expected) { + int failures = 1; + switch(s) { + default: + break; + } + failures = 0; + return failures; + } + + + static int testNullBehavior() { + int failures = 0; + int count = 0; + + Method[] methods = OneCaseSwitches.class.getDeclaredMethods(); + + try { + for(Method method : methods) { + count++; + try { + if (method.isAnnotationPresent(TestMeForNull.class)) { + System.out.println("Testing method " + method); + method.invoke(null, (String)null, emptyStringSet, false); + failures++; + System.err.println("Didn't get NPE as expected from " + method); + } + } catch (InvocationTargetException ite) { // Expected + Throwable targetException = ite.getTargetException(); + if (! (targetException instanceof NullPointerException)) { + failures++; // Wrong exception thrown + System.err.println("Didn't get expected target exception NPE, got " + + ite.getClass().getName()); + } + } + } + } catch (Exception e) { + throw new RuntimeException(e); + } + + if (count == 0) { + failures++; + System.err.println("Did not find any annotated methods."); + } + return failures; + } + + static int testZeroCases() { + int failures = 0; + Set noDefaultSet = new HashSet(); + Set defaultSet = new HashSet(); + + zeroCasesNoDefault(FOO, noDefaultSet, false); + for(String word : words) { + zeroCasesNoDefault(word, noDefaultSet, false); + } + + if (!noDefaultSet.isEmpty()) { + failures++; + System.err.println("Non-empty set after zeroCasesNoDefault"); + } + + for(String word : words) { + zeroCasesWithDefault(word, defaultSet, true); + } + if (defaultSet.size() != words.length) { + failures++; + System.err.println("Missing strings after zeroCasesWithDefault"); + } + + return failures; + } + + static int testOneCaseNoDefault() { + int failures = 0; + Set s = new HashSet(); + s.add("foo"); + Set fooSet = Collections.unmodifiableSet(s); + Set testSet = new HashSet(); + + oneCaseNoDefault(FOO, testSet, true); + if (!testSet.equals(fooSet)) { + failures++; + System.err.println("Unexpected result from oneCaseNoDefault: didn't get {\"Foo\"}"); + } + + for(String word : words) { + oneCaseNoDefault(word, testSet, false); + } + if (!testSet.equals(fooSet)) { + failures++; + System.err.println("Unexpected result from oneCaseNoDefault: didn't get {\"Foo\"}"); + } + + return failures; + } + + static int testBreakOnly() { + int failures = 0; + + for(String word : words) { + failures += oneCaseBreakOnly(word, emptyStringSet, true); + failures += oneCaseDefaultBreakOnly(word, emptyStringSet, true); + } + + return failures; + } + + static int testExpressionEval() { + String s = "a"; + int errors = 2; + + System.out.println("Testing expression evaluation."); + + switch (s + s) { + case "aa": + errors = 0; + break; + + case "aaaa": + errors = 1; + System.err.println("Suspected bad expression evaluation."); + break; + + default: + throw new RuntimeException("Should not reach here."); + } + return errors; + } + + static final String FOO = "foo"; + + static final String[] words = {"baz", + "quux", + "wombat", + "\u0ccc\u0012"}; // hash collision with "foo" + + final static Set emptyStringSet = Collections.emptySet(); + + public static void main(String... args) { + int failures = 0; + + failures += testNullBehavior(); + failures += testZeroCases(); + failures += testOneCaseNoDefault(); + failures += testBreakOnly(); + failures += testExpressionEval(); + + if (failures > 0) { + throw new RuntimeException(); + } + } +}