jdk8-mips64-public/langtools: test/tools/javac/annotations/typeAnnotations/classfile/CombinationsTargetTest1.java@8e4c22acebeb (annotated)

test/tools/javac/annotations/typeAnnotations/classfile/CombinationsTargetTest1.java@8e4c22acebeb (annotated)

test/tools/javac/annotations/typeAnnotations/classfile/CombinationsTargetTest1.java

Thu, 31 Jan 2013 12:16:03 -0800

author: darcy
date: Thu, 31 Jan 2013 12:16:03 -0800
changeset 1531: 8e4c22acebeb
parent 1521: 71f35e4b93a5
child 1534: bec996065c45
permissions: -rw-r--r--

8007313: Remove use of {ContainerFor/ContainedBy} from langtools
Reviewed-by: jjg

 /*
  * Copyright (c) 2013 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 8005085 8005877 8004829 8005681 8006734 8006775
  * @ignore
  * @summary Combinations of Target ElementTypes on (repeated)type annotations.
  */
 import com.sun.tools.classfile.*;
 import java.io.File;
 public class CombinationsTargetTest1 extends ClassfileTestHelper {
     // Helps identify test case in event of failure.
     int testcount = 0;
     int src1 = 1, src2 = 2, src4 = 4,
         src5 = 5, src6 = 6, src7 = 7;
     String[] ETypes={"TYPE", "FIELD", "METHOD", "PARAMETER", "CONSTRUCTOR",
                      "LOCAL_VARIABLE", "ANNOTATION_TYPE", "PACKAGE"};
     // local class tests will have an inner class.
     Boolean hasInnerClass=false;
     String innerClassname="";
     public static void main(String[] args) throws Exception {
         new CombinationsTargetTest1().run();
     }
     void run() throws Exception {
         // Determines which repeat and order in source(ABMix).
         Boolean As= false, BDs=true, ABMix=false;
         int testrun=0;
         // A repeats and/or B/D repeats, ABMix for order of As and Bs.
         Boolean [][] bRepeat = new Boolean[][]{{false,false,false},//no repeats
                                                {true,false,false}, //repeat @A
                                                {false,true,false}, //repeat @B
                                                {true,true,false},  //repeat both
                                                {false,false,true}  //repeat mix
         };
         for(Boolean[] bCombo : bRepeat) {
             As=bCombo[0]; BDs=bCombo[1]; ABMix=bCombo[2];
             for(String et : ETypes) {
                switch(et) {
                    case "METHOD":
                        test( 8,  0, 2, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src1);
                        test(10,  0, 2, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src2);
                        test( 8,  0, 0, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src4);
                        test(10,  0, 2, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src6);
                        test( 0,  8, 0, 2, As, BDs, ABMix, "RUNTIME", et, ++testrun, src1);
                        test( 0, 10, 0, 2, As, BDs, ABMix, "RUNTIME", et, ++testrun, src2);
                        test( 0,  8, 0, 0, As, BDs, ABMix, "RUNTIME", et, ++testrun, src4);
                        test( 0, 10, 0, 2, As, BDs, ABMix, "RUNTIME", et, ++testrun, src6);
                        break;
                    case "CONSTRUCTOR":
                    case "FIELD":
                        test( 8,  0, 4, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src1);
                        test( 6,  0, 3, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src5);
                        test( 9,  0, 0, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src7);
                        test( 0,  8, 0, 4, As, BDs, ABMix, "RUNTIME", et, ++testrun, src1);
                        test( 0,  6, 0, 3, As, BDs, ABMix, "RUNTIME", et, ++testrun, src5);
                        test( 0,  9, 0, 0, As, BDs, ABMix, "RUNTIME", et, ++testrun, src7);
                        break;
                    default:/*TYPE,PARAMETER,LOCAL_VARIABLE,ANNOTATION_TYPE,PACKAGE*/
                        test( 8,  0, 2, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src1);
                        test( 6,  0, 3, 0, As, BDs, ABMix, "CLASS",   et, ++testrun, src5);
                        test( 0,  8, 0, 2, As, BDs, ABMix, "RUNTIME", et, ++testrun, src1);
                        test( 0,  6, 0, 3, As, BDs, ABMix, "RUNTIME", et, ++testrun, src5);
                }
             }
         }
     }
     public void test(int tinv, int tvis, int inv, int vis, Boolean Arepeats,
                      Boolean BDrepeats, Boolean ABmix, String rtn, String et2,
                      Integer N, int source) throws Exception {
         ++testcount;
         expected_tvisibles = tvis;
         expected_tinvisibles = tinv;
         expected_visibles = vis;
         expected_invisibles = inv;
         File testFile = null;
         String tname="Test" + N.toString();
         hasInnerClass=false;
         String testDef = "Test " + testcount + " parameters: tinv=" + tinv +
                 ", tvis=" + tvis + ", inv=" + inv + ", vis=" + vis +
                 ", Arepeats=" + Arepeats + ", BDrepeats=" + BDrepeats +
                 ", ABmix=" + ABmix + ", retention: " + rtn + ", anno2: " +
                 et2 + ", src=" + source;
         println(testDef);
         // Create test source and File.
         String sourceString = sourceString(tname, rtn, et2, Arepeats,
                                            BDrepeats, ABmix, source);
         testFile = writeTestFile(tname+".java", sourceString);
         // Compile test source and read classfile.
         File classFile = null;
         try {
             classFile = compile(testFile);
         } catch (Error err) {
             System.err.println("Failed compile. Source:\n" + sourceString);
             throw err;
         }
         //if sourcString() set hasInnerClass it also set innerClassname.
         if(hasInnerClass) {
             StringBuffer sb = new StringBuffer(classFile.getAbsolutePath());
             classFile=new File(sb.insert(sb.lastIndexOf(".class"),innerClassname).toString());
         }
         ClassFile cf = ClassFile.read(classFile);
         //Test class,fields and method counts.
         test(cf);
         for (Field f : cf.fields) {
             test(cf, f);
         }
         for (Method m: cf.methods) {
             test(cf, m);
         }
         countAnnotations();
         if (errors > 0) {
             System.err.println( testDef );
             System.err.println( "Source:\n" + sourceString );
             throw new Exception( errors + " errors found" );
         }
         println("Pass");
     }
     //
     // Source for test cases
     //
     String sourceString(String testname, String retentn, String annot2,
                         Boolean Arepeats, Boolean BDrepeats, Boolean ABmix,
                         int src) {
         String As = "@A", Bs = "@B", Ds = "@D";
         if(Arepeats) As = "@A @A";
         if(BDrepeats) {
             Bs = "@B @B";
             Ds = "@D @D";
         }
         if(ABmix) { As = "@A @B"; Bs = "@A @B"; Ds = "@D @D"; }
         // Source to check for TYPE_USE and TYPE_PARAMETER annotations.
         // Source base (annotations) is same for all test cases.
         String source = new String();
         String imports = new String("import java.lang.annotation.*; \n" +
             "import static java.lang.annotation.RetentionPolicy.*; \n" +
             "import static java.lang.annotation.ElementType.*; \n" +
             "import java.util.List; \n" +
             "import java.util.HashMap; \n" +
             "import java.util.Map; \n\n");
             String sourceBase = new String("@Retention("+retentn+")\n" +
             "@Target({TYPE_USE,_OTHER_})\n" +
             "@Repeatable( AC.class )\n" +
             "@interface A { }\n\n" +
             "@Retention("+retentn+")\n" +
             "@Target({TYPE_USE,_OTHER_})\n" +
             "@interface AC { A[] value(); }\n\n" +
             "@Retention("+retentn+")\n" +
             "@Target({TYPE_USE,_OTHER_})\n" +
             "@Repeatable( BC.class )\n" +
             "@interface B { }\n\n" +
             "@Retention("+retentn+")\n" +
             "@Target({TYPE_USE,_OTHER_})\n" +
             "@interface BC { B[] value(); } \n\n" +
             "@Retention("+retentn+")\n" +
             "@Target({TYPE_PARAMETER,_OTHER_})\n" +
             "@interface C { }\n\n" +
             "@Retention("+retentn+")\n" +
             "@Target({TYPE_USE,TYPE_PARAMETER,_OTHER_})\n" +
             "@Repeatable(DC.class)\n" +
             "@interface D { }\n\n" +
             "@Retention("+retentn+")\n" +
             "@Target({TYPE_USE,TYPE_PARAMETER,_OTHER_})\n" +
             "@interface DC { D[] value(); }\n\n");
         // Test case sources with sample generated source.
         switch(src) {
             case 1: // repeating type annotations at class level
                     /*
                      * @A @B class Test1 {
                      * @A @B Test1(){}
                      * @A @B Integer i1 = 0;
                      * String @A @B [] @A @B [] sa = null;
                      * // type usage in method body
                      * String test(Test1 this, String param, String ... vararg) {
                      *     Object o = new  String  [3];
                      *     return (String) null;
                      * }}
                      */
                 source = new String(
                 "// (repeating) type annotations at class level. \n" +
                 "_As_ _Bs_ class " + testname + " {\n" +
                 "_As_ _Bs_ " + testname +"(){} \n" +
                 "_As_ _Bs_ Integer i1 = 0; \n" +
                 "String _As_ _Bs_ [] _As_ _Bs_ [] sa = null; \n" +
                 "// type usage in method body \n" +
                 "String test("+testname+" this, " +
                    "String param, String ... vararg) { \n" +
                 "    Object o = new  String  [3]; \n" +
                 "    return (String) null; \n" +
                 "} \n" +
                 "} \n").concat(sourceBase).replace("_OTHER_", annot2).replace("_As_",As).replace("_Bs_",Bs) +
                 "\n\n";
                 break;
             case 2: // (repeating) type annotations on method.
                     /*
                      * class Test12 {
                      * Test12(){}
                      * // type usage on method
                      * @A @B String test(@A @B  Test12 this, @A @B  String param, @A @B  String @A @B  ... vararg) {
                      *     Object o = new String [3];
                      *     return (String) null;
                      * }}
                      */
                 source = new String(
                 "// (repeating) type annotations on method. \n" +
                 "class " + testname + " {\n" +
                 testname +"(){} \n" +
                 "// type usage on method \n" +
                 "_As_ _Bs_ String test(_As_ _Bs_  "+testname+" this, " +
                    "_As_ _Bs_  String param, _As_ _Bs_  String _As_ _Bs_  ... vararg) { \n" +
                 "    Object o = new String [3]; \n" +
                 "    return (String) null; \n" +
                 "} \n" +
                 "} \n").concat(sourceBase).replace("_OTHER_", annot2).replace("_As_",As).replace("_Bs_",Bs) +
                 "\n\n";
                 break;
             case 4: //(repeating) annotations on wildcard, type arguments in anonymous class.
                     /*
                      * class Test13<T extends Object> {
                      *     public T data = null;
                      *     T getData() { return data;}
                      *     String mtest( Test13<String> t){ return t.getData(); }
                      *     public void test() {
                      *         mtest( new Test13<@A @B String>() {
                      *                  void m1(List<@A @B ? extends @A @B  Object> lst) {}
                      *                  void m2() throws@A @B Exception { }
                      *                });
                      *     }
                      * }
                      */
                 source = new String( source +
                 "// (repeating) annotations on wildcard, type arguments in anonymous class. \n" +
                 "class " + testname + "<T extends Object> {\n" +
                 "    public T data = null;\n" +
                 "    T getData() { return data;}\n" +
                 "    String mtest( " + testname + "<String> t){ return t.getData(); }\n" +
                 "    public void test() {\n" +
                 "        mtest( new " + testname + "<_As_ _Bs_ String>() {\n" +
                 "                 void m1(List<_As_ _Bs_ ? extends _As_ _Bs_  Object> lst) {}\n" +
                 "                 void m2() throws_As_ _Bs_ Exception { }\n" +
                 "               });\n" +
                 "    }\n" +
                 "}\n").concat(sourceBase).replace("_OTHER_", annot2).replace("_As_",As).replace("_Bs_",Bs) + "\n\n";
                 hasInnerClass=true;
                 innerClassname="$1";
             break;
             case 5: // (repeating)annotations on type parameters, bounds and  type arguments on class decl.
                     /*
                      * @A @B @D
                      * class Test2<@A @B @C @D T extends @A @B Object> {
                      *     Map<List<String>, Integer> map =
                      *         new HashMap<List< String>, Integer>();
                      *     Map<List<String>,Integer> map2 = new HashMap<>();
                      *     String test(Test2<T> this) { return null;}
                      *     <T> String genericMethod(T t) { return null; }
                      * }
                      */
                 source = new String( source +
                 "// (repeating)annotations on type parameters, bounds and  type arguments on class decl. \n" +
                 "_As_ _Bs_ _Ds_\n" +  //8004829: A and B on type parameter below.
                 "class " + testname + "<_As_ _Bs_ @C _Ds_ T extends _As_ _Bs_ Object> {\n" +
                 "    Map<List<String>, Integer> map =\n" +
                 "        new HashMap<List< String>, Integer>();\n" +
                 "    Map<List<String>,Integer> map2 = new HashMap<>();\n" +
                 "    String test(" + testname + "<T> this) { return null;}\n" +
                 "    <T> String genericMethod(T t) { return null; }\n" +
                 "}\n").concat(sourceBase).replace("_OTHER_", annot2).replace("_As_",As).replace("_Bs_",Bs).replace("_Ds_",Ds) +
                 "\n\n";
             break;
             case 6: // (repeating) annotations on type parameters, bounds and  type arguments on method.
                     /*
                      * class Test14<T extends Object> {
                      *     Map<List<String>, Integer> map =
                      *         new HashMap<List<String>, Integer>();
                      *     Map<List<String>, Integer> map2 = new HashMap<>();
                      *     String test(@A @B Test14<@D T> this) { return null;}
                      *     <@C @D T> @A @B String genericMethod(@A @B @D T t) { return null; }
                      * }
                      */
                 source = new String( source +
                 "// (repeating) annotations on type parameters, bounds and  type arguments on method. \n" +
                 "class " + testname + "<T extends Object> {\n" +
                 "    Map<List<String>, Integer> map =\n" +
                 "        new HashMap<List<String>, Integer>();\n" +
                 "    Map<List<String>, Integer> map2 = new HashMap<>();\n" +
                 "    String test(_As_ _Bs_ " + testname + "<_Ds_ T> this) { return null;}\n" +
                 "    <@C _Ds_ T> _As_ _Bs_ String genericMethod(_As_ _Bs_ _Ds_ T t) { return null; }\n" +
                 "}\n").concat(sourceBase).replace("_OTHER_", annot2).replace("_As_",As).replace("_Bs_",Bs).replace("_Ds_",Ds) +
                 "\n\n";
             break;
             case 7: // repeating annotations on type parameters, bounds and  type arguments in method.
                     /*
                      * class Test7{
                      *     <E extends Comparable> Map<List<E>, E > foo(E e) {
                      *         class maptest <@A @B @D E> {
                      *             Map<List<@A @B @D E>,@A @B @D E> getMap() {
                      *                 return new HashMap<List<E>,E>();
                      *             }
                      *         }
                      *         return new maptest<E>().getMap();
                      *    }
                      *    Map<List<String>,String> shm = foo(new String("hello"));
                      * }
                      */
                 source = new String( source +
                 "// (repeating)annotations on type parameters of class, method return value in method. \n" +
                 "class "+ testname + "{\n" +
                 "    <E extends Comparable> Map<List<E>, E > foo(E e) {\n" +
                 "        class maptest <_As_ _Bs_ _Ds_ E> {\n" +                  // inner class $1maptest
                 "            Map<List<_As_ _Bs_ _Ds_ E>,_As_ _Bs_ _Ds_ E> getMap() { \n" +
                 "                return new HashMap<List<E>,E>();\n" +
                 "            }\n" +
                 "        }\n" +
                 "        return new maptest<E>().getMap();\n" +
                 "   }\n" +
                 "   Map<List<String>,String> shm = foo(new String(\"hello\"));\n" +
                 "}\n").concat(sourceBase).replace("_OTHER_", annot2).replace("_As_",As).replace("_Bs_",Bs).replace("_Ds_",Ds) +
                 "\n\n";
                 hasInnerClass=true;
                 innerClassname="$1maptest";
             break;
         }
         return imports + source;
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/annotations/typeAnnotations/classfile/CombinationsTargetTest1.java@8e4c22acebeb (annotated)

test/tools/javac/annotations/typeAnnotations/classfile/CombinationsTargetTest1.java