jdk8-mips64-public/langtools: test/tools/javac/types/GenericTypeWellFormednessTest.java@0ff2bbd38f10 (annotated)

test/tools/javac/types/GenericTypeWellFormednessTest.java@0ff2bbd38f10 (annotated)

test/tools/javac/types/GenericTypeWellFormednessTest.java

Wed, 06 Apr 2011 20:33:44 -0700

author: ohair
date: Wed, 06 Apr 2011 20:33:44 -0700
changeset 962: 0ff2bbd38f10
parent 821: c8d312dd17bc
child 2525: 2eb010b6cb22
permissions: -rw-r--r--

7033660: Update copyright year to 2011 on any files changed in 2011
Reviewed-by: dholmes

 /*
  * Copyright (c) 2010, 2011, 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 7007432 7006109
  * @summary Test generic types well-formedness
  * @author mcimadamore
  * @library .
  * @run main GenericTypeWellFormednessTest
  */
 import com.sun.tools.javac.code.BoundKind;
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.*;
 import java.lang.reflect.Array;
 /**
  * Check parameterized type well-formedness. This test executes a number of checks
  * in order to establish as to whether an instantiation of a generic type conforms
  * to the generic class' declared bounds.
  */
 public class GenericTypeWellFormednessTest extends TypeHarness {
     static int executedCount = 0;
     static int ignoredCount = 0;
     InstantiableType[] rows;
     Type[] columns;
     static class InstantiableType {
         protected Type type;
         public InstantiableType(Type type) {
             this.type = type;
         }
         Type inst(Type clazz) {
             return type;
         }
     }
     enum Result {
         /* generic type is well-formed w.r.t. declared bounds */
         OK(true),
         /* generic type is not well-formed w.r.t. declared bounds */
         FAIL(false),
         /* generic type is not well-formed w.r.t. declared bounds according to the JLS 3rd,
          * but javac allows it (spec for generic type well-formedness is overly restrictive)
          * See regression test test/tools/generics/wildcards/T5097548.java
          */
         IGNORE(false);
         boolean value;
         Result(boolean value) {
             this.value = value;
         }
     }
     static final Result T = Result.OK;
     static final Result F = Result.FAIL;
     static final Result I = Result.IGNORE;
     /*is a type in 'rows' a valid instantiation for the generic class in 'col' ? */
     Result[][] isValidInstantiation = {
                      //Foo<X>, Foo<X ext Object>, Foo<X ext Number>, Foo<X ext Foo<X>>, Foo<X ext Foo<+X>>, Foo<X ext Foo<-X>>, Foo<X ext Foo<?>>
     /*Foo<Object>*/  { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<Number>*/  { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<Integer>*/ { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<Double>*/  { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<String>*/  { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<X1>*/      { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<X2>*/      { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<X3>*/      { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<X4>*/      { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<X5>*/      { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<X6>*/      { T     , T                , F                , T                , T                 , T                 , T },
     /*Foo<+Object>*/ { T     , T                , I                , I                , I                 , I                 , I },
     /*Foo<+Number>*/ { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<+Integer>*/{ T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<+Double>*/ { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<+String>*/ { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<+X1>*/     { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<+X2>*/     { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<+X3>*/     { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<+X4>*/     { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<+X5>*/     { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<+X6>*/     { T     , T                , F                , T                , T                 , I                 , T },
     /*Foo<-Object>*/ { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<-Number>*/ { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<-Integer>*/{ T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<-Double>*/ { T     , T                , T                , F                , F                 , F                 , F },
     /*Foo<-String>*/ { T     , T                , F                , F                , F                 , F                 , F },
     /*Foo<-X1>*/     { T     , T                , I                , I                , I                 , I                 , I },
     /*Foo<-X2>*/     { T     , T                , I                , F                , F                 , F                 , F },
     /*Foo<-X3>*/     { T     , T                , I                , F                , F                 , F                 , F },
     /*Foo<-X4>*/     { T     , T                , I                , F                , F                 , F                 , F },
     /*Foo<-X5>*/     { T     , T                , I                , F                , F                 , F                 , F },
     /*Foo<-X6>*/     { T     , T                , F                , T                , I                 , I                 , T },
     /*Foo<?>*/       { T     , T                , T                , T                , T                 , T                 , T }};
     GenericTypeWellFormednessTest() {
         InstantiableType[] basicTypes = {
             new InstantiableType(predef.objectType),
             new InstantiableType(NumberType()),
             new InstantiableType(box(predef.intType)),
             new InstantiableType(box(predef.doubleType)),
             new InstantiableType(predef.stringType) };
         InstantiableType[] typeVars = new InstantiableType[basicTypes.length + 1];
         for (int i = 0 ; i < basicTypes.length ; i++) {
            typeVars[i] = new InstantiableType(fac.TypeVariable(basicTypes[i].type));
         }
         typeVars[typeVars.length - 1] = new InstantiableType(null) {
             Type inst(Type clazz) {
                 TypeVar tvar = fac.TypeVariable();
                 tvar.bound = subst(clazz, Mapping(clazz.getTypeArguments().head, tvar));
                 return tvar;
             }
         };
         InstantiableType[] typeArgs = join(InstantiableType.class, basicTypes, typeVars);
         InstantiableType[] invariantTypes = new InstantiableType[typeArgs.length];
         for (int i = 0 ; i < typeArgs.length ; i++) {
            final InstantiableType type1 = typeArgs[i];
            invariantTypes[i] = new InstantiableType(typeArgs[i].type) {
                Type inst(Type clazz) {
                    return subst(clazz, Mapping(clazz.getTypeArguments().head, type1.inst(clazz)));
                }
             };
         }
         InstantiableType[] covariantTypes = new InstantiableType[typeArgs.length];
         for (int i = 0 ; i < typeArgs.length ; i++) {
            final InstantiableType type1 = typeArgs[i];
            covariantTypes[i] = new InstantiableType(null) {
                Type inst(Type clazz) {
                    Type t = fac.Wildcard(BoundKind.EXTENDS, type1.inst(clazz));
                    return subst(clazz, Mapping(clazz.getTypeArguments().head, t));
                }
             };
         }
         InstantiableType[] contravariantTypes = new InstantiableType[typeArgs.length];
         for (int i = 0 ; i < typeArgs.length ; i++) {
            final InstantiableType type1 = typeArgs[i];
            contravariantTypes[i] = new InstantiableType(null) {
                Type inst(Type clazz) {
                    Type t = fac.Wildcard(BoundKind.SUPER, type1.inst(clazz));
                    return subst(clazz, Mapping(clazz.getTypeArguments().head, t));
                }
             };
         }
         InstantiableType[] bivariantTypes = {
             new InstantiableType(fac.Wildcard(BoundKind.UNBOUND, predef.objectType)) {
                Type inst(Type clazz) {
                    return subst(clazz, Mapping(clazz.getTypeArguments().head, type));
                }
             }
         };
         rows = join(InstantiableType.class, invariantTypes, covariantTypes, contravariantTypes, bivariantTypes);
         Type tv1 = fac.TypeVariable();
         Type decl1 = fac.Class(tv1);
         Type tv2 = fac.TypeVariable(predef.objectType);
         Type decl2 = fac.Class(tv2);
         Type tv3 = fac.TypeVariable(NumberType());
         Type decl3 = fac.Class(tv3);
         TypeVar tv4 = fac.TypeVariable();
         Type decl4 = fac.Class(tv4);
         tv4.bound = decl4;
         tv4.tsym.name = predef.exceptionType.tsym.name;
         TypeVar tv5 = fac.TypeVariable();
         Type decl5 = fac.Class(tv5);
         tv5.bound = subst(decl5, Mapping(tv5, fac.Wildcard(BoundKind.EXTENDS, tv5)));
         TypeVar tv6 = fac.TypeVariable();
         Type decl6 = fac.Class(tv6);
         tv6.bound = subst(decl6, Mapping(tv6, fac.Wildcard(BoundKind.SUPER, tv6)));
         TypeVar tv7 = fac.TypeVariable();
         Type decl7 = fac.Class(tv7);
         tv7.bound = subst(decl7, Mapping(tv7, fac.Wildcard(BoundKind.UNBOUND, predef.objectType)));
         columns = new Type[] {
             decl1, decl2, decl3, decl4, decl5, decl6, decl7
         };
     }
     void test() {
         for (int i = 0; i < rows.length ; i++) {
             for (int j = 0; j < columns.length ; j++) {
                 Type decl = columns[j];
                 Type inst = rows[i].inst(decl);
                 if (isValidInstantiation[i][j] != Result.IGNORE) {
                     executedCount++;
                     assertValidGenericType(inst, isValidInstantiation[i][j].value);
                 } else {
                     ignoredCount++;
                 }
             }
         }
     }
     Type NumberType() {
         Symbol s = box(predef.intType).tsym;
         s.complete();
         return ((ClassType)s.type).supertype_field;
     }
     @SuppressWarnings("unchecked")
     <T> T[] join(Class<T> type, T[]... args) {
         int totalLength = 0;
         for (T[] arr : args) {
             totalLength += arr.length;
         }
         T[] new_arr = (T[])Array.newInstance(type, totalLength);
         int idx = 0;
         for (T[] arr : args) {
             System.arraycopy(arr, 0, new_arr, idx, arr.length);
             idx += arr.length;
         }
         return new_arr;
     }
     public static void main(String[] args) {
         new GenericTypeWellFormednessTest().test();
         System.out.println("Executed checks : " + executedCount);
         System.out.println("Ignored checks : " + ignoredCount);
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/types/GenericTypeWellFormednessTest.java@0ff2bbd38f10 (annotated)

test/tools/javac/types/GenericTypeWellFormednessTest.java