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 _FieldNonGenericTestCase extends TestCaseBase {
040:
041: class MemberOuterNonGeneric {
042: class MemberInnerGeneric<T> {
043: }
044: }
045:
046: class MemberOuterGeneric<T> {
047: class MemberInnerNonGeneric {
048: }
049: }
050:
051: public void testLocalNonGeneric() {
052: class LocalNonGeneric {
053: }
054: class Test {
055: // null
056: // class _FieldNonGenericTestCase$1LocalNonGeneric
057: public LocalNonGeneric f;
058: }
059: Type type = getType(Test.class);
060: assertEquals(LocalNonGeneric.class, type);
061: }
062:
063: public void testMemberNonGeneric() {
064: class Test {
065: // null
066: // class _FieldNonGenericTestCase$MemberOuterNonGeneric
067: public MemberOuterNonGeneric f;
068: }
069: Type type = getType(Test.class);
070: assertEquals(MemberOuterNonGeneric.class, type);
071: }
072:
073: public void testLocalGeneric() {
074: class LocalGeneric<T> {
075: }
076: class Test {
077: // _FieldNonGenericTestCase$1LocalGeneric<Ljava/lang/String;>
078: // _FieldNonGenericTestCase$1LocalGeneric<java.lang.String>
079: public LocalGeneric<String> f;
080: }
081: ParameterizedType type = getParameterizedType(Test.class);
082: assertEquals(LocalGeneric.class, type.getRawType());
083: assertEquals(String.class, singleton(type
084: .getActualTypeArguments()));
085: assertNull(type.getOwnerType());
086: }
087:
088: public void testMemberGeneric() {
089: class Test {
090: // _FieldNonGenericTestCase$MemberOuterGeneric<Ljava/lang/String;>
091: // _FieldNonGenericTestCase._FieldNonGenericTestCase$MemberOuterGeneric<java.lang.String>
092: public MemberOuterGeneric<String> f;
093: }
094: ParameterizedType type = getParameterizedType(Test.class);
095: assertEquals(MemberOuterGeneric.class, type.getRawType());
096: assertEquals(String.class, singleton(type
097: .getActualTypeArguments()));
098: assertEquals(this .getClass(), type.getOwnerType());
099: }
100:
101: public void testLocalInnerGeneric() {
102: class LocalNonGeneric {
103: class LocalInnerGeneric<T> {
104: }
105: }
106: class Test {
107: // _FieldNonGenericTestCase$2LocalNonGeneric$LocalInnerGeneric<Ljava/lang/Integer;>
108: // _FieldNonGenericTestCase$2LocalNonGeneric._FieldNonGenericTestCase$2LocalNonGeneric$LocalInnerGeneric<java.lang.Integer>
109: public LocalNonGeneric.LocalInnerGeneric<Integer> f;
110: }
111: ParameterizedType innerType = getParameterizedType(Test.class);
112: assertEquals(LocalNonGeneric.LocalInnerGeneric.class, innerType
113: .getRawType());
114: assertEquals(Integer.class, singleton(innerType
115: .getActualTypeArguments()));
116: assertEquals(LocalNonGeneric.class, innerType.getOwnerType());
117: }
118:
119: public void testMemberInnerGeneric() {
120: class Test {
121: // _FieldNonGenericTestCase$MemberOuterNonGeneric$MemberInnerGeneric<Ljava/lang/Integer;>
122: // _FieldNonGenericTestCase$MemberOuterNonGeneric._FieldNonGenericTestCase$MemberOuterNonGeneric$MemberInnerGeneric<java.lang.Integer>
123: public MemberOuterNonGeneric.MemberInnerGeneric<Integer> f;
124: }
125: ParameterizedType innerType = getParameterizedType(Test.class);
126: assertEquals(MemberOuterNonGeneric.MemberInnerGeneric.class,
127: innerType.getRawType());
128: assertEquals(Integer.class, singleton(innerType
129: .getActualTypeArguments()));
130: assertEquals(MemberOuterNonGeneric.class, innerType
131: .getOwnerType());
132: }
133:
134: public void testLocalOuterGeneric() {
135: class LocalGeneric<T> {
136: class LocalInnerGeneric {
137: }
138: }
139: class Test {
140: // _FieldNonGenericTestCase$2LocalGeneric<Ljava/lang/String;>.LocalInnerGeneric
141: // _FieldNonGenericTestCase$2LocalGeneric<java.lang.String>.LocalInnerGeneric
142: public LocalGeneric<String>.LocalInnerGeneric f;
143: }
144: ParameterizedType innerType = getParameterizedType(Test.class);
145: assertEquals(LocalGeneric.LocalInnerGeneric.class, innerType
146: .getRawType());
147: assertEquals(0, innerType.getActualTypeArguments().length);
148: ParameterizedType outerType = (ParameterizedType) innerType
149: .getOwnerType();
150: assertEquals(LocalGeneric.class, outerType.getRawType());
151: assertEquals(String.class, singleton(outerType
152: .getActualTypeArguments()));
153: assertNull(outerType.getOwnerType());
154: }
155:
156: public void testMemberOuterGeneric() {
157: class Test {
158: // _FieldNonGenericTestCase$MemberOuterGeneric<Ljava/lang/String;>.MemberInnerNonGeneric
159: // _FieldNonGenericTestCase._FieldNonGenericTestCase$MemberOuterGeneric<java.lang.String>.MemberInnerNonGeneric
160: public MemberOuterGeneric<String>.MemberInnerNonGeneric f;
161: }
162: ParameterizedType innerType = getParameterizedType(Test.class);
163: assertEquals(MemberOuterGeneric.MemberInnerNonGeneric.class,
164: innerType.getRawType());
165: assertEquals(0, innerType.getActualTypeArguments().length);
166: ParameterizedType outerType = (ParameterizedType) innerType
167: .getOwnerType();
168: assertEquals(MemberOuterGeneric.class, outerType.getRawType());
169: assertEquals(String.class, singleton(outerType
170: .getActualTypeArguments()));
171: assertEquals(this.getClass(), outerType.getOwnerType());
172: }
173:
174: }
|