001: /***
002: * Retrotranslator: a Java bytecode transformer that translates Java classes
003: * compiled with JDK 5.0 into classes that can be run on JVM 1.4.
004: *
005: * Copyright (c) 2005 - 2008 Taras Puchko
006: * All rights reserved.
007: *
008: * Redistribution and use in source and binary forms, with or without
009: * modification, are permitted provided that the following conditions
010: * are met:
011: * 1. Redistributions of source code must retain the above copyright
012: * notice, this list of conditions and the following disclaimer.
013: * 2. Redistributions in binary form must reproduce the above copyright
014: * notice, this list of conditions and the following disclaimer in the
015: * documentation and/or other materials provided with the distribution.
016: * 3. Neither the name of the copyright holders nor the names of its
017: * contributors may be used to endorse or promote products derived from
018: * this software without specific prior written permission.
019: *
020: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
021: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
022: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
023: * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
024: * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
025: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
026: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
027: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
028: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
029: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
030: * THE POSSIBILITY OF SUCH DAMAGE.
031: */package net.sf.retrotranslator.runtime.java.lang.reflect;
032:
033: import java.lang.reflect.*;
034: import net.sf.retrotranslator.tests.TestCaseBase;
035:
036: /**
037: * @author Taras Puchko
038: */
039: public class _FieldGenericTestCase<Z> extends TestCaseBase {
040:
041: class MemberOuterNonGeneric {
042: }
043:
044: class MemberOuterGeneric<T> {
045: class MemberInnerNonGeneric {
046: }
047: }
048:
049: static class StaticMemberOuterNonGeneric {
050: }
051:
052: static class StaticMemberOuterGeneric<T> {
053: class MemberInnerNonGeneric {
054: }
055: }
056:
057: public void testVariable() {
058: class Test {
059: // TZ;
060: // Z
061: public Z f;
062: }
063: Type type = getType(Test.class);
064: assertVariable(type);
065: }
066:
067: public void testMemberNonGeneric() {
068: class Test {
069: // _FieldGenericTestCase<TZ;>.MemberOuterNonGeneric
070: // _FieldGenericTestCase<Z>.MemberOuterNonGeneric
071: public MemberOuterNonGeneric f;
072: }
073: ParameterizedType outerType = getParameterizedType(Test.class);
074: assertEquals(MemberOuterNonGeneric.class, outerType
075: .getRawType());
076: assertEquals(0, outerType.getActualTypeArguments().length);
077: assertThisType(outerType.getOwnerType());
078: }
079:
080: public void testStaticMemberNonGeneric() {
081: class Test {
082: // null
083: // class _FieldGenericTestCase$StaticMemberOuterNonGeneric
084: public StaticMemberOuterNonGeneric f;
085: }
086: Type type = getType(Test.class);
087: assertEquals(StaticMemberOuterNonGeneric.class, type);
088: }
089:
090: public void testMemberGeneric() {
091: class Test {
092: // _FieldGenericTestCase<TZ;>.MemberOuterGeneric<-[TZ;>
093: // _FieldGenericTestCase<Z>.MemberOuterGeneric<? super Z[]>
094: public MemberOuterGeneric<? super Z[]> f;
095: }
096: ParameterizedType outerType = getParameterizedType(Test.class);
097: assertEquals(MemberOuterGeneric.class, outerType.getRawType());
098: WildcardType wildcardType = (WildcardType) singleton(outerType
099: .getActualTypeArguments());
100: assertEquals(Object.class, singleton(wildcardType
101: .getUpperBounds()));
102: GenericArrayType arrayType = (GenericArrayType) singleton(wildcardType
103: .getLowerBounds());
104: assertVariable(arrayType.getGenericComponentType());
105: assertThisType(outerType.getOwnerType());
106: }
107:
108: public void testStaticMemberGeneric() {
109: class Test {
110: // _FieldGenericTestCase$StaticMemberOuterGeneric<Ljava/lang/String;>
111: // _FieldGenericTestCase._FieldGenericTestCase$StaticMemberOuterGeneric<java.lang.String>
112: public StaticMemberOuterGeneric<String> f;
113: }
114: ParameterizedType type = getParameterizedType(Test.class);
115: assertEquals(StaticMemberOuterGeneric.class, type.getRawType());
116: assertEquals(String.class, singleton(type
117: .getActualTypeArguments()));
118: assertEquals(this .getClass(), type.getOwnerType());
119: }
120:
121: public void testMemberOuterGeneric() {
122: class Test {
123: // _FieldGenericTestCase<TZ;>.MemberOuterGeneric<Ljava/lang/String;>.MemberInnerNonGeneric
124: // _FieldGenericTestCase<Z>.MemberOuterGeneric<java.lang.String>.MemberInnerNonGeneric
125: public MemberOuterGeneric<String>.MemberInnerNonGeneric f;
126: }
127: ParameterizedType innerType = getParameterizedType(Test.class);
128: assertEquals(MemberOuterGeneric.MemberInnerNonGeneric.class,
129: innerType.getRawType());
130: assertEquals(0, innerType.getActualTypeArguments().length);
131: ParameterizedType outerType = (ParameterizedType) innerType
132: .getOwnerType();
133: assertEquals(MemberOuterGeneric.class, outerType.getRawType());
134: assertEquals(String.class, singleton(outerType
135: .getActualTypeArguments()));
136: assertThisType(outerType.getOwnerType());
137: }
138:
139: public void testStaticMemberOuterGeneric() {
140: class Test {
141: // _FieldGenericTestCase$StaticMemberOuterGeneric<Ljava/lang/String;>.MemberInnerNonGeneric
142: // _FieldGenericTestCase._FieldGenericTestCase$StaticMemberOuterGeneric<java.lang.String>.MemberInnerNonGeneric
143: public StaticMemberOuterGeneric<String>.MemberInnerNonGeneric f;
144: }
145: ParameterizedType innerType = getParameterizedType(Test.class);
146: assertEquals(
147: StaticMemberOuterGeneric.MemberInnerNonGeneric.class,
148: innerType.getRawType());
149: assertEquals(0, innerType.getActualTypeArguments().length);
150: ParameterizedType outerType = (ParameterizedType) innerType
151: .getOwnerType();
152: assertEquals(StaticMemberOuterGeneric.class, outerType
153: .getRawType());
154: assertEquals(String.class, singleton(outerType
155: .getActualTypeArguments()));
156: assertEquals(this .getClass(), outerType.getOwnerType());
157: }
158:
159: private void assertThisType(Type this Type) {
160: ParameterizedType type = (ParameterizedType) this Type;
161: assertEquals(this .getClass(), type.getRawType());
162: assertNull(type.getOwnerType());
163: assertVariable(singleton(type.getActualTypeArguments()));
164: }
165:
166: private void assertVariable(Type type) {
167: TypeVariable variable = (TypeVariable) type;
168: assertEquals("Z", variable.getName());
169: assertEquals(this .getClass(), variable.getGenericDeclaration());
170: assertEquals(Object.class, singleton(variable.getBounds()));
171: }
172: }
|