jdk8-mips64-public/langtools: test/tools/javac/StringsInSwitch/OneCaseSwitches.java@8fb9b4be3cb1 (annotated)

test/tools/javac/StringsInSwitch/OneCaseSwitches.java@8fb9b4be3cb1 (annotated)

test/tools/javac/StringsInSwitch/OneCaseSwitches.java

Mon, 02 Nov 2009 21:36:59 -0800

author: darcy
date: Mon, 02 Nov 2009 21:36:59 -0800
changeset 430: 8fb9b4be3cb1
child 554: 9d9f26857129
permissions: -rw-r--r--

6827009: Project Coin: Strings in Switch
Reviewed-by: jjg, mcimadamore

 /*
  * Copyright 2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.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<String> stringSet, boolean expected) {
         int failures = 0;
         switch(s) {
         }
         return failures;
     }
     @TestMeForNull
     public static int zeroCasesWithDefault(String s, Set<String> 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<String> 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<String> 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<String> 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<String> 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<String> stringSet, boolean expected) {
         int failures = 1;
         switch(s) {
         case "foo":
             break;
         }
         failures = 0;
         return failures;
     }
     @TestMeForNull
     public static int oneCaseDefaultBreakOnly(String s, Set<String> 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<String> noDefaultSet = new HashSet<String>();
         Set<String> defaultSet   = new HashSet<String>();
         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<String> s = new HashSet<String>();
         s.add("foo");
         Set<String> fooSet = Collections.unmodifiableSet(s);
         Set<String> testSet   = new HashSet<String>();
         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<String> 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();
         }
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/StringsInSwitch/OneCaseSwitches.java@8fb9b4be3cb1 (annotated)

test/tools/javac/StringsInSwitch/OneCaseSwitches.java