0001: /*
0002: * Licensed to the Apache Software Foundation (ASF) under one or more
0003: * contributor license agreements. See the NOTICE file distributed with
0004: * this work for additional information regarding copyright ownership.
0005: * The ASF licenses this file to You under the Apache License, Version 2.0
0006: * (the "License"); you may not use this file except in compliance with
0007: * the License. You may obtain a copy of the License at
0008: *
0009: * http://www.apache.org/licenses/LICENSE-2.0
0010: *
0011: * Unless required by applicable law or agreed to in writing, software
0012: * distributed under the License is distributed on an "AS IS" BASIS,
0013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014: * See the License for the specific language governing permissions and
0015: * limitations under the License.
0016: */
0017:
0018: /**
0019: * @author Serguei S.Zapreyev
0020: * @version $Revision$
0021: */package java.lang;
0022:
0023: /**
0024: * Area for supposed testing: top, member, local, enums, interfaces
0025: * - fields,
0026: * - methods
0027: * - constructors
0028: */
0029:
0030: import java.lang.reflect.*;
0031:
0032: import java.lang.annotation.Retention;
0033: import java.lang.annotation.RetentionPolicy;
0034:
0035: import junit.framework.TestCase;
0036:
0037: /*
0038: * Created on April 03, 2006
0039: *
0040: * This ClassGenericsTest class is used to test the Core API Class, Method, Constructor, Field classes
0041: *
0042: */
0043:
0044: /**
0045: * ###############################################################################
0046: * ###############################################################################
0047: * TODO: 1.
0048: * ###############################################################################
0049: * ###############################################################################
0050: */
0051:
0052: @Retention(value=RetentionPolicy.RUNTIME)
0053: @interface igt {
0054: abstract String author() default "Zapreyev";
0055: };
0056:
0057: @SuppressWarnings(value={"unchecked"})
0058: public class ClassGenericsTest<X> extends TestCase {
0059: @igt
0060: class Mc001 {
0061: };
0062:
0063: protected void setUp() throws Exception {
0064: }
0065:
0066: protected void tearDown() throws Exception {
0067: }
0068:
0069: /**
0070: * getTypeParameters(), getGenericInterfaces(), getGenericSuperclass() of non-generalized member class
0071: */
0072: public void test_1() {
0073: if (Mc001.class.getTypeParameters().length != 0)
0074: fail("test_1, case 001 FAILED: "
0075: + Mc001.class.getTypeParameters());
0076: if (Mc001.class.getGenericInterfaces().length != 0)
0077: fail("test_1, case 002 FAILED: "
0078: + Mc001.class.getGenericInterfaces());
0079: if (!Mc001.class.getGenericSuperclass().equals(Object.class))
0080: fail("test_1, case 003 FAILED: "
0081: + Mc001.class.getGenericSuperclass());
0082: }
0083:
0084: /**
0085: * getTypeParameters(), getGenericInterfaces(), getGenericSuperclass() of generalized member class
0086: */
0087: @igt
0088: interface MI001<T0 extends java.io.Serializable> {
0089: };
0090:
0091: @igt
0092: interface MI002<T1 extends MI001> {
0093: };
0094:
0095: @igt
0096: interface MI003<T2> extends MI001 {
0097: };
0098:
0099: @igt
0100: interface MI004<T2> /*extends MI001<MI001>*/{
0101: @igt
0102: interface MI005<T21, T22> /*extends MI003<MI002>*/{
0103: };
0104: };
0105:
0106: @igt(author="Serguei Stepanovich Zapreyev")
0107: public class Mc002<T3 extends ClassGenericsTest> {
0108: @igt
0109: public class Mc004<T5 extends ClassGenericsTest> {
0110: };
0111: };
0112:
0113: @igt
0114: class Mc003<T4 extends Thread & java.io.Serializable & Cloneable>
0115: extends
0116: java.lang.ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>
0117: implements MI002<MI003<java.io.Serializable>>,
0118: MI003<MI003<Cloneable>>,
0119: MI004.MI005<Type, Type> {
0120: };
0121:
0122: /**/@igt
0123: class Mc007\u0391<T7 extends Thread & java.io.Serializable & Cloneable> {
0124: };
0125:
0126: /**/@igt
0127: class Mc008\u0576\u06C0\u06F10<T8 extends Mc007? & java.io.Serializable & Cloneable>
0128: extends
0129: java.lang.ClassGenericsTest<? super Mc007?>.Mc002<ClassGenericsTest>
0130: implements MI002<MI003<java.io.Serializable>>,
0131: MI003<MI003<Cloneable>>, MI004.MI005<Mc007?, Type> {
0132: };
0133:
0134: /**/@igt
0135: class Mc010\u0576\u06C0\u06F10 {
0136: };
0137:
0138: /**/@igt
0139: interface MI010\u0576\u06C0\u06F10 {
0140: };
0141:
0142: /**/@igt
0143: class MC011\u0576\u06C0\u06F10 extends Mc010???0
0144: implements MI010???0 {
0145: };
0146:
0147: public void test_2() {
0148: //ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<ClassGenericsTest> f1;
0149: Type ap[];
0150: TypeVariable tv;
0151: Type ab[];
0152: Type ai[];
0153: Type aa[];
0154: Type aa2[];
0155: Type oc;
0156: WildcardType wc;
0157: Type aa3[];
0158:
0159: ap = Mc003.class.getTypeParameters();
0160: if (ap.length != 1)
0161: fail("test_2, case 001 FAILED: " + ap.length);
0162: tv = (TypeVariable) ap[0];
0163: if (!tv.getName().equals("T4"))
0164: fail("test_2, case 002 FAILED: " + tv.getName());
0165: if (!((Class) tv.getGenericDeclaration()).getName().equals(
0166: "java.lang.ClassGenericsTest$Mc003"))
0167: fail("test_2, case 003 FAILED: "
0168: + ((Class) tv.getGenericDeclaration()).getName());
0169: ab = tv.getBounds();
0170: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
0171: fail("test_2, case 004 FAILED: "
0172: + ((Class) ab[0]).getName());
0173: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
0174: fail("test_2, case 005 FAILED: "
0175: + ((Class) ab[1]).getName());
0176: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
0177: fail("test_2, case 006 FAILED: "
0178: + ((Class) ab[2]).getName());
0179: //////////////////////////////////////////////////////////////////////////////////////////////
0180: ai = Mc003.class.getGenericInterfaces();
0181: if (ai.length != 3)
0182: fail("test_2, case 007 FAILED: " + ai.length);
0183: if (!((Class) ((ParameterizedType) ai[0]).getRawType())
0184: .getName().equals("java.lang.ClassGenericsTest$MI002"))
0185: fail("test_2, case 008 FAILED: "
0186: + ((Class) ((ParameterizedType) ai[0]).getRawType())
0187: .getName());
0188: if (!((Class) ((ParameterizedType) ai[0]).getOwnerType())
0189: .getName().equals("java.lang.ClassGenericsTest"))
0190: fail("test_2, case 009 FAILED: "
0191: + ((Class) ((ParameterizedType) ai[0])
0192: .getOwnerType()).getName());
0193: aa = ((ParameterizedType) ai[0]).getActualTypeArguments();
0194: if (aa.length != 1)
0195: fail("test_2, case 010 FAILED: " + aa.length);
0196: if (!((Class) ((ParameterizedType) aa[0]).getRawType())
0197: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0198: fail("test_2, case 011 FAILED: "
0199: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0200: .getName());
0201: if (!((Class) ((ParameterizedType) aa[0]).getOwnerType())
0202: .getName().equals("java.lang.ClassGenericsTest"))
0203: fail("test_2, case 012 FAILED: "
0204: + ((Class) ((ParameterizedType) aa[0])
0205: .getOwnerType()).getName());
0206: aa2 = ((ParameterizedType) aa[0]).getActualTypeArguments(); //java.io.Serializable
0207: if (aa2.length != 1)
0208: fail("test_2, case 013 FAILED: " + aa.length);
0209: if (!((Class) aa2[0]).getName().equals("java.io.Serializable"))
0210: fail("test_2, case 014 FAILED: "
0211: + ((Class) ((ParameterizedType) aa2[0])
0212: .getRawType()).getName());
0213:
0214: if (!((Class) ((ParameterizedType) ai[1]).getRawType())
0215: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0216: fail("test_2, case 015 FAILED: "
0217: + ((Class) ((ParameterizedType) ai[1]).getRawType())
0218: .getName());
0219: if (!((Class) ((ParameterizedType) ai[1]).getOwnerType())
0220: .getName().equals("java.lang.ClassGenericsTest"))
0221: fail("test_2, case 016 FAILED: "
0222: + ((Class) ((ParameterizedType) ai[1])
0223: .getOwnerType()).getName());
0224: aa = ((ParameterizedType) ai[1]).getActualTypeArguments();
0225: if (aa.length != 1)
0226: fail("test_2, case 017 FAILED: " + aa.length);
0227: if (!((Class) ((ParameterizedType) aa[0]).getRawType())
0228: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0229: fail("test_2, case 018 FAILED: "
0230: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0231: .getName());
0232: if (!((Class) ((ParameterizedType) aa[0]).getOwnerType())
0233: .getName().equals("java.lang.ClassGenericsTest"))
0234: fail("test_2, case 019 FAILED: "
0235: + ((Class) ((ParameterizedType) aa[0])
0236: .getOwnerType()).getName());
0237: aa2 = ((ParameterizedType) aa[0]).getActualTypeArguments(); //java.lang.Cloneable
0238: if (aa2.length != 1)
0239: fail("test_2, case 020 FAILED: " + aa.length);
0240: if (!((Class) aa2[0]).getName().equals("java.lang.Cloneable"))
0241: fail("test_2, case 021 FAILED: "
0242: + ((Class) ((ParameterizedType) aa2[0])
0243: .getRawType()).getName());
0244:
0245: if (!((Class) ((ParameterizedType) ai[2]).getRawType())
0246: .getName().equals(
0247: "java.lang.ClassGenericsTest$MI004$MI005"))
0248: fail("test_2, case 022 FAILED: "
0249: + ((Class) ((ParameterizedType) ai[2]).getRawType())
0250: .getName());
0251: if (!((Class) ((ParameterizedType) ai[2]).getOwnerType())
0252: .getName().equals("java.lang.ClassGenericsTest$MI004"))
0253: fail("test_2, case 023 FAILED: "
0254: + ((Class) ((ParameterizedType) ai[2])
0255: .getOwnerType()).getName());
0256: aa = ((ParameterizedType) ai[2]).getActualTypeArguments();
0257: if (aa.length != 2)
0258: fail("test_2, case 002 FAILED: " + aa.length);
0259: if (!((Class) aa[0]).getName().equals("java.lang.reflect.Type"))
0260: fail("test_2, case 024 FAILED: "
0261: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0262: .getName());
0263: if (!((Class) aa[1]).getName().equals("java.lang.reflect.Type"))
0264: fail("test_2, case 025 FAILED: "
0265: + ((Class) ((ParameterizedType) aa[1]).getRawType())
0266: .getName());
0267:
0268: //////////////////////////////////////////////////////////////////////////////////////////////
0269: if (!(Mc003.class.getGenericSuperclass() instanceof java.lang.reflect.ParameterizedType))
0270: fail("test_2, case 026 FAILED: "
0271: + Mc003.class.getGenericSuperclass());
0272: if (!((Class) ((ParameterizedType) Mc003.class
0273: .getGenericSuperclass()).getRawType())
0274: .equals(Mc002.class))
0275: fail("test_2, case 027 FAILED: "
0276: + Mc003.class.getGenericSuperclass());
0277: if (!((igt) ((Class) ((ParameterizedType) Mc003.class
0278: .getGenericSuperclass()).getRawType()).getAnnotations()[0])
0279: .author().equals("Serguei Stepanovich Zapreyev"))
0280: fail("test_2, case 028 FAILED: "
0281: + ((igt) ((Class) ((ParameterizedType) Mc003.class
0282: .getGenericSuperclass()).getRawType())
0283: .getAnnotations()[0]).author());
0284: aa = ((ParameterizedType) Mc003.class.getGenericSuperclass())
0285: .getActualTypeArguments();
0286: if (aa.length != 1)
0287: fail("test_2, case 029 FAILED: " + aa.length);
0288: if (!((Class) aa[0]).getName().equals(
0289: "java.lang.ClassGenericsTest"))
0290: fail("test_2, case 030 FAILED: " + aa[0]);
0291: oc = ((ParameterizedType) Mc003.class.getGenericSuperclass())
0292: .getOwnerType();
0293: if (!((Class) ((ParameterizedType) oc).getRawType())
0294: .equals(java.lang.ClassGenericsTest.class))
0295: fail("test_2, case 031 FAILED: "
0296: + Mc003.class.getGenericSuperclass());
0297: if (((ParameterizedType) oc).getOwnerType() != null)
0298: fail("test_2, case 032 FAILED: "
0299: + ((ParameterizedType) oc).getOwnerType());
0300: aa = ((ParameterizedType) oc).getActualTypeArguments();
0301: if (aa.length != 1)
0302: fail("test_2, case 033 FAILED: " + aa.length);
0303: wc = (WildcardType) aa[0];
0304: aa3 = wc.getLowerBounds();
0305: if (aa3.length != 1)
0306: fail("test_2, case 034 FAILED: " + aa3.length);
0307: if (!((Class) aa3[0]).equals(Class.class))
0308: fail("test_2, case 035 FAILED: " + ((Class) aa3[0]));
0309: aa3 = wc.getUpperBounds();
0310: if (aa3.length != 1)
0311: fail("test_2, case 036 FAILED: " + aa3.length);
0312: if (!((Class) aa3[0]).equals(Object.class))
0313: fail("test_2, case 037 FAILED: " + ((Class) aa3[0]));
0314: ////////////////////////////////////////////////////////////////////////////////////////////////////
0315: ////////////////////////////////////////////////////////////////////////////////////////////////////
0316: ////////////////////////////////////////////////////////////////////////////////////////////////////
0317: ap = Mc007?.class.getTypeParameters();
0318: if (ap.length != 1)
0319: fail("test_2, case 038 FAILED: " + ap.length);
0320: tv = (TypeVariable) ap[0];
0321: if (!tv.getName().equals("T7"))
0322: fail("test_2, case 039 FAILED: " + tv.getName());
0323: if (!((Class) tv.getGenericDeclaration()).getName().equals(
0324: "java.lang.ClassGenericsTest$Mc007\u0391"))
0325: fail("test_2, case 040 FAILED: "
0326: + ((Class) tv.getGenericDeclaration()).getName());
0327: ab = tv.getBounds();
0328: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
0329: fail("test_2, case 041 FAILED: "
0330: + ((Class) ab[0]).getName());
0331: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
0332: fail("test_2, case 042 FAILED: "
0333: + ((Class) ab[1]).getName());
0334: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
0335: fail("test_2, case 043 FAILED: "
0336: + ((Class) ab[2]).getName());
0337: //////////////////////////////////////////////////////////////////////////////////////////////
0338: ai = Mc007?.class.getGenericInterfaces();
0339: if (ai.length != 0)
0340: fail("test_2, case 001 FAILED: " + ap.length);
0341: //////////////////////////////////////////////////////////////////////////////////////////////
0342: if (!(Mc007?.class.getGenericSuperclass() instanceof java.lang.Object))
0343: fail("test_2, case 044 FAILED: "
0344: + Mc003.class.getGenericSuperclass());
0345: ////////////////////////////////////////////////////////////////////////////////////////////////////
0346: ////////////////////////////////////////////////////////////////////////////////////////////////////
0347: ////////////////////////////////////////////////////////////////////////////////////////////////////
0348: ap = Mc008???0.class.getTypeParameters();
0349: if (ap.length != 1)
0350: fail("test_2, case 045 FAILED: " + ap.length);
0351: tv = (TypeVariable) ap[0];
0352: if (!tv.getName().equals("T8"))
0353: fail("test_2, case 046 FAILED: " + tv.getName());
0354: if (!((Class) tv.getGenericDeclaration()).getName().equals(
0355: "java.lang.ClassGenericsTest$Mc008\u0576\u06C0\u06F10"))
0356: fail("test_2, case 047 FAILED: "
0357: + ((Class) tv.getGenericDeclaration()).getName());
0358: ab = tv.getBounds();
0359: if (!((Class) ab[0]).getName().equals(
0360: "java.lang.ClassGenericsTest$Mc007\u0391"))
0361: fail("test_2, case 048 FAILED: "
0362: + ((Class) ab[0]).getName());
0363: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
0364: fail("test_2, case 049 FAILED: "
0365: + ((Class) ab[1]).getName());
0366: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
0367: fail("test_2, case 050 FAILED: "
0368: + ((Class) ab[2]).getName());
0369: //////////////////////////////////////////////////////////////////////////////////////////////
0370: ai = Mc008???0.class.getGenericInterfaces();
0371: if (ai.length != 3)
0372: fail("test_2, case 051 FAILED: " + ai.length);
0373: if (!((Class) ((ParameterizedType) ai[0]).getRawType())
0374: .getName().equals("java.lang.ClassGenericsTest$MI002"))
0375: fail("test_2, case 052 FAILED: "
0376: + ((Class) ((ParameterizedType) ai[0]).getRawType())
0377: .getName());
0378: if (!((Class) ((ParameterizedType) ai[0]).getOwnerType())
0379: .getName().equals("java.lang.ClassGenericsTest"))
0380: fail("test_2, case 053 FAILED: "
0381: + ((Class) ((ParameterizedType) ai[0])
0382: .getOwnerType()).getName());
0383: aa = ((ParameterizedType) ai[0]).getActualTypeArguments();
0384: if (aa.length != 1)
0385: fail("test_2, case 054 FAILED: " + aa.length);
0386: if (!((Class) ((ParameterizedType) aa[0]).getRawType())
0387: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0388: fail("test_2, case 055 FAILED: "
0389: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0390: .getName());
0391: if (!((Class) ((ParameterizedType) aa[0]).getOwnerType())
0392: .getName().equals("java.lang.ClassGenericsTest"))
0393: fail("test_2, case 056 FAILED: "
0394: + ((Class) ((ParameterizedType) aa[0])
0395: .getOwnerType()).getName());
0396: aa2 = ((ParameterizedType) aa[0]).getActualTypeArguments(); //java.io.Serializable
0397: if (aa2.length != 1)
0398: fail("test_2, case 057 FAILED: " + aa.length);
0399: if (!((Class) aa2[0]).getName().equals("java.io.Serializable"))
0400: fail("test_2, case 058 FAILED: "
0401: + ((Class) ((ParameterizedType) aa2[0])
0402: .getRawType()).getName());
0403:
0404: if (!((Class) ((ParameterizedType) ai[1]).getRawType())
0405: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0406: fail("test_2, case 059 FAILED: "
0407: + ((Class) ((ParameterizedType) ai[1]).getRawType())
0408: .getName());
0409: if (!((Class) ((ParameterizedType) ai[1]).getOwnerType())
0410: .getName().equals("java.lang.ClassGenericsTest"))
0411: fail("test_2, case 060 FAILED: "
0412: + ((Class) ((ParameterizedType) ai[1])
0413: .getOwnerType()).getName());
0414: aa = ((ParameterizedType) ai[1]).getActualTypeArguments();
0415: if (aa.length != 1)
0416: fail("test_2, case 061 FAILED: " + aa.length);
0417: if (!((Class) ((ParameterizedType) aa[0]).getRawType())
0418: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0419: fail("test_2, case 062 FAILED: "
0420: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0421: .getName());
0422: if (!((Class) ((ParameterizedType) aa[0]).getOwnerType())
0423: .getName().equals("java.lang.ClassGenericsTest"))
0424: fail("test_2, case 063 FAILED: "
0425: + ((Class) ((ParameterizedType) aa[0])
0426: .getOwnerType()).getName());
0427: aa2 = ((ParameterizedType) aa[0]).getActualTypeArguments(); //java.lang.Cloneable
0428: if (aa2.length != 1)
0429: fail("test_2, case 064 FAILED: " + aa.length);
0430: if (!((Class) aa2[0]).getName().equals("java.lang.Cloneable"))
0431: fail("test_2, case 065 FAILED: "
0432: + ((Class) ((ParameterizedType) aa2[0])
0433: .getRawType()).getName());
0434:
0435: if (!((Class) ((ParameterizedType) ai[2]).getRawType())
0436: .getName().equals(
0437: "java.lang.ClassGenericsTest$MI004$MI005"))
0438: fail("test_2, case 066 FAILED: "
0439: + ((Class) ((ParameterizedType) ai[2]).getRawType())
0440: .getName());
0441: if (!((Class) ((ParameterizedType) ai[2]).getOwnerType())
0442: .getName().equals("java.lang.ClassGenericsTest$MI004"))
0443: fail("test_2, case 067 FAILED: "
0444: + ((Class) ((ParameterizedType) ai[2])
0445: .getOwnerType()).getName());
0446: aa = ((ParameterizedType) ai[2]).getActualTypeArguments();
0447: if (aa.length != 2)
0448: fail("test_2, case 068 FAILED: " + aa.length);
0449: if (!((Class) aa[0]).getName().equals(
0450: "java.lang.ClassGenericsTest$Mc007\u0391"))
0451: fail("test_2, case 069 FAILED: "
0452: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0453: .getName());
0454: if (!((Class) aa[1]).getName().equals("java.lang.reflect.Type"))
0455: fail("test_2, case 070 FAILED: "
0456: + ((Class) ((ParameterizedType) aa[1]).getRawType())
0457: .getName());
0458:
0459: //////////////////////////////////////////////////////////////////////////////////////////////
0460: if (!(Mc008???0.class.getGenericSuperclass() instanceof java.lang.reflect.ParameterizedType))
0461: fail("test_2, case 071 FAILED: "
0462: + Mc003.class.getGenericSuperclass());
0463: if (!((Class) ((ParameterizedType) Mc008???0.class
0464: .getGenericSuperclass()).getRawType())
0465: .equals(Mc002.class))
0466: fail("test_2, case 072 FAILED: "
0467: + Mc003.class.getGenericSuperclass());
0468: if (!((igt) ((Class) ((ParameterizedType) Mc008???0.class
0469: .getGenericSuperclass()).getRawType()).getAnnotations()[0])
0470: .author().equals("Serguei Stepanovich Zapreyev"))
0471: fail("test_2, case 073 FAILED: "
0472: + ((igt) ((Class) ((ParameterizedType) Mc003.class
0473: .getGenericSuperclass()).getRawType())
0474: .getAnnotations()[0]).author());
0475: aa = ((ParameterizedType) Mc008???0.class
0476: .getGenericSuperclass()).getActualTypeArguments();
0477: if (aa.length != 1)
0478: fail("test_2, case 074 FAILED: " + aa.length);
0479: System.out.println(aa[0]);
0480: if (!((Class) aa[0]).getName().equals(
0481: "java.lang.ClassGenericsTest"))
0482: fail("test_2, case 075 FAILED: "
0483: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0484: .getName());
0485: oc = ((ParameterizedType) Mc008???0.class
0486: .getGenericSuperclass()).getOwnerType();
0487: if (!((Class) ((ParameterizedType) oc).getRawType())
0488: .equals(java.lang.ClassGenericsTest.class))
0489: fail("test_2, case 076 FAILED: "
0490: + Mc003.class.getGenericSuperclass());
0491: if (((ParameterizedType) oc).getOwnerType() != null)
0492: fail("test_2, case 077 FAILED: "
0493: + ((ParameterizedType) oc).getOwnerType());
0494: aa = ((ParameterizedType) oc).getActualTypeArguments();
0495: if (aa.length != 1)
0496: fail("test_2, case 078 FAILED: " + aa.length);
0497: wc = (WildcardType) aa[0];
0498: aa3 = wc.getLowerBounds();
0499: if (aa3.length != 1)
0500: fail("test_2, case 079 FAILED: " + aa3.length);
0501: if (!((Class) aa3[0]).equals(Mc007?.class))
0502: fail("test_2, case 080 FAILED: " + ((Class) aa3[0]));
0503: aa3 = wc.getUpperBounds();
0504: if (aa3.length != 1)
0505: fail("test_2, case 081 FAILED: " + aa3.length);
0506: if (!((Class) aa3[0]).equals(Object.class))
0507: fail("test_2, case 082 FAILED: " + ((Class) aa3[0]));
0508: ////////////////////////////////////////////////////////////////////////////////////////////////////
0509: ////////////////////////////////////////////////////////////////////////////////////////////////////
0510: ////////////////////////////////////////////////////////////////////////////////////////////////////
0511: //if (RuntimeAdditionalSupport1.openingFlag) {
0512: ap = MC011???0.class.getTypeParameters();
0513: if (ap.length != 0)
0514: fail("test_2, case 083 FAILED: " + ap.length);
0515: //////////////////////////////////////////////////////////////////////////////////////////////
0516: ai = MC011???0.class.getGenericInterfaces();
0517: if (ai.length != 1)
0518: fail("test_2, case 084 FAILED: " + ai.length);
0519: if (!((Class) ai[0]).getName().equals(
0520: "java.lang.ClassGenericsTest$MI010\u0576\u06C0\u06F10"))
0521: fail("test_2, case 085 FAILED: "
0522: + ((Class) ai[0]).getName());
0523: //////////////////////////////////////////////////////////////////////////////////////////////
0524: if (!((Class) MC011???0.class
0525: .getGenericSuperclass()).getName().equals(
0526: "java.lang.ClassGenericsTest$Mc010\u0576\u06C0\u06F10"))
0527: fail("test_2, case 086 FAILED: "
0528: + ((Class) Mc008???0.class
0529: .getGenericSuperclass()).getName());
0530: //}
0531:
0532: }
0533:
0534: /**
0535: * getGenericType() of generalized type fields
0536: */
0537: class Mc005 extends Thread implements java.io.Serializable,
0538: Cloneable {
0539: private static final long serialVersionUID = 0L;
0540: };
0541:
0542: public Mc003<Mc005> fld0;
0543: public ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<ClassGenericsTest> f0;
0544: public X f111;
0545: public ClassGenericsTest f112;
0546:
0547: public void test_3() {
0548: Type ft = null;
0549: try {
0550: ft = java.lang.ClassGenericsTest.class.getField("fld0")
0551: .getGenericType();
0552: //{boolean b = true; if(b) return;}
0553: } catch (NoSuchFieldException e) {
0554: fail("test_3, case 001 FAILED: ");
0555: }
0556: Type oc1 = (ParameterizedType) ft;
0557: if (!((Class) ((ParameterizedType) oc1).getRawType())
0558: .equals(java.lang.ClassGenericsTest.Mc003.class))
0559: fail("test_3, case 002 FAILED: "
0560: + ((Class) ((ParameterizedType) oc1).getRawType()));
0561: if (RuntimeAdditionalSupport1.openingFlag) {
0562: if (!((ParameterizedType) oc1).getOwnerType().toString()
0563: .equals("java.lang.ClassGenericsTest<X>"))
0564: fail("test_3, case 003 FAILED: "
0565: + ((ParameterizedType) oc1).getOwnerType()
0566: .toString());
0567: }
0568: Type aa0[] = ((ParameterizedType) oc1).getActualTypeArguments();
0569: if (aa0.length != 1)
0570: fail("test_3, case 004 FAILED: " + aa0.length);
0571: if (!((ParameterizedType) aa0[0]).getRawType().equals(
0572: Mc005.class))
0573: fail("test_3, case 005 FAILED: " + (/*(Class)*/aa0[0]));
0574: if (!((ParameterizedType) aa0[0]).getOwnerType().toString()
0575: .equals("java.lang.ClassGenericsTest<X>"))
0576: fail("test_3, case 006 FAILED: " + (/*(Class)*/aa0[0]));
0577:
0578: Class c = (Class) ((ParameterizedType) ft).getRawType();
0579:
0580: Type ap[] = c.getTypeParameters();
0581: if (ap.length != 1)
0582: fail("test_3, case 007 FAILED: " + ap.length);
0583: TypeVariable tv = (TypeVariable) ap[0];
0584: if (!tv.getName().equals("T4"))
0585: fail("test_3, case 008 FAILED: " + tv.getName());
0586: if (!((Class) tv.getGenericDeclaration()).getName().equals(
0587: "java.lang.ClassGenericsTest$Mc003"))
0588: fail("test_3, case 009 FAILED: "
0589: + ((Class) tv.getGenericDeclaration()).getName());
0590: Type ab[] = tv.getBounds();
0591: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
0592: fail("test_3, case 010 FAILED: "
0593: + ((Class) ab[0]).getName());
0594: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
0595: fail("test_3, case 011 FAILED: "
0596: + ((Class) ab[1]).getName());
0597: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
0598: fail("test_3, case 012 FAILED: "
0599: + ((Class) ab[2]).getName());
0600: //////////////////////////////////////////////////////////////////////////////////////////////
0601: Type ai[] = c.getGenericInterfaces();
0602: if (ai.length != 3)
0603: fail("test_3, case 013 FAILED: " + ai.length);
0604: if (!((Class) ((ParameterizedType) ai[0]).getRawType())
0605: .getName().equals("java.lang.ClassGenericsTest$MI002"))
0606: fail("test_3, case 014 FAILED: "
0607: + ((Class) ((ParameterizedType) ai[0]).getRawType())
0608: .getName());
0609: if (!((Class) ((ParameterizedType) ai[0]).getOwnerType())
0610: .getName().equals("java.lang.ClassGenericsTest"))
0611: fail("test_3, case 015 FAILED: "
0612: + ((Class) ((ParameterizedType) ai[0])
0613: .getOwnerType()).getName());
0614: Type aa[] = ((ParameterizedType) ai[0])
0615: .getActualTypeArguments();
0616: if (aa.length != 1)
0617: fail("test_3, case 016 FAILED: " + aa.length);
0618: if (!((Class) ((ParameterizedType) aa[0]).getRawType())
0619: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0620: fail("test_3, case 017 FAILED: "
0621: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0622: .getName());
0623: if (!((Class) ((ParameterizedType) aa[0]).getOwnerType())
0624: .getName().equals("java.lang.ClassGenericsTest"))
0625: fail("test_3, case 018 FAILED: "
0626: + ((Class) ((ParameterizedType) aa[0])
0627: .getOwnerType()).getName());
0628: Type aa2[] = ((ParameterizedType) aa[0])
0629: .getActualTypeArguments(); //java.io.Serializable
0630: if (aa2.length != 1)
0631: fail("test_3, case 019 FAILED: " + aa.length);
0632: if (!((Class) aa2[0]).getName().equals("java.io.Serializable"))
0633: fail("test_3, case 020 FAILED: "
0634: + ((Class) ((ParameterizedType) aa2[0])
0635: .getRawType()).getName());
0636:
0637: if (!((Class) ((ParameterizedType) ai[1]).getRawType())
0638: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0639: fail("test_3, case 021 FAILED: "
0640: + ((Class) ((ParameterizedType) ai[1]).getRawType())
0641: .getName());
0642: if (!((Class) ((ParameterizedType) ai[1]).getOwnerType())
0643: .getName().equals("java.lang.ClassGenericsTest"))
0644: fail("test_3, case 022 FAILED: "
0645: + ((Class) ((ParameterizedType) ai[1])
0646: .getOwnerType()).getName());
0647: aa = ((ParameterizedType) ai[1]).getActualTypeArguments();
0648: if (aa.length != 1)
0649: fail("test_3, case 023 FAILED: " + aa.length);
0650: if (!((Class) ((ParameterizedType) aa[0]).getRawType())
0651: .getName().equals("java.lang.ClassGenericsTest$MI003"))
0652: fail("test_3, case 024 FAILED: "
0653: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0654: .getName());
0655: if (!((Class) ((ParameterizedType) aa[0]).getOwnerType())
0656: .getName().equals("java.lang.ClassGenericsTest"))
0657: fail("test_3, case 025 FAILED: "
0658: + ((Class) ((ParameterizedType) aa[0])
0659: .getOwnerType()).getName());
0660: aa2 = ((ParameterizedType) aa[0]).getActualTypeArguments(); //java.lang.Cloneable
0661: if (aa2.length != 1)
0662: fail("test_3, case 026 FAILED: " + aa.length);
0663: if (!((Class) aa2[0]).getName().equals("java.lang.Cloneable"))
0664: fail("test_3, case 027 FAILED: "
0665: + ((Class) ((ParameterizedType) aa2[0])
0666: .getRawType()).getName());
0667:
0668: if (!((Class) ((ParameterizedType) ai[2]).getRawType())
0669: .getName().equals(
0670: "java.lang.ClassGenericsTest$MI004$MI005"))
0671: fail("test_3, case 028 FAILED: "
0672: + ((Class) ((ParameterizedType) ai[2]).getRawType())
0673: .getName());
0674: if (!((Class) ((ParameterizedType) ai[2]).getOwnerType())
0675: .getName().equals("java.lang.ClassGenericsTest$MI004"))
0676: fail("test_3, case 029 FAILED: "
0677: + ((Class) ((ParameterizedType) ai[2])
0678: .getOwnerType()).getName());
0679: aa = ((ParameterizedType) ai[2]).getActualTypeArguments();
0680: if (aa.length != 2)
0681: fail("test_3, case 030 FAILED: " + aa.length);
0682: if (!((Class) aa[0]).getName().equals("java.lang.reflect.Type"))
0683: fail("test_3, case 031 FAILED: "
0684: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0685: .getName());
0686: if (!((Class) aa[1]).getName().equals("java.lang.reflect.Type"))
0687: fail("test_3, case 032 FAILED: "
0688: + ((Class) ((ParameterizedType) aa[1]).getRawType())
0689: .getName());
0690:
0691: //////////////////////////////////////////////////////////////////////////////////////////////
0692: if (!(c.getGenericSuperclass() instanceof java.lang.reflect.ParameterizedType))
0693: fail("test_3, case 033 FAILED: "
0694: + Mc003.class.getGenericSuperclass());
0695: if (!((Class) ((ParameterizedType) c.getGenericSuperclass())
0696: .getRawType()).equals(Mc002.class))
0697: fail("test_3, case 034 FAILED: "
0698: + Mc003.class.getGenericSuperclass());
0699: if (!((igt) ((Class) ((ParameterizedType) c
0700: .getGenericSuperclass()).getRawType()).getAnnotations()[0])
0701: .author().equals("Serguei Stepanovich Zapreyev"))
0702: fail("test_3, case 035 FAILED: "
0703: + ((igt) ((Class) ((ParameterizedType) Mc003.class
0704: .getGenericSuperclass()).getRawType())
0705: .getAnnotations()[0]).author());
0706: aa = ((ParameterizedType) c.getGenericSuperclass())
0707: .getActualTypeArguments();
0708: if (aa.length != 1)
0709: fail("test_3, case 029 FAILED: " + aa.length);
0710: if (!((Class) aa[0]).getName().equals(
0711: "java.lang.ClassGenericsTest"))
0712: fail("test_3, case 036 FAILED: "
0713: + ((Class) ((ParameterizedType) aa[0]).getRawType())
0714: .getName());
0715: Type oc = ((ParameterizedType) c.getGenericSuperclass())
0716: .getOwnerType();
0717: if (!((Class) ((ParameterizedType) oc).getRawType())
0718: .equals(java.lang.ClassGenericsTest.class))
0719: fail("test_3, case 037 FAILED: "
0720: + Mc003.class.getGenericSuperclass());
0721: if (((ParameterizedType) oc).getOwnerType() != null)
0722: fail("test_3, case 038 FAILED: "
0723: + ((ParameterizedType) oc).getOwnerType());
0724: aa = ((ParameterizedType) oc).getActualTypeArguments();
0725: if (aa.length != 1)
0726: fail("test_3, case 039 FAILED: " + aa.length);
0727: WildcardType wc = (WildcardType) aa[0];
0728: Type aa3[] = wc.getLowerBounds();
0729: if (aa3.length != 1)
0730: fail("test_3, case 040 FAILED: " + aa3.length);
0731: if (!((Class) aa3[0]).equals(Class.class))
0732: fail("test_3, case 041 FAILED: " + ((Class) aa3[0]));
0733: aa3 = wc.getUpperBounds();
0734: if (aa3.length != 1)
0735: fail("test_3, case 042 FAILED: " + aa3.length);
0736: if (!((Class) aa3[0]).equals(Object.class))
0737: fail("test_3, case 043 FAILED: " + ((Class) aa3[0]));
0738:
0739: //////////////////////////////////////////////////////////////////////////////////////////////
0740: try {
0741: ft = java.lang.ClassGenericsTest.class.getField("f0")
0742: .getGenericType();
0743: } catch (NoSuchFieldException e) {
0744: fail("test_3, case 044 FAILED: ");
0745: }
0746: oc1 = (ParameterizedType) ft;
0747: if (!((Class) ((ParameterizedType) oc1).getRawType())
0748: .equals(java.lang.ClassGenericsTest.Mc002.Mc004.class))
0749: fail("test_3, case 045 FAILED: "
0750: + ((Class) ((ParameterizedType) oc1).getRawType()));
0751: if (!((ParameterizedType) oc1)
0752: .getOwnerType()
0753: .toString()
0754: .equals(
0755: "java.lang.ClassGenericsTest<? super java.lang.Class>.Mc002<java.lang.ClassGenericsTest>"))
0756: fail("test_3, case 046 FAILED: "
0757: + ((ParameterizedType) oc1).getOwnerType()
0758: .toString());
0759: aa0 = ((ParameterizedType) oc1).getActualTypeArguments();
0760: if (aa0.length != 1)
0761: fail("test_3, case 047 FAILED: " + aa0.length);
0762: if (!((Class) aa0[0]).equals(ClassGenericsTest.class))
0763: fail("test_3, case 048 FAILED: " + (/*(Class)*/aa0[0]));
0764:
0765: if (!((Class) ((ParameterizedType) ((ParameterizedType) oc1)
0766: .getOwnerType()).getRawType())
0767: .equals(java.lang.ClassGenericsTest.Mc002.class))
0768: fail("test_3, case 049 FAILED: "
0769: + ((Class) ((ParameterizedType) oc1).getRawType()));
0770: aa0 = ((ParameterizedType) ((ParameterizedType) oc1)
0771: .getOwnerType()).getActualTypeArguments();
0772: if (aa0.length != 1)
0773: fail("test_3, case 050 FAILED: " + aa0.length);
0774: if (!((Class) aa0[0]).equals(ClassGenericsTest.class))
0775: fail("test_3, case 051 FAILED: " + (/*(Class)*/aa0[0]));
0776: if (!((ParameterizedType) ((ParameterizedType) oc1)
0777: .getOwnerType()).getOwnerType().toString().equals(
0778: "java.lang.ClassGenericsTest<? super java.lang.Class>"))
0779: fail("test_3, case 052 FAILED: "
0780: + ((Class) ((ParameterizedType) oc1).getRawType()));
0781: if (!((Class) ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
0782: .getOwnerType()).getOwnerType()).getRawType())
0783: .equals(java.lang.ClassGenericsTest.class))
0784: fail("test_3, case 053 FAILED: "
0785: + ((Class) ((ParameterizedType) oc1).getRawType()));
0786:
0787: aa0 = ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
0788: .getOwnerType()).getOwnerType())
0789: .getActualTypeArguments();
0790: if (aa0.length != 1)
0791: fail("test_3, case 054 FAILED: " + aa0.length);
0792: wc = (WildcardType) aa[0];
0793: aa3 = wc.getLowerBounds();
0794: if (aa3.length != 1)
0795: fail("test_3, case 055 FAILED: " + aa3.length);
0796: if (!((Class) aa3[0]).equals(Class.class))
0797: fail("test_3, case 056 FAILED: " + ((Class) aa3[0]));
0798: aa3 = wc.getUpperBounds();
0799: if (aa3.length != 1)
0800: fail("test_3, case 057 FAILED: " + aa3.length);
0801: if (!((Class) aa3[0]).equals(Object.class))
0802: fail("test_3, case 058 FAILED: " + ((Class) aa3[0]));
0803: ////////////////////////////////////////////////////////////////////////////////////////////////////
0804: try {
0805: ft = java.lang.ClassGenericsTest.class.getField("f111")
0806: .getGenericType();
0807: } catch (NoSuchFieldException e) {
0808: fail("test_3, case 059 FAILED: ");
0809: }
0810: tv = (TypeVariable) ft;
0811: if (!tv.getName().equals("X"))
0812: fail("test_3, case 060 FAILED: " + tv.getName());
0813: if (!((Class) tv.getGenericDeclaration()).getName().equals(
0814: "java.lang.ClassGenericsTest"))
0815: fail("test_3, case 061 FAILED: "
0816: + ((Class) tv.getGenericDeclaration()).getName());
0817: ab = tv.getBounds();
0818: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
0819: fail("test_3, case 062 FAILED: "
0820: + ((Class) ab[0]).getName());
0821: }
0822:
0823: /**
0824: * getGenericType() of non-generalized fields
0825: */
0826: public void test_4() {
0827: Type ft = null;
0828: try {
0829: ft = java.lang.ClassGenericsTest.class.getField("f112")
0830: .getGenericType();
0831: } catch (NoSuchFieldException e) {
0832: fail("test_4, case 001 FAILED: ");
0833: }
0834: if (!((Class) ft).getName().equals(
0835: "java.lang.ClassGenericsTest"))
0836: fail("test_4, case 002 FAILED: " + ((Class) ft).getName());
0837: }
0838:
0839: /**
0840: * getGenericExceptionTypes(), getGenericParameterTypes(), getGenericReturnType(), getTypeParameters(), toGenericString() of generalized method
0841: */
0842: static class Mc009\u0576\u06C0\u06F1 extends Throwable implements
0843: java.io.Serializable, Cloneable {
0844: private static final long serialVersionUID = 0L;
0845: };
0846:
0847: /* + */@igt(author = "*****")
0848: public <UuUuU extends Throwable, TM1, TM2 extends Thread & java.io.Serializable & Cloneable> void foo1For_5(
0849: UuUuU a1) throws UuUuU, java.io.IOException {
0850: }
0851:
0852: /* + */public <\u0391 extends Throwable, TM1, TM2, TM3, TM4, TM5, TM6, TM7> X foo2For_5()
0853: throws \u0391, java.io.IOException {
0854: X f = null;
0855: return f;
0856: }
0857:
0858: /* + */public <\u0576\u06C0\u06F1 extends Throwable, \u0576\u06C0\u06F11 extends Throwable, \u0576\u06C0\u06F12 extends Throwable, \u0576\u06C0\u06F13 extends Throwable, TM1, TM2 extends Thread & java.io.Serializable & Cloneable> TM2 foo3For_5(
0859: ???[] BAAB,
0860: TM1 a1,
0861: TM2 a2,
0862: ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<ClassGenericsTest> a3)
0863: throws \u0576\u06C0\u06F1, Throwable, \u0576\u06C0\u06F13,
0864: \u0576\u06C0\u06F12, \u0576\u06C0\u06F11,
0865: java.lang.ClassGenericsTest.Mc009\u0576\u06C0\u06F1 {
0866: TM2 f = null;
0867: return f;
0868: }
0869:
0870: /* + */public Mc003<Mc005> foo4For_5(
0871: ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<?> a1,
0872: @igt(author="Czar")
0873: Mc003<Mc005> a2, @igt(author="President")
0874: Mc003<Mc005>... a3) {
0875: return a2;
0876: }
0877:
0878: ///* + */ public void foo4For_5(ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<?> a1, @igt(author="Czar") Mc003<Mc005> a2, @igt(author="President") Mc003<Mc005> ... a3) {}
0879: /* - */public ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<ClassGenericsTest> foo5For_5(
0880: X a1,
0881: Class<Type> a2,
0882: ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<ClassGenericsTest> a3) {
0883: return a3;
0884: }
0885:
0886: public void test_5() {
0887: Type rt;
0888: TypeVariable tv;
0889: ParameterizedType oc1;
0890: Type aa0[];
0891: Type ap[];
0892: Type ab[];
0893: Type aet[];
0894: Type atp[];
0895: Type aa3[];
0896: GenericArrayType gat;
0897: WildcardType wc;
0898: Method m = null;
0899: try {
0900: //m = ClassGenericsTest.class.getMethod("foo1For_5");
0901: java.lang.reflect.Method am[] = ClassGenericsTest.class
0902: .getDeclaredMethods();
0903: for (int i = 0; i < am.length; i++) {
0904: if (am[i].getName().equals("foo1For_5")) {
0905: m = am[i];
0906: }
0907: }
0908: //if(aa.length!=5) fail("test_5, case 0 FAILED: "+aa.length);
0909:
0910: if (!((igt) m.getAnnotation(igt.class)).author().equals(
0911: "*****"))
0912: fail("test_3, case 001 FAILED: "
0913: + ((igt) m.getAnnotation(igt.class)).author());
0914: } catch (Exception e) {
0915: fail("test_5, case 002 FAILED: " + e.toString());
0916: }
0917: rt = m.getGenericReturnType();
0918: if (!((Class) rt).getName().equals("void"))
0919: fail("test_5, case 003 FAILED: " + ((Class) rt).getName());
0920: ///////
0921: atp = m.getTypeParameters();
0922: if (atp.length != 3)
0923: fail("test_5, case 004 FAILED: " + atp.length);
0924: tv = (TypeVariable) atp[0];
0925: if (!tv.getName().equals("UuUuU"))
0926: fail("test_5, case 005 FAILED: " + tv.getName());
0927: if (!((Method) tv.getGenericDeclaration()).getName().equals(
0928: "foo1For_5"))
0929: fail("test_5, case 006 FAILED: "
0930: + ((Method) tv.getGenericDeclaration()).getName());
0931: ab = tv.getBounds();
0932: if (ab.length != 1)
0933: fail("test_5, case 007 FAILED: " + ab.length);
0934: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
0935: fail("test_5, case 008 FAILED: "
0936: + ((Class) ab[0]).getName());
0937: tv = (TypeVariable) atp[1];
0938: if (!tv.getName().equals("TM1"))
0939: fail("test_5, case 009 FAILED: " + tv.getName());
0940: if (!((Method) tv.getGenericDeclaration()).getName().equals(
0941: "foo1For_5"))
0942: fail("test_5, case 010 FAILED: "
0943: + ((Method) tv.getGenericDeclaration()).getName());
0944: ab = tv.getBounds();
0945: if (ab.length != 1)
0946: fail("test_5, case 011 FAILED: " + ab.length);
0947: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
0948: fail("test_5, case 012 FAILED: "
0949: + ((Class) ab[0]).getName());
0950: tv = (TypeVariable) atp[2];
0951: if (!tv.getName().equals("TM2"))
0952: fail("test_5, case 013 FAILED: " + tv.getName());
0953: if (!((Method) tv.getGenericDeclaration()).getName().equals(
0954: "foo1For_5"))
0955: fail("test_5, case 014 FAILED: "
0956: + ((Method) tv.getGenericDeclaration()).getName());
0957: ab = tv.getBounds();
0958: if (ab.length != 3)
0959: fail("test_5, case 015 FAILED: " + ab.length);
0960: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
0961: fail("test_5, case 016 FAILED: "
0962: + ((Class) ab[0]).getName());
0963: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
0964: fail("test_5, case 017 FAILED: "
0965: + ((Class) ab[1]).getName());
0966: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
0967: fail("test_5, case 018 FAILED: "
0968: + ((Class) ab[2]).getName());
0969: ///////
0970: ap = m.getGenericParameterTypes();
0971: if (ap.length != 1)
0972: fail("test_5, case 019 FAILED: " + ap.length);
0973: tv = (TypeVariable) ap[0];
0974: if (!tv.getName().equals("UuUuU"))
0975: fail("test_5, case 020 FAILED: " + tv.getName());
0976: ///////
0977: aet = m.getGenericExceptionTypes();
0978: if (aet.length != 2)
0979: fail("test_5, case 021 FAILED: " + ap.length);
0980: tv = (TypeVariable) aet[0];
0981: if (!tv.getName().equals("UuUuU"))
0982: fail("test_5, case 022 FAILED: " + tv.getName());
0983: if (!((Class) aet[1]).getName().equals("java.io.IOException"))
0984: fail("test_5, case 023 FAILED: "
0985: + ((Class) aet[1]).getName());
0986: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
0987: m = null;
0988: try {
0989: java.lang.reflect.Method am[] = ClassGenericsTest.class
0990: .getDeclaredMethods();
0991: for (int i = 0; i < am.length; i++) {
0992: if (am[i].getName().equals("foo2For_5")) {
0993: m = am[i];
0994: }
0995: }
0996: //if(!((igt)m.getAnnotation(igt.class)).author().equals("*****")) fail("test_3, case 003 FAILED: "+((igt)m.getAnnotation(igt.class)).author());
0997: } catch (Exception e) {
0998: fail("test_5, case 024 FAILED: " + e.toString());
0999: }
1000: rt = m.getGenericReturnType();
1001: tv = ((TypeVariable) rt);
1002: if (!tv.getName().equals("X"))
1003: fail("test_5, case 025 FAILED: " + ((Class) rt).getName());
1004: if (!((Class) tv.getGenericDeclaration()).getName().equals(
1005: "java.lang.ClassGenericsTest"))
1006: fail("test_5, case 026 FAILED: "
1007: + ((Method) tv.getGenericDeclaration()).getName());
1008: ///////
1009: atp = m.getTypeParameters();
1010: if (atp.length != 8)
1011: fail("test_5, case 027 FAILED: " + atp.length);
1012: tv = (TypeVariable) atp[0];
1013: if (!tv.getName().equals("\u0391"))
1014: fail("test_5, case 028 FAILED: " + tv.getName());
1015: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1016: "foo2For_5"))
1017: fail("test_5, case 028 FAILED: "
1018: + ((Method) tv.getGenericDeclaration()).getName());
1019: ab = tv.getBounds();
1020: if (ab.length != 1)
1021: fail("test_5, case 030 FAILED: " + ab.length);
1022: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1023: fail("test_5, case 031 FAILED: "
1024: + ((Class) ab[0]).getName());
1025: tv = (TypeVariable) atp[1];
1026: if (!tv.getName().equals("TM1"))
1027: fail("test_5, case 032 FAILED: " + tv.getName());
1028: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1029: "foo2For_5"))
1030: fail("test_5, case 033 FAILED: "
1031: + ((Method) tv.getGenericDeclaration()).getName());
1032: ab = tv.getBounds();
1033: if (ab.length != 1)
1034: fail("test_5, case 034 FAILED: " + ab.length);
1035: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1036: fail("test_5, case 035 FAILED: "
1037: + ((Class) ab[0]).getName());
1038: tv = (TypeVariable) atp[2];
1039: if (!tv.getName().equals("TM2"))
1040: fail("test_5, case 036 FAILED: " + tv.getName());
1041: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1042: "foo2For_5"))
1043: fail("test_5, case 037 FAILED: "
1044: + ((Method) tv.getGenericDeclaration()).getName());
1045: ab = tv.getBounds();
1046: if (ab.length != 1)
1047: fail("test_5, case 038 FAILED: " + ab.length);
1048: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1049: fail("test_5, case 039 FAILED: "
1050: + ((Class) ab[0]).getName());
1051: tv = (TypeVariable) atp[3];
1052: if (!tv.getName().equals("TM3"))
1053: fail("test_5, case 040 FAILED: " + tv.getName());
1054: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1055: "foo2For_5"))
1056: fail("test_5, case 041 FAILED: "
1057: + ((Method) tv.getGenericDeclaration()).getName());
1058: ab = tv.getBounds();
1059: if (ab.length != 1)
1060: fail("test_5, case 042 FAILED: " + ab.length);
1061: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1062: fail("test_5, case 043 FAILED: "
1063: + ((Class) ab[0]).getName());
1064: tv = (TypeVariable) atp[4];
1065: if (!tv.getName().equals("TM4"))
1066: fail("test_5, case 044 FAILED: " + tv.getName());
1067: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1068: "foo2For_5"))
1069: fail("test_5, case 045 FAILED: "
1070: + ((Method) tv.getGenericDeclaration()).getName());
1071: ab = tv.getBounds();
1072: if (ab.length != 1)
1073: fail("test_5, case 046 FAILED: " + ab.length);
1074: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1075: fail("test_5, case 047 FAILED: "
1076: + ((Class) ab[0]).getName());
1077: tv = (TypeVariable) atp[5];
1078: if (!tv.getName().equals("TM5"))
1079: fail("test_5, case 048 FAILED: " + tv.getName());
1080: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1081: "foo2For_5"))
1082: fail("test_5, case 049 FAILED: "
1083: + ((Method) tv.getGenericDeclaration()).getName());
1084: ab = tv.getBounds();
1085: if (ab.length != 1)
1086: fail("test_5, case 050 FAILED: " + ab.length);
1087: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1088: fail("test_5, case 051 FAILED: "
1089: + ((Class) ab[0]).getName());
1090: tv = (TypeVariable) atp[6];
1091: if (!tv.getName().equals("TM6"))
1092: fail("test_5, case 052 FAILED: " + tv.getName());
1093: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1094: "foo2For_5"))
1095: fail("test_5, case 053 FAILED: "
1096: + ((Method) tv.getGenericDeclaration()).getName());
1097: ab = tv.getBounds();
1098: if (ab.length != 1)
1099: fail("test_5, case 054 FAILED: " + ab.length);
1100: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1101: fail("test_5, case 055 FAILED: "
1102: + ((Class) ab[0]).getName());
1103: tv = (TypeVariable) atp[7];
1104: if (!tv.getName().equals("TM7"))
1105: fail("test_5, case 056 FAILED: " + tv.getName());
1106: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1107: "foo2For_5"))
1108: fail("test_5, case 057 FAILED: "
1109: + ((Method) tv.getGenericDeclaration()).getName());
1110: ab = tv.getBounds();
1111: if (ab.length != 1)
1112: fail("test_5, case 058 FAILED: " + ab.length);
1113: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1114: fail("test_5, case 059 FAILED: "
1115: + ((Class) ab[0]).getName());
1116: ///////
1117: ap = m.getGenericParameterTypes();
1118: if (ap.length != 0)
1119: fail("test_5, case 060 FAILED: " + ap.length);
1120: //tv = (TypeVariable)ap[0];
1121: //if(!tv.getName().equals("UuUuU")) fail("test_5, case 003 FAILED: "+tv.getName());
1122: ///////
1123: aet = m.getGenericExceptionTypes();
1124: if (aet.length != 2)
1125: fail("test_5, case 061 FAILED: " + ap.length);
1126: tv = (TypeVariable) aet[0];
1127: if (!tv.getName().equals("\u0391"))
1128: fail("test_5, case 062 FAILED: " + tv.getName());
1129: if (!((Class) aet[1]).getName().equals("java.io.IOException"))
1130: fail("test_5, case 063 FAILED: "
1131: + ((Class) aet[1]).getName());
1132: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1133: m = null;
1134: try {
1135: java.lang.reflect.Method am[] = ClassGenericsTest.class
1136: .getDeclaredMethods();
1137: for (int i = 0; i < am.length; i++) {
1138: if (am[i].getName().equals("foo3For_5")) {
1139: m = am[i];
1140: }
1141: }
1142: //if(!((igt)m.getAnnotation(igt.class)).author().equals("*****")) fail("test_3, case 003 FAILED: "+((igt)m.getAnnotation(igt.class)).author());
1143: } catch (Exception e) {
1144: fail("test_5, case 064 FAILED: " + e.toString());
1145: }
1146: rt = m.getGenericReturnType();
1147: tv = ((TypeVariable) rt);
1148: if (!tv.getName().equals("TM2"))
1149: fail("test_5, case 065 FAILED: " + ((Class) rt).getName());
1150: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1151: "foo3For_5"))
1152: fail("test_5, case 066 FAILED: "
1153: + ((Method) tv.getGenericDeclaration()).getName());
1154: ///////
1155: atp = m.getTypeParameters();
1156: if (atp.length != 6)
1157: fail("test_5, case 067 FAILED: " + atp.length);
1158: tv = (TypeVariable) atp[0];
1159: if (!tv.getName().equals("\u0576\u06C0\u06F1"))
1160: fail("test_5, case 068 FAILED: " + tv.getName());
1161: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1162: "foo3For_5"))
1163: fail("test_5, case 069 FAILED: "
1164: + ((Method) tv.getGenericDeclaration()).getName());
1165: ab = tv.getBounds();
1166: if (ab.length != 1)
1167: fail("test_5, case 070 FAILED: " + ab.length);
1168: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1169: fail("test_5, case 071 FAILED: "
1170: + ((Class) ab[0]).getName());
1171: tv = (TypeVariable) atp[1];
1172: if (!tv.getName().equals("\u0576\u06C0\u06F11"))
1173: fail("test_5, case 072 FAILED: " + tv.getName());
1174: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1175: "foo3For_5"))
1176: fail("test_5, case 073 FAILED: "
1177: + ((Method) tv.getGenericDeclaration()).getName());
1178: ab = tv.getBounds();
1179: if (ab.length != 1)
1180: fail("test_5, case 074 FAILED: " + ab.length);
1181: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1182: fail("test_5, case 075 FAILED: "
1183: + ((Class) ab[0]).getName());
1184: tv = (TypeVariable) atp[2];
1185: if (!tv.getName().equals("\u0576\u06C0\u06F12"))
1186: fail("test_5, case 076 FAILED: " + tv.getName());
1187: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1188: "foo3For_5"))
1189: fail("test_5, case 077 FAILED: "
1190: + ((Method) tv.getGenericDeclaration()).getName());
1191: ab = tv.getBounds();
1192: if (ab.length != 1)
1193: fail("test_5, case 001 FAILED: " + ab.length);
1194: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1195: fail("test_5, case 078 FAILED: "
1196: + ((Class) ab[0]).getName());
1197: tv = (TypeVariable) atp[3];
1198: if (!tv.getName().equals("\u0576\u06C0\u06F13"))
1199: fail("test_5, case 079 FAILED: " + tv.getName());
1200: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1201: "foo3For_5"))
1202: fail("test_5, case 080 FAILED: "
1203: + ((Method) tv.getGenericDeclaration()).getName());
1204: ab = tv.getBounds();
1205: if (ab.length != 1)
1206: fail("test_5, case 081 FAILED: " + ab.length);
1207: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1208: fail("test_5, case 082 FAILED: "
1209: + ((Class) ab[0]).getName());
1210: tv = (TypeVariable) atp[4];
1211: if (!tv.getName().equals("TM1"))
1212: fail("test_5, case 083 FAILED: " + tv.getName());
1213: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1214: "foo3For_5"))
1215: fail("test_5, case 084 FAILED: "
1216: + ((Method) tv.getGenericDeclaration()).getName());
1217: ab = tv.getBounds();
1218: if (ab.length != 1)
1219: fail("test_5, case 085 FAILED: " + ab.length);
1220: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1221: fail("test_5, case 086 FAILED: "
1222: + ((Class) ab[0]).getName());
1223: tv = (TypeVariable) atp[5];
1224: if (!tv.getName().equals("TM2"))
1225: fail("test_5, case 087 FAILED: " + tv.getName());
1226: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1227: "foo3For_5"))
1228: fail("test_5, case 088 FAILED: "
1229: + ((Method) tv.getGenericDeclaration()).getName());
1230: ab = tv.getBounds();
1231: if (ab.length != 3)
1232: fail("test_5, case 089 FAILED: " + ab.length);
1233: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
1234: fail("test_5, case 090 FAILED: "
1235: + ((Class) ab[0]).getName());
1236: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
1237: fail("test_5, case 091 FAILED: "
1238: + ((Class) ab[0]).getName());
1239: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
1240: fail("test_5, case 092 FAILED: "
1241: + ((Class) ab[0]).getName());
1242: ///////
1243: ap = m.getGenericParameterTypes();
1244: if (ap.length != 4)
1245: fail("test_5, case 093 FAILED: " + ap.length);
1246: gat = (GenericArrayType) ap[0];
1247: tv = (TypeVariable) gat.getGenericComponentType();
1248: if (!tv.getName().equals("\u0576\u06C0\u06F1"))
1249: fail("test_5, case 094 FAILED: " + tv.getName());
1250: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1251: "foo3For_5"))
1252: fail("test_5, case 095 FAILED: "
1253: + ((Method) tv.getGenericDeclaration()).getName());
1254: tv = (TypeVariable) ap[1];
1255: if (!tv.getName().equals("TM1"))
1256: fail("test_5, case 096 FAILED: " + tv.getName());
1257: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1258: "foo3For_5"))
1259: fail("test_5, case 097 FAILED: "
1260: + ((Method) tv.getGenericDeclaration()).getName());
1261: tv = (TypeVariable) ap[2];
1262: if (!tv.getName().equals("TM2"))
1263: fail("test_5, case 098 FAILED: " + tv.getName());
1264: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1265: "foo3For_5"))
1266: fail("test_5, case 099 FAILED: "
1267: + ((Method) tv.getGenericDeclaration()).getName());
1268: oc1 = (ParameterizedType) ap[3];
1269: if (!((Class) ((ParameterizedType) oc1).getRawType())
1270: .equals(java.lang.ClassGenericsTest.Mc002.Mc004.class))
1271: fail("test_5, case 100 FAILED: "
1272: + ((Class) ((ParameterizedType) oc1).getRawType()));
1273: if (!((ParameterizedType) oc1)
1274: .getOwnerType()
1275: .toString()
1276: .equals(
1277: "java.lang.ClassGenericsTest<? super java.lang.Class>.Mc002<java.lang.ClassGenericsTest>"))
1278: fail("test_5, case 101 FAILED: "
1279: + ((ParameterizedType) oc1).getOwnerType()
1280: .toString());
1281: aa0 = ((ParameterizedType) oc1).getActualTypeArguments();
1282: if (aa0.length != 1)
1283: fail("test_5, case 102 FAILED: " + aa0.length);
1284: //System.out.println(aa0[0]);
1285: if (!((Class) aa0[0]).equals(ClassGenericsTest.class))
1286: fail("test_5, case 103 FAILED: " + (aa0[0]));
1287:
1288: if (!((Class) ((ParameterizedType) ((ParameterizedType) oc1)
1289: .getOwnerType()).getRawType())
1290: .equals(java.lang.ClassGenericsTest.Mc002.class))
1291: fail("test_5, case 104 FAILED: "
1292: + ((Class) ((ParameterizedType) oc1).getRawType()));
1293: aa0 = ((ParameterizedType) ((ParameterizedType) oc1)
1294: .getOwnerType()).getActualTypeArguments();
1295: if (aa0.length != 1)
1296: fail("test_5, case 105 FAILED: " + aa0.length);
1297: if (!((Class) aa0[0]).equals(ClassGenericsTest.class))
1298: fail("test_5, case 106 FAILED: " + (aa0[0]));
1299: if (!((ParameterizedType) ((ParameterizedType) oc1)
1300: .getOwnerType()).getOwnerType().toString().equals(
1301: "java.lang.ClassGenericsTest<? super java.lang.Class>"))
1302: fail("test_5, case 107 FAILED: "
1303: + ((Class) ((ParameterizedType) oc1).getRawType()));
1304: if (!((Class) ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
1305: .getOwnerType()).getOwnerType()).getRawType())
1306: .equals(java.lang.ClassGenericsTest.class))
1307: fail("test_5, case 108 FAILED: "
1308: + ((Class) ((ParameterizedType) oc1).getRawType()));
1309:
1310: aa0 = ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
1311: .getOwnerType()).getOwnerType())
1312: .getActualTypeArguments();
1313: if (aa0.length != 1)
1314: fail("test_5, case 109 FAILED: " + aa0.length);
1315: wc = (WildcardType) aa0[0];
1316: aa3 = wc.getLowerBounds();
1317: if (aa3.length != 1)
1318: fail("test_5, case 110 FAILED: " + aa3.length);
1319: if (!((Class) aa3[0]).equals(Class.class))
1320: fail("test_2, case 111 FAILED: " + ((Class) aa3[0]));
1321: aa3 = wc.getUpperBounds();
1322: if (aa3.length != 1)
1323: fail("test_5, case 112 FAILED: " + aa3.length);
1324: if (!((Class) aa3[0]).equals(Object.class))
1325: fail("test_5, case 113 FAILED: " + ((Class) aa3[0]));
1326: ///////
1327: aet = m.getGenericExceptionTypes();
1328: if (aet.length != 6)
1329: fail("test_5, case 114 FAILED: " + ap.length);
1330: tv = (TypeVariable) aet[0];
1331: if (!tv.getName().equals("\u0576\u06C0\u06F1"))
1332: fail("test_5, case 115 FAILED: " + tv.getName());
1333: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1334: "foo3For_5"))
1335: fail("test_5, case 116 FAILED: "
1336: + ((Method) tv.getGenericDeclaration()).getName());
1337: if (!((Class) aet[1]).getName().equals("java.lang.Throwable"))
1338: fail("test_5, case 117 FAILED: "
1339: + ((Class) aet[1]).getName());
1340: tv = (TypeVariable) aet[2];
1341: if (!tv.getName().equals("\u0576\u06C0\u06F13"))
1342: fail("test_5, case 118 FAILED: " + tv.getName());
1343: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1344: "foo3For_5"))
1345: fail("test_5, case 119 FAILED: "
1346: + ((Method) tv.getGenericDeclaration()).getName());
1347: tv = (TypeVariable) aet[3];
1348: if (!tv.getName().equals("\u0576\u06C0\u06F12"))
1349: fail("test_5, case 120 FAILED: " + tv.getName());
1350: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1351: "foo3For_5"))
1352: fail("test_5, case 121 FAILED: "
1353: + ((Method) tv.getGenericDeclaration()).getName());
1354: tv = (TypeVariable) aet[4];
1355: if (!tv.getName().equals("\u0576\u06C0\u06F11"))
1356: fail("test_5, case 122 FAILED: " + tv.getName());
1357: if (!((Method) tv.getGenericDeclaration()).getName().equals(
1358: "foo3For_5"))
1359: fail("test_5, case 123 FAILED: "
1360: + ((Method) tv.getGenericDeclaration()).getName());
1361:
1362: if (!((Class) aet[5]).getName().equals(
1363: "java.lang.ClassGenericsTest$Mc009\u0576\u06C0\u06F1"))
1364: fail("test_5, case 1231 FAILED: " + ((Class) rt).getName());
1365: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1366: m = null;
1367: try {
1368: java.lang.reflect.Method am[] = ClassGenericsTest.class
1369: .getDeclaredMethods();
1370: for (int i = 0; i < am.length; i++) {
1371: if (am[i].getName().equals("foo4For_5")) {
1372: m = am[i];
1373: }
1374: }
1375: //if(!((igt)m.getAnnotation(igt.class)).author().equals("*****")) fail("test_3, case 003 FAILED: "+((igt)m.getAnnotation(igt.class)).author());
1376: } catch (Exception e) {
1377: fail("test_5, case 124 FAILED: " + e.toString());
1378: }
1379: rt = m.getGenericReturnType();
1380: oc1 = (ParameterizedType) rt;
1381: if (!((Class) ((ParameterizedType) oc1).getRawType())
1382: .equals(java.lang.ClassGenericsTest.Mc003.class))
1383: fail("test_5, case 125 FAILED: "
1384: + ((Class) ((ParameterizedType) oc1).getRawType()));
1385: if (RuntimeAdditionalSupport1.openingFlag) {
1386: if (!((ParameterizedType) oc1).getOwnerType().toString()
1387: .equals("java.lang.ClassGenericsTest<X>"))
1388: fail("test_5, case 126 FAILED: "
1389: + ((ParameterizedType) oc1).getOwnerType()
1390: .toString());
1391: }
1392: aa0 = ((ParameterizedType) oc1).getActualTypeArguments();
1393: if (aa0.length != 1)
1394: fail("test_2, case 127 FAILED: " + aa0.length);
1395: if (!((ParameterizedType) aa0[0]).getRawType().equals(
1396: Mc005.class))
1397: fail("test_5, case 128 FAILED: " + (aa0[0]));
1398: if (!((ParameterizedType) aa0[0]).getOwnerType().toString()
1399: .equals("java.lang.ClassGenericsTest<X>"))
1400: fail("test_5, case 129 FAILED: " + (aa0[0]));
1401:
1402: //Class c = (Class)((ParameterizedType)ft).getRawType();
1403: Class c = (Class) (oc1).getRawType();
1404:
1405: ap = c.getTypeParameters();
1406: if (ap.length != 1)
1407: fail("test_5, case 130 FAILED: " + ap.length);
1408: tv = (TypeVariable) ap[0];
1409: if (!tv.getName().equals("T4"))
1410: fail("test_5, case 131 FAILED: " + tv.getName());
1411: if (!((Class) tv.getGenericDeclaration()).getName().equals(
1412: "java.lang.ClassGenericsTest$Mc003"))
1413: fail("test_5, case 132 FAILED: "
1414: + ((Class) tv.getGenericDeclaration()).getName());
1415: ab = tv.getBounds();
1416: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
1417: fail("test_5, case 133 FAILED: "
1418: + ((Class) ab[0]).getName());
1419: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
1420: fail("test_5, case 134 FAILED: "
1421: + ((Class) ab[1]).getName());
1422: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
1423: fail("test_5, case 135 FAILED: "
1424: + ((Class) ab[2]).getName());
1425: ///////
1426: atp = m.getTypeParameters();
1427: if (atp.length != 0)
1428: fail("test_5, case 136 FAILED: " + atp.length);
1429: ///////
1430: ap = m.getGenericParameterTypes();
1431: if (ap.length != 3)
1432: fail("test_5, case 137 FAILED: " + ap.length);
1433: oc1 = (ParameterizedType) ap[0];
1434: if (!((Class) ((ParameterizedType) oc1).getRawType())
1435: .equals(java.lang.ClassGenericsTest.Mc002.Mc004.class))
1436: fail("test_5, case 138 FAILED: "
1437: + ((Class) ((ParameterizedType) oc1).getRawType()));
1438: if (!((ParameterizedType) oc1)
1439: .getOwnerType()
1440: .toString()
1441: .equals(
1442: "java.lang.ClassGenericsTest<? super java.lang.Class>.Mc002<java.lang.ClassGenericsTest>"))
1443: fail("test_5, case 139 FAILED: "
1444: + ((ParameterizedType) oc1).getOwnerType()
1445: .toString());
1446: aa0 = ((ParameterizedType) oc1).getActualTypeArguments();
1447: if (aa0.length != 1)
1448: fail("test_5, case 140 FAILED: " + aa0.length);
1449:
1450: wc = (WildcardType) aa0[0];
1451: aa3 = wc.getLowerBounds();
1452: if (aa3.length != 0)
1453: fail("test_5, case 141 FAILED: " + aa3.length);
1454: //if(!((Class)aa3[0]).equals(Class.class)) fail("test_2, case 050 FAILED: "+((Class)aa3[0]));
1455: aa3 = wc.getUpperBounds();
1456: if (aa3.length != 1)
1457: fail("test_5, case 142 FAILED: " + aa3.length);
1458: if (!((Class) aa3[0]).equals(Object.class))
1459: fail("test_5, case 143 FAILED: " + ((Class) aa3[0]));
1460:
1461: if (!((Class) ((ParameterizedType) ((ParameterizedType) oc1)
1462: .getOwnerType()).getRawType())
1463: .equals(java.lang.ClassGenericsTest.Mc002.class))
1464: fail("test_5, case 144 FAILED: "
1465: + ((Class) ((ParameterizedType) oc1).getRawType()));
1466: aa0 = ((ParameterizedType) ((ParameterizedType) oc1)
1467: .getOwnerType()).getActualTypeArguments();
1468: if (aa0.length != 1)
1469: fail("test_5, case 145 FAILED: " + aa0.length);
1470: if (!((Class) aa0[0]).equals(ClassGenericsTest.class))
1471: fail("test_5, case 146 FAILED: " + (aa0[0]));
1472: if (!((ParameterizedType) ((ParameterizedType) oc1)
1473: .getOwnerType()).getOwnerType().toString().equals(
1474: "java.lang.ClassGenericsTest<? super java.lang.Class>"))
1475: fail("test_5, case 147 FAILED: "
1476: + ((Class) ((ParameterizedType) oc1).getRawType()));
1477: if (!((Class) ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
1478: .getOwnerType()).getOwnerType()).getRawType())
1479: .equals(java.lang.ClassGenericsTest.class))
1480: fail("test_5, case 148 FAILED: "
1481: + ((Class) ((ParameterizedType) oc1).getRawType()));
1482:
1483: aa0 = ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
1484: .getOwnerType()).getOwnerType())
1485: .getActualTypeArguments();
1486: if (aa0.length != 1)
1487: fail("test_5, case 149 FAILED: " + aa0.length);
1488: wc = (WildcardType) aa0[0];
1489: aa3 = wc.getLowerBounds();
1490: if (aa3.length != 1)
1491: fail("test_5, case 150 FAILED: " + aa3.length);
1492: if (!((Class) aa3[0]).equals(Class.class))
1493: fail("test_2, case 151 FAILED: " + ((Class) aa3[0]));
1494: aa3 = wc.getUpperBounds();
1495: if (aa3.length != 1)
1496: fail("test_5, case 152 FAILED: " + aa3.length);
1497: if (!((Class) aa3[0]).equals(Object.class))
1498: fail("test_5, case 153 FAILED: " + ((Class) aa3[0]));
1499: ///
1500:
1501: oc1 = (ParameterizedType) ap[1];
1502: if (!((Class) ((ParameterizedType) oc1).getRawType())
1503: .equals(java.lang.ClassGenericsTest.Mc003.class))
1504: fail("test_5, case 154 FAILED: "
1505: + ((Class) ((ParameterizedType) oc1).getRawType()));
1506: if (RuntimeAdditionalSupport1.openingFlag) {
1507: if (!((ParameterizedType) oc1).getOwnerType().toString()
1508: .equals("java.lang.ClassGenericsTest<X>"))
1509: fail("test_5, case 155 FAILED: "
1510: + ((ParameterizedType) oc1).getOwnerType()
1511: .toString());
1512: }
1513: aa0 = ((ParameterizedType) oc1).getActualTypeArguments();
1514: if (aa0.length != 1)
1515: fail("test_2, case 156 FAILED: " + aa0.length);
1516: if (!((ParameterizedType) aa0[0]).getRawType().equals(
1517: Mc005.class))
1518: fail("test_5, case 157 FAILED: " + (aa0[0]));
1519: if (!((ParameterizedType) aa0[0]).getOwnerType().toString()
1520: .equals("java.lang.ClassGenericsTest<X>"))
1521: fail("test_5, case 158 FAILED: " + (aa0[0]));
1522:
1523: c = (Class) (oc1).getRawType();
1524:
1525: ap = c.getTypeParameters();
1526: if (ap.length != 1)
1527: fail("test_5, case 159 FAILED: " + ap.length);
1528: tv = (TypeVariable) ap[0];
1529: if (!tv.getName().equals("T4"))
1530: fail("test_5, case 160 FAILED: " + tv.getName());
1531: if (!((Class) tv.getGenericDeclaration()).getName().equals(
1532: "java.lang.ClassGenericsTest$Mc003"))
1533: fail("test_5, case 161 FAILED: "
1534: + ((Class) tv.getGenericDeclaration()).getName());
1535: ab = tv.getBounds();
1536: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
1537: fail("test_5, case 162 FAILED: "
1538: + ((Class) ab[0]).getName());
1539: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
1540: fail("test_5, case 163 FAILED: "
1541: + ((Class) ab[1]).getName());
1542: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
1543: fail("test_5, case 164 FAILED: "
1544: + ((Class) ab[2]).getName());
1545: ///////
1546: aet = m.getGenericExceptionTypes();
1547: if (aet.length != 0)
1548: fail("test_5, case 165 FAILED: " + aet.length);
1549: ///////
1550: if (RuntimeAdditionalSupport1.openingFlag) {
1551: if (!m
1552: .toGenericString()
1553: .equals(
1554: "public transient java.lang.ClassGenericsTest<X>.Mc003<java.lang.ClassGenericsTest<X>.Mc005> java.lang.ClassGenericsTest.foo4For_5(java.lang.ClassGenericsTest<? super java.lang.Class>.Mc002<java.lang.ClassGenericsTest>.Mc004<?>,java.lang.ClassGenericsTest<X>.Mc003<java.lang.ClassGenericsTest<X>.Mc005>,java.lang.ClassGenericsTest<X>.Mc003<java.lang.ClassGenericsTest<X>.Mc005>[])"))
1555: fail("test_5, case 166 FAILED: |" + m.toGenericString()
1556: + "|");
1557: }
1558: }
1559:
1560: /**
1561: * getGenericExceptionTypes(), getGenericParameterTypes(), getGenericReturnType(), getTypeParameters(), toGenericString() of non-generalized method
1562: */
1563: public void foo1For_5_5(int a1) throws java.io.IOException {
1564: }
1565:
1566: public void test_5_5() {
1567: Type rt;
1568: Type ap[];
1569: Type aet[];
1570: Type atp[];
1571: Method m = null;
1572: try {
1573: java.lang.reflect.Method am[] = ClassGenericsTest.class
1574: .getDeclaredMethods();
1575: for (int i = 0; i < am.length; i++) {
1576: if (am[i].getName().equals("foo1For_5_5")) {
1577: m = am[i];
1578: }
1579: }
1580: } catch (Exception e) {
1581: fail("test_5_5, case 001 FAILED: " + e.toString());
1582: }
1583: rt = m.getGenericReturnType();
1584: if (!((Class) rt).getName().equals("void"))
1585: fail("test_5_5, case 002 FAILED: " + ((Class) rt).getName());
1586: ///////
1587: atp = m.getTypeParameters();
1588: if (atp.length != 0)
1589: fail("test_5_5, case 003 FAILED: " + atp.length);
1590: ///////
1591: ap = m.getGenericParameterTypes();
1592: if (ap.length != 1)
1593: fail("test_5_5, case 004 FAILED: " + ap.length);
1594: if (!((Class) ap[0]).getName().equals("int"))
1595: fail("test_5_5, case 005 FAILED: "
1596: + ((Class) ap[0]).getName());
1597: ///////
1598: aet = m.getGenericExceptionTypes();
1599: if (aet.length != 1)
1600: fail("test_5_5, case 006 FAILED: " + ap.length);
1601: if (!((Class) aet[0]).getName().equals("java.io.IOException"))
1602: fail("test_5_5, case 007 FAILED: "
1603: + ((Class) aet[0]).getName());
1604: ///////
1605: if (!m
1606: .toGenericString()
1607: .equals(
1608: "public void java.lang.ClassGenericsTest.foo1For_5_5(int) throws java.io.IOException"))
1609: fail("test_5_5, case 008 FAILED: |" + m.toGenericString()
1610: + "|");
1611: }
1612:
1613: /**
1614: * getGenericExceptionTypes(), getGenericParameterTypes(), getGenericReturnType(), getTypeParameters(), toGenericString() of generalized constructor
1615: */
1616: class MC006 {
1617: /* + */@igt(author = "*****")
1618: public <UuUuU extends Throwable, TM1, TM2 extends Thread & java.io.Serializable & Cloneable> MC006(
1619: UuUuU a1) throws UuUuU, java.io.IOException {
1620: }
1621:
1622: /* + */public <\u0391 extends Throwable, TM1, TM2, TM3, TM4, TM5, TM6, TM7> MC006()
1623: throws \u0391, java.io.IOException {
1624: }
1625:
1626: /* + */public <\u0576\u06C0\u06F1 extends Throwable, \u0576\u06C0\u06F11 extends Throwable, \u0576\u06C0\u06F12 extends Throwable, \u0576\u06C0\u06F13 extends Throwable, TM1, TM2 extends Thread & java.io.Serializable & Cloneable> MC006(
1627: ???[] BAAB,
1628: TM1 a1,
1629: TM2 a2,
1630: ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<ClassGenericsTest> a3)
1631: throws \u0576\u06C0\u06F1, Throwable,
1632: \u0576\u06C0\u06F13, \u0576\u06C0\u06F12,
1633: \u0576\u06C0\u06F11 {
1634: }
1635:
1636: /* + */public MC006(
1637: ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<?> a1,
1638: @igt(author="Czar")
1639: Mc003<Mc005> a2, @igt(author="President")
1640: Mc003<Mc005>... a3) {
1641: }
1642:
1643: /* - */public MC006(
1644: X a1,
1645: Class<Type> a2,
1646: ClassGenericsTest<? super Class>.Mc002<ClassGenericsTest>.Mc004<ClassGenericsTest> a3) {
1647: }
1648: }
1649:
1650: public void test_6() {
1651: TypeVariable tv;
1652: ParameterizedType oc1;
1653: Type aa0[];
1654: Type ap[];
1655: Type ab[];
1656: Type aet[];
1657: Type atp[];
1658: GenericArrayType gat;
1659: Constructor<ClassGenericsTest.MC006> m = null;
1660: try {
1661: //for(int i = 0; i <ClassGenericsTest.MC006.class.getDeclaredConstructors().length; i++ ) {
1662: // System.out.println(ClassGenericsTest.MC006.class.getDeclaredConstructors()[i]);
1663: //}
1664: m = ClassGenericsTest.MC006.class
1665: .getConstructor(new Class[] {
1666: ClassGenericsTest.class, Throwable.class });
1667: if (!(m.getAnnotation(igt.class)).author().equals("*****"))
1668: fail("test_6, case 001 FAILED: "
1669: + ((igt) m.getAnnotation(igt.class)).author());
1670: } catch (Exception e) {
1671: fail("test_6, case 002 FAILED: " + e.toString());
1672: }
1673: atp = m.getTypeParameters();
1674: if (atp.length != 3)
1675: fail("test_6, case 004 FAILED: " + atp.length);
1676: tv = (TypeVariable) atp[0];
1677: if (!tv.getName().equals("UuUuU"))
1678: fail("test_6, case 005 FAILED: " + tv.getName());
1679: if (!((Constructor) tv.getGenericDeclaration()).getName()
1680: .equals("java.lang.ClassGenericsTest$MC006"))
1681: fail("test_6, case 006 FAILED: "
1682: + ((Constructor) tv.getGenericDeclaration())
1683: .getName());
1684: ab = tv.getBounds();
1685: if (ab.length != 1)
1686: fail("test_6, case 007 FAILED: " + ab.length);
1687: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1688: fail("test_6, case 008 FAILED: "
1689: + ((Class) ab[0]).getName());
1690: tv = (TypeVariable) atp[1];
1691: if (!tv.getName().equals("TM1"))
1692: fail("test_6, case 009 FAILED: " + tv.getName());
1693: if (!((Constructor) tv.getGenericDeclaration()).getName()
1694: .equals("java.lang.ClassGenericsTest$MC006"))
1695: fail("test_6, case 010 FAILED: "
1696: + ((Constructor) tv.getGenericDeclaration())
1697: .getName());
1698: ab = tv.getBounds();
1699: if (ab.length != 1)
1700: fail("test_6, case 011 FAILED: " + ab.length);
1701: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1702: fail("test_6, case 012 FAILED: "
1703: + ((Class) ab[0]).getName());
1704: tv = (TypeVariable) atp[2];
1705: if (!tv.getName().equals("TM2"))
1706: fail("test_6, case 013 FAILED: " + tv.getName());
1707: if (!((Constructor) tv.getGenericDeclaration()).getName()
1708: .equals("java.lang.ClassGenericsTest$MC006"))
1709: fail("test_6, case 014 FAILED: "
1710: + ((Constructor) tv.getGenericDeclaration())
1711: .getName());
1712: ab = tv.getBounds();
1713: if (ab.length != 3)
1714: fail("test_6, case 015 FAILED: " + ab.length);
1715: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
1716: fail("test_6, case 016 FAILED: "
1717: + ((Class) ab[0]).getName());
1718: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
1719: fail("test_2, case 017 FAILED: "
1720: + ((Class) ab[1]).getName());
1721: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
1722: fail("test_2, case 018 FAILED: "
1723: + ((Class) ab[2]).getName());
1724: ///////
1725: ap = m.getGenericParameterTypes();
1726: if (ap.length != 1)
1727: fail("test_6, case 019 FAILED: " + ap.length);
1728: tv = (TypeVariable) ap[0];
1729: if (!tv.getName().equals("UuUuU"))
1730: fail("test_6, case 020 FAILED: " + tv.getName());
1731: ///////
1732: aet = m.getGenericExceptionTypes();
1733: if (aet.length != 2)
1734: fail("test_6, case 021 FAILED: " + ap.length);
1735: tv = (TypeVariable) aet[0];
1736: if (!tv.getName().equals("UuUuU"))
1737: fail("test_6, case 022 FAILED: " + tv.getName());
1738: if (!((Class) aet[1]).getName().equals("java.io.IOException"))
1739: fail("test_6, case 023 FAILED: "
1740: + ((Class) aet[1]).getName());
1741: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1742: m = null;
1743: try {
1744: m = ClassGenericsTest.MC006.class
1745: .getConstructor(new Class[] { ClassGenericsTest.class });
1746: } catch (Exception e) {
1747: fail("test_6, case 024 FAILED: " + e.toString());
1748: }
1749: ///////
1750: atp = m.getTypeParameters();
1751: if (atp.length != 8)
1752: fail("test_6, case 027 FAILED: " + atp.length);
1753: tv = (TypeVariable) atp[0];
1754: if (!tv.getName().equals("\u0391"))
1755: fail("test_6, case 028 FAILED: " + tv.getName());
1756: if (!((Constructor) tv.getGenericDeclaration()).getName()
1757: .equals("java.lang.ClassGenericsTest$MC006"))
1758: fail("test_6, case 028 FAILED: "
1759: + ((Constructor) tv.getGenericDeclaration())
1760: .getName());
1761: ab = tv.getBounds();
1762: if (ab.length != 1)
1763: fail("test_6, case 030 FAILED: " + ab.length);
1764: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1765: fail("test_6, case 031 FAILED: "
1766: + ((Class) ab[0]).getName());
1767: tv = (TypeVariable) atp[1];
1768: if (!tv.getName().equals("TM1"))
1769: fail("test_6, case 032 FAILED: " + tv.getName());
1770: if (!((Constructor) tv.getGenericDeclaration()).getName()
1771: .equals("java.lang.ClassGenericsTest$MC006"))
1772: fail("test_6, case 033 FAILED: "
1773: + ((Constructor) tv.getGenericDeclaration())
1774: .getName());
1775: ab = tv.getBounds();
1776: if (ab.length != 1)
1777: fail("test_6, case 034 FAILED: " + ab.length);
1778: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1779: fail("test_6, case 035 FAILED: "
1780: + ((Class) ab[0]).getName());
1781: tv = (TypeVariable) atp[2];
1782: if (!tv.getName().equals("TM2"))
1783: fail("test_6, case 036 FAILED: " + tv.getName());
1784: if (!((Constructor) tv.getGenericDeclaration()).getName()
1785: .equals("java.lang.ClassGenericsTest$MC006"))
1786: fail("test_6, case 037 FAILED: "
1787: + ((Constructor) tv.getGenericDeclaration())
1788: .getName());
1789: ab = tv.getBounds();
1790: if (ab.length != 1)
1791: fail("test_6, case 038 FAILED: " + ab.length);
1792: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1793: fail("test_6, case 039 FAILED: "
1794: + ((Class) ab[0]).getName());
1795: tv = (TypeVariable) atp[3];
1796: if (!tv.getName().equals("TM3"))
1797: fail("test_6, case 040 FAILED: " + tv.getName());
1798: if (!((Constructor) tv.getGenericDeclaration()).getName()
1799: .equals("java.lang.ClassGenericsTest$MC006"))
1800: fail("test_6, case 041 FAILED: "
1801: + ((Constructor) tv.getGenericDeclaration())
1802: .getName());
1803: ab = tv.getBounds();
1804: if (ab.length != 1)
1805: fail("test_6, case 042 FAILED: " + ab.length);
1806: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1807: fail("test_6, case 043 FAILED: "
1808: + ((Class) ab[0]).getName());
1809: tv = (TypeVariable) atp[4];
1810: if (!tv.getName().equals("TM4"))
1811: fail("test_6, case 044 FAILED: " + tv.getName());
1812: if (!((Constructor) tv.getGenericDeclaration()).getName()
1813: .equals("java.lang.ClassGenericsTest$MC006"))
1814: fail("test_6, case 045 FAILED: "
1815: + ((Constructor) tv.getGenericDeclaration())
1816: .getName());
1817: ab = tv.getBounds();
1818: if (ab.length != 1)
1819: fail("test_6, case 046 FAILED: " + ab.length);
1820: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1821: fail("test_6, case 047 FAILED: "
1822: + ((Class) ab[0]).getName());
1823: tv = (TypeVariable) atp[5];
1824: if (!tv.getName().equals("TM5"))
1825: fail("test_6, case 048 FAILED: " + tv.getName());
1826: if (!((Constructor) tv.getGenericDeclaration()).getName()
1827: .equals("java.lang.ClassGenericsTest$MC006"))
1828: fail("test_6, case 049 FAILED: "
1829: + ((Constructor) tv.getGenericDeclaration())
1830: .getName());
1831: ab = tv.getBounds();
1832: if (ab.length != 1)
1833: fail("test_6, case 050 FAILED: " + ab.length);
1834: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1835: fail("test_6, case 051 FAILED: "
1836: + ((Class) ab[0]).getName());
1837: tv = (TypeVariable) atp[6];
1838: if (!tv.getName().equals("TM6"))
1839: fail("test_6, case 052 FAILED: " + tv.getName());
1840: if (!((Constructor) tv.getGenericDeclaration()).getName()
1841: .equals("java.lang.ClassGenericsTest$MC006"))
1842: fail("test_6, case 053 FAILED: "
1843: + ((Constructor) tv.getGenericDeclaration())
1844: .getName());
1845: ab = tv.getBounds();
1846: if (ab.length != 1)
1847: fail("test_6, case 054 FAILED: " + ab.length);
1848: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1849: fail("test_6, case 055 FAILED: "
1850: + ((Class) ab[0]).getName());
1851: tv = (TypeVariable) atp[7];
1852: if (!tv.getName().equals("TM7"))
1853: fail("test_6, case 056 FAILED: " + tv.getName());
1854: if (!((Constructor) tv.getGenericDeclaration()).getName()
1855: .equals("java.lang.ClassGenericsTest$MC006"))
1856: fail("test_6, case 057 FAILED: "
1857: + ((Constructor) tv.getGenericDeclaration())
1858: .getName());
1859: ab = tv.getBounds();
1860: if (ab.length != 1)
1861: fail("test_6, case 058 FAILED: " + ab.length);
1862: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1863: fail("test_6, case 059 FAILED: "
1864: + ((Class) ab[0]).getName());
1865: ///////
1866: ap = m.getGenericParameterTypes();
1867: if (ap.length != 0)
1868: fail("test_6, case 060 FAILED: " + ap.length);
1869: //tv = (TypeVariable)ap[0];
1870: //if(!tv.getName().equals("UuUuU")) fail("test_6, case 003 FAILED: "+tv.getName());
1871: ///////
1872: aet = m.getGenericExceptionTypes();
1873: if (aet.length != 2)
1874: fail("test_6, case 061 FAILED: " + ap.length);
1875: tv = (TypeVariable) aet[0];
1876: if (!tv.getName().equals("\u0391"))
1877: fail("test_6, case 062 FAILED: " + tv.getName());
1878: if (!((Class) aet[1]).getName().equals("java.io.IOException"))
1879: fail("test_6, case 063 FAILED: "
1880: + ((Class) aet[1]).getName());
1881: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1882: m = null;
1883: try {
1884: m = ClassGenericsTest.MC006.class
1885: .getConstructor(new Class[] {
1886: java.lang.ClassGenericsTest.class,
1887: java.lang.Throwable[].class,
1888: java.lang.Object.class,
1889: java.lang.Thread.class,
1890: java.lang.ClassGenericsTest.Mc002.Mc004.class });
1891: } catch (Exception e) {
1892: fail("test_6, case 064 FAILED: " + e.toString());
1893: }
1894: ///////
1895: atp = m.getTypeParameters();
1896: if (atp.length != 6)
1897: fail("test_6, case 067 FAILED: " + atp.length);
1898: tv = (TypeVariable) atp[0];
1899: if (!tv.getName().equals("\u0576\u06C0\u06F1"))
1900: fail("test_6, case 068 FAILED: " + tv.getName());
1901: if (!((Constructor) tv.getGenericDeclaration()).getName()
1902: .equals("java.lang.ClassGenericsTest$MC006"))
1903: fail("test_6, case 069 FAILED: "
1904: + ((Constructor) tv.getGenericDeclaration())
1905: .getName());
1906: ab = tv.getBounds();
1907: if (ab.length != 1)
1908: fail("test_6, case 070 FAILED: " + ab.length);
1909: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1910: fail("test_6, case 071 FAILED: "
1911: + ((Class) ab[0]).getName());
1912: tv = (TypeVariable) atp[1];
1913: if (!tv.getName().equals("\u0576\u06C0\u06F11"))
1914: fail("test_6, case 072 FAILED: " + tv.getName());
1915: if (!((Constructor) tv.getGenericDeclaration()).getName()
1916: .equals("java.lang.ClassGenericsTest$MC006"))
1917: fail("test_6, case 073 FAILED: "
1918: + ((Constructor) tv.getGenericDeclaration())
1919: .getName());
1920: ab = tv.getBounds();
1921: if (ab.length != 1)
1922: fail("test_6, case 074 FAILED: " + ab.length);
1923: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1924: fail("test_6, case 075 FAILED: "
1925: + ((Class) ab[0]).getName());
1926: tv = (TypeVariable) atp[2];
1927: if (!tv.getName().equals("\u0576\u06C0\u06F12"))
1928: fail("test_6, case 076 FAILED: " + tv.getName());
1929: if (!((Constructor) tv.getGenericDeclaration()).getName()
1930: .equals("java.lang.ClassGenericsTest$MC006"))
1931: fail("test_6, case 077 FAILED: "
1932: + ((Constructor) tv.getGenericDeclaration())
1933: .getName());
1934: ab = tv.getBounds();
1935: if (ab.length != 1)
1936: fail("test_6, case 001 FAILED: " + ab.length);
1937: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1938: fail("test_6, case 078 FAILED: "
1939: + ((Class) ab[0]).getName());
1940: tv = (TypeVariable) atp[3];
1941: if (!tv.getName().equals("\u0576\u06C0\u06F13"))
1942: fail("test_6, case 079 FAILED: " + tv.getName());
1943: if (!((Constructor) tv.getGenericDeclaration()).getName()
1944: .equals("java.lang.ClassGenericsTest$MC006"))
1945: fail("test_6, case 080 FAILED: "
1946: + ((Constructor) tv.getGenericDeclaration())
1947: .getName());
1948: ab = tv.getBounds();
1949: if (ab.length != 1)
1950: fail("test_6, case 081 FAILED: " + ab.length);
1951: if (!((Class) ab[0]).getName().equals("java.lang.Throwable"))
1952: fail("test_6, case 082 FAILED: "
1953: + ((Class) ab[0]).getName());
1954: tv = (TypeVariable) atp[4];
1955: if (!tv.getName().equals("TM1"))
1956: fail("test_6, case 083 FAILED: " + tv.getName());
1957: if (!((Constructor) tv.getGenericDeclaration()).getName()
1958: .equals("java.lang.ClassGenericsTest$MC006"))
1959: fail("test_6, case 084 FAILED: "
1960: + ((Constructor) tv.getGenericDeclaration())
1961: .getName());
1962: ab = tv.getBounds();
1963: if (ab.length != 1)
1964: fail("test_6, case 085 FAILED: " + ab.length);
1965: if (!((Class) ab[0]).getName().equals("java.lang.Object"))
1966: fail("test_6, case 086 FAILED: "
1967: + ((Class) ab[0]).getName());
1968: tv = (TypeVariable) atp[5];
1969: if (!tv.getName().equals("TM2"))
1970: fail("test_6, case 087 FAILED: " + tv.getName());
1971: if (!((Constructor) tv.getGenericDeclaration()).getName()
1972: .equals("java.lang.ClassGenericsTest$MC006"))
1973: fail("test_6, case 088 FAILED: "
1974: + ((Constructor) tv.getGenericDeclaration())
1975: .getName());
1976: ab = tv.getBounds();
1977: if (ab.length != 3)
1978: fail("test_6, case 089 FAILED: " + ab.length);
1979: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
1980: fail("test_6, case 090 FAILED: "
1981: + ((Class) ab[0]).getName());
1982: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
1983: fail("test_6, case 091 FAILED: "
1984: + ((Class) ab[0]).getName());
1985: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
1986: fail("test_6, case 092 FAILED: "
1987: + ((Class) ab[0]).getName());
1988: ///////
1989: ap = m.getGenericParameterTypes();
1990: if (ap.length != 4)
1991: fail("test_6, case 093 FAILED: " + ap.length);
1992: gat = (GenericArrayType) ap[0];
1993: tv = (TypeVariable) gat.getGenericComponentType();
1994: if (!tv.getName().equals("\u0576\u06C0\u06F1"))
1995: fail("test_6, case 094 FAILED: " + tv.getName());
1996: if (!((Constructor) tv.getGenericDeclaration()).getName()
1997: .equals("java.lang.ClassGenericsTest$MC006"))
1998: fail("test_6, case 095 FAILED: "
1999: + ((Constructor) tv.getGenericDeclaration())
2000: .getName());
2001: tv = (TypeVariable) ap[1];
2002: if (!tv.getName().equals("TM1"))
2003: fail("test_6, case 096 FAILED: " + tv.getName());
2004: if (!((Constructor) tv.getGenericDeclaration()).getName()
2005: .equals("java.lang.ClassGenericsTest$MC006"))
2006: fail("test_6, case 097 FAILED: "
2007: + ((Constructor) tv.getGenericDeclaration())
2008: .getName());
2009: tv = (TypeVariable) ap[2];
2010: if (!tv.getName().equals("TM2"))
2011: fail("test_6, case 098 FAILED: " + tv.getName());
2012: if (!((Constructor) tv.getGenericDeclaration()).getName()
2013: .equals("java.lang.ClassGenericsTest$MC006"))
2014: fail("test_6, case 099 FAILED: "
2015: + ((Constructor) tv.getGenericDeclaration())
2016: .getName());
2017: oc1 = (ParameterizedType) ap[3];
2018: if (!((Class) ((ParameterizedType) oc1).getRawType())
2019: .equals(java.lang.ClassGenericsTest.Mc002.Mc004.class))
2020: fail("test_6, case 100 FAILED: "
2021: + ((Class) ((ParameterizedType) oc1).getRawType()));
2022: if (!((ParameterizedType) oc1)
2023: .getOwnerType()
2024: .toString()
2025: .equals(
2026: "java.lang.ClassGenericsTest<? super java.lang.Class>.Mc002<java.lang.ClassGenericsTest>"))
2027: fail("test_6, case 101 FAILED: "
2028: + ((ParameterizedType) oc1).getOwnerType()
2029: .toString());
2030: aa0 = ((ParameterizedType) oc1).getActualTypeArguments();
2031: if (aa0.length != 1)
2032: fail("test_6, case 102 FAILED: " + aa0.length);
2033: //System.out.println(aa0[0]);
2034: if (!((Class) aa0[0]).equals(ClassGenericsTest.class))
2035: fail("test_6, case 103 FAILED: " + (aa0[0]));
2036:
2037: if (!((Class) ((ParameterizedType) ((ParameterizedType) oc1)
2038: .getOwnerType()).getRawType())
2039: .equals(java.lang.ClassGenericsTest.Mc002.class))
2040: fail("test_6, case 104 FAILED: "
2041: + ((Class) ((ParameterizedType) oc1).getRawType()));
2042: aa0 = ((ParameterizedType) ((ParameterizedType) oc1)
2043: .getOwnerType()).getActualTypeArguments();
2044: if (aa0.length != 1)
2045: fail("test_6, case 105 FAILED: " + aa0.length);
2046: if (!((Class) aa0[0]).equals(ClassGenericsTest.class))
2047: fail("test_6, case 106 FAILED: " + (aa0[0]));
2048: if (!((ParameterizedType) ((ParameterizedType) oc1)
2049: .getOwnerType()).getOwnerType().toString().equals(
2050: "java.lang.ClassGenericsTest<? super java.lang.Class>"))
2051: fail("test_6, case 107 FAILED: "
2052: + ((Class) ((ParameterizedType) oc1).getRawType()));
2053: if (!((Class) ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
2054: .getOwnerType()).getOwnerType()).getRawType())
2055: .equals(java.lang.ClassGenericsTest.class))
2056: fail("test_6, case 108 FAILED: "
2057: + ((Class) ((ParameterizedType) oc1).getRawType()));
2058:
2059: aa0 = ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
2060: .getOwnerType()).getOwnerType())
2061: .getActualTypeArguments();
2062: if (aa0.length != 1)
2063: fail("test_6, case 109 FAILED: " + aa0.length);
2064: WildcardType wc = (WildcardType) aa0[0];
2065: Type aa3[] = wc.getLowerBounds();
2066: if (aa3.length != 1)
2067: fail("test_6, case 110 FAILED: " + aa3.length);
2068: if (!((Class) aa3[0]).equals(Class.class))
2069: fail("test_2, case 111 FAILED: " + ((Class) aa3[0]));
2070: aa3 = wc.getUpperBounds();
2071: if (aa3.length != 1)
2072: fail("test_6, case 112 FAILED: " + aa3.length);
2073: if (!((Class) aa3[0]).equals(Object.class))
2074: fail("test_6, case 113 FAILED: " + ((Class) aa3[0]));
2075: ///////
2076: aet = m.getGenericExceptionTypes();
2077: if (aet.length != 5)
2078: fail("test_6, case 114 FAILED: " + ap.length);
2079: tv = (TypeVariable) aet[0];
2080: if (!tv.getName().equals("\u0576\u06C0\u06F1"))
2081: fail("test_6, case 115 FAILED: " + tv.getName());
2082: if (!((Constructor) tv.getGenericDeclaration()).getName()
2083: .equals("java.lang.ClassGenericsTest$MC006"))
2084: fail("test_6, case 116 FAILED: "
2085: + ((Constructor) tv.getGenericDeclaration())
2086: .getName());
2087: if (!((Class) aet[1]).getName().equals("java.lang.Throwable"))
2088: fail("test_6, case 117 FAILED: "
2089: + ((Class) aet[1]).getName());
2090: tv = (TypeVariable) aet[2];
2091: if (!tv.getName().equals("\u0576\u06C0\u06F13"))
2092: fail("test_6, case 118 FAILED: " + tv.getName());
2093: if (!((Constructor) tv.getGenericDeclaration()).getName()
2094: .equals("java.lang.ClassGenericsTest$MC006"))
2095: fail("test_6, case 119 FAILED: "
2096: + ((Constructor) tv.getGenericDeclaration())
2097: .getName());
2098: tv = (TypeVariable) aet[3];
2099: if (!tv.getName().equals("\u0576\u06C0\u06F12"))
2100: fail("test_6, case 120 FAILED: " + tv.getName());
2101: if (!((Constructor) tv.getGenericDeclaration()).getName()
2102: .equals("java.lang.ClassGenericsTest$MC006"))
2103: fail("test_6, case 121 FAILED: "
2104: + ((Constructor) tv.getGenericDeclaration())
2105: .getName());
2106: tv = (TypeVariable) aet[4];
2107: if (!tv.getName().equals("\u0576\u06C0\u06F11"))
2108: fail("test_6, case 122 FAILED: " + tv.getName());
2109: if (!((Constructor) tv.getGenericDeclaration()).getName()
2110: .equals("java.lang.ClassGenericsTest$MC006"))
2111: fail("test_6, case 123 FAILED: "
2112: + ((Constructor) tv.getGenericDeclaration())
2113: .getName());
2114: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2115: m = null;
2116: try {
2117: m = ClassGenericsTest.MC006.class
2118: .getConstructor(new Class[] {
2119: java.lang.ClassGenericsTest.class,
2120: java.lang.ClassGenericsTest.Mc002.Mc004.class,
2121: java.lang.ClassGenericsTest.Mc003.class,
2122: java.lang.ClassGenericsTest.Mc003[].class });
2123: } catch (Exception e) {
2124: fail("test_6, case 124 FAILED: " + e.toString());
2125: }
2126: ///////
2127: atp = m.getTypeParameters();
2128: if (atp.length != 0)
2129: fail("test_6, case 136 FAILED: " + atp.length);
2130: ///////
2131: ap = m.getGenericParameterTypes();
2132: if (ap.length != 3)
2133: fail("test_6, case 137 FAILED: " + ap.length);
2134: oc1 = (ParameterizedType) ap[0];
2135: if (!((Class) ((ParameterizedType) oc1).getRawType())
2136: .equals(java.lang.ClassGenericsTest.Mc002.Mc004.class))
2137: fail("test_6, case 138 FAILED: "
2138: + ((Class) ((ParameterizedType) oc1).getRawType()));
2139: if (!((ParameterizedType) oc1)
2140: .getOwnerType()
2141: .toString()
2142: .equals(
2143: "java.lang.ClassGenericsTest<? super java.lang.Class>.Mc002<java.lang.ClassGenericsTest>"))
2144: fail("test_6, case 139 FAILED: "
2145: + ((ParameterizedType) oc1).getOwnerType()
2146: .toString());
2147: aa0 = ((ParameterizedType) oc1).getActualTypeArguments();
2148: if (aa0.length != 1)
2149: fail("test_6, case 140 FAILED: " + aa0.length);
2150:
2151: wc = (WildcardType) aa0[0];
2152: aa3 = wc.getLowerBounds();
2153: if (aa3.length != 0)
2154: fail("test_6, case 141 FAILED: " + aa3.length);
2155: //if(!((Class)aa3[0]).equals(Class.class)) fail("test_2, case 050 FAILED: "+((Class)aa3[0]));
2156: aa3 = wc.getUpperBounds();
2157: if (aa3.length != 1)
2158: fail("test_6, case 142 FAILED: " + aa3.length);
2159: if (!((Class) aa3[0]).equals(Object.class))
2160: fail("test_6, case 143 FAILED: " + ((Class) aa3[0]));
2161:
2162: if (!((Class) ((ParameterizedType) ((ParameterizedType) oc1)
2163: .getOwnerType()).getRawType())
2164: .equals(java.lang.ClassGenericsTest.Mc002.class))
2165: fail("test_6, case 144 FAILED: "
2166: + ((Class) ((ParameterizedType) oc1).getRawType()));
2167: aa0 = ((ParameterizedType) ((ParameterizedType) oc1)
2168: .getOwnerType()).getActualTypeArguments();
2169: if (aa0.length != 1)
2170: fail("test_6, case 145 FAILED: " + aa0.length);
2171: if (!((Class) aa0[0]).equals(ClassGenericsTest.class))
2172: fail("test_6, case 146 FAILED: " + (aa0[0]));
2173: if (!((ParameterizedType) ((ParameterizedType) oc1)
2174: .getOwnerType()).getOwnerType().toString().equals(
2175: "java.lang.ClassGenericsTest<? super java.lang.Class>"))
2176: fail("test_6, case 147 FAILED: "
2177: + ((Class) ((ParameterizedType) oc1).getRawType()));
2178: if (!((Class) ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
2179: .getOwnerType()).getOwnerType()).getRawType())
2180: .equals(java.lang.ClassGenericsTest.class))
2181: fail("test_6, case 148 FAILED: "
2182: + ((Class) ((ParameterizedType) oc1).getRawType()));
2183:
2184: aa0 = ((ParameterizedType) ((ParameterizedType) ((ParameterizedType) oc1)
2185: .getOwnerType()).getOwnerType())
2186: .getActualTypeArguments();
2187: if (aa0.length != 1)
2188: fail("test_6, case 149 FAILED: " + aa0.length);
2189: wc = (WildcardType) aa0[0];
2190: aa3 = wc.getLowerBounds();
2191: if (aa3.length != 1)
2192: fail("test_6, case 150 FAILED: " + aa3.length);
2193: if (!((Class) aa3[0]).equals(Class.class))
2194: fail("test_2, case 151 FAILED: " + ((Class) aa3[0]));
2195: aa3 = wc.getUpperBounds();
2196: if (aa3.length != 1)
2197: fail("test_6, case 152 FAILED: " + aa3.length);
2198: if (!((Class) aa3[0]).equals(Object.class))
2199: fail("test_6, case 153 FAILED: " + ((Class) aa3[0]));
2200: ///
2201:
2202: oc1 = (ParameterizedType) ap[1];
2203: if (!((Class) ((ParameterizedType) oc1).getRawType())
2204: .equals(java.lang.ClassGenericsTest.Mc003.class))
2205: fail("test_6, case 154 FAILED: "
2206: + ((Class) ((ParameterizedType) oc1).getRawType()));
2207: if (RuntimeAdditionalSupport1.openingFlag) {
2208: if (!((ParameterizedType) oc1).getOwnerType().toString()
2209: .equals("java.lang.ClassGenericsTest<X>"))
2210: fail("test_6, case 155 FAILED: "
2211: + ((ParameterizedType) oc1).getOwnerType()
2212: .toString());
2213: }
2214: aa0 = ((ParameterizedType) oc1).getActualTypeArguments();
2215: if (aa0.length != 1)
2216: fail("test_2, case 156 FAILED: " + aa0.length);
2217: if (!((ParameterizedType) aa0[0]).getRawType().equals(
2218: Mc005.class))
2219: fail("test_6, case 157 FAILED: " + (aa0[0]));
2220: if (!((ParameterizedType) aa0[0]).getOwnerType().toString()
2221: .equals("java.lang.ClassGenericsTest<X>"))
2222: fail("test_6, case 158 FAILED: " + (aa0[0]));
2223:
2224: Class c = (Class) (oc1).getRawType();
2225:
2226: ap = c.getTypeParameters();
2227: if (ap.length != 1)
2228: fail("test_6, case 159 FAILED: " + ap.length);
2229: tv = (TypeVariable) ap[0];
2230: if (!tv.getName().equals("T4"))
2231: fail("test_6, case 160 FAILED: " + tv.getName());
2232: if (!((Class) tv.getGenericDeclaration()).getName().equals(
2233: "java.lang.ClassGenericsTest$Mc003"))
2234: fail("test_6, case 161 FAILED: "
2235: + ((Class) tv.getGenericDeclaration()).getName());
2236: ab = tv.getBounds();
2237: if (!((Class) ab[0]).getName().equals("java.lang.Thread"))
2238: fail("test_6, case 162 FAILED: "
2239: + ((Class) ab[0]).getName());
2240: if (!((Class) ab[1]).getName().equals("java.io.Serializable"))
2241: fail("test_6, case 163 FAILED: "
2242: + ((Class) ab[1]).getName());
2243: if (!((Class) ab[2]).getName().equals("java.lang.Cloneable"))
2244: fail("test_6, case 164 FAILED: "
2245: + ((Class) ab[2]).getName());
2246: ///////
2247: aet = m.getGenericExceptionTypes();
2248: if (aet.length != 0)
2249: fail("test_6, case 165 FAILED: " + ap.length);
2250: ///////
2251: if (RuntimeAdditionalSupport1.openingFlag) {
2252: if (!m
2253: .toGenericString()
2254: .equals(
2255: "public transient java.lang.ClassGenericsTest$MC006(java.lang.ClassGenericsTest<? super java.lang.Class>.Mc002<java.lang.ClassGenericsTest>.Mc004<?>,java.lang.ClassGenericsTest<X>.Mc003<java.lang.ClassGenericsTest<X>.Mc005>,java.lang.ClassGenericsTest<X>.Mc003<java.lang.ClassGenericsTest<X>.Mc005>[])"))
2256: fail("test_6, case 166 FAILED: |" + m.toGenericString()
2257: + "|");
2258: }
2259: //java.lang.ClassGenericsTest.class,java.lang.Object.class,java.lang.Class.class,java.lang.ClassGenericsTest$Mc002$Mc004.class
2260: }
2261:
2262: /**
2263: * getGenericExceptionTypes(), getGenericParameterTypes(), getGenericReturnType(), getTypeParameters(), toGenericString() of non-generalized constructor
2264: */
2265: class MC014 {
2266: public MC014(float a1) throws java.io.IOException {
2267: }
2268: }
2269:
2270: public void test_6_6() {
2271: Type ap[];
2272: Type aet[];
2273: Type atp[];
2274: Constructor m = null;
2275: m = null;
2276: try {
2277: m = ClassGenericsTest.MC014.class
2278: .getConstructor(new Class[] {
2279: java.lang.ClassGenericsTest.class,
2280: float.class });
2281: } catch (Exception e) {
2282: fail("test_6_5, case 001 FAILED: " + e.toString());
2283: }
2284: atp = m.getTypeParameters();
2285: if (atp.length != 0)
2286: fail("test_6_5, case 002 FAILED: " + atp.length);
2287: ///////
2288: ap = m.getGenericParameterTypes();
2289: if (ap.length != 2)
2290: fail("test_6_5, case 003 FAILED: " + ap.length);
2291: if (!((Class) ap[0]).getName().equals(
2292: "java.lang.ClassGenericsTest"))
2293: fail("test_6_5, case 004 FAILED: "
2294: + ((Class) ap[0]).getName());
2295: if (!((Class) ap[1]).getName().equals("float"))
2296: fail("test_6_5, case 005 FAILED: "
2297: + ((Class) ap[0]).getName());
2298: ///////
2299: aet = m.getGenericExceptionTypes();
2300: if (aet.length != 1)
2301: fail("test_6_5, case 006 FAILED: " + ap.length);
2302: if (!((Class) aet[0]).getName().equals("java.io.IOException"))
2303: fail("test_6_5, case 007 FAILED: "
2304: + ((Class) aet[0]).getName());
2305: ///////
2306: if (!m
2307: .toGenericString()
2308: .equals(
2309: "public java.lang.ClassGenericsTest$MC014(java.lang.ClassGenericsTest,float) throws java.io.IOException"))
2310: fail("test_6_5, case 008 FAILED: |" + m.toGenericString()
2311: + "|");
2312:
2313: }
2314: }
|