KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > net > sf > retrotranslator > runtime > java > lang > reflect > _FieldGenericTestCase


1 /***
2  * Retrotranslator: a Java bytecode transformer that translates Java classes
3  * compiled with JDK 5.0 into classes that can be run on JVM 1.4.
4  *
5  * Copyright (c) 2005 - 2007 Taras Puchko
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  * notice, this list of conditions and the following disclaimer in the
15  * documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the copyright holders nor the names of its
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30  * THE POSSIBILITY OF SUCH DAMAGE.
31  */

32 package net.sf.retrotranslator.runtime.java.lang.reflect;
33
34 import java.lang.reflect.*;
35 import net.sf.retrotranslator.tests.BaseTestCase;
36
37 /**
38  * @author Taras Puchko
39  */

40 public class _FieldGenericTestCase<Z> extends BaseTestCase {
41
42     class MemberOuterNonGeneric {
43     }
44
45     class MemberOuterGeneric<T> {
46         class MemberInnerNonGeneric {
47         }
48     }
49
50     static class StaticMemberOuterNonGeneric {
51     }
52
53     static class StaticMemberOuterGeneric<T> {
54         class MemberInnerNonGeneric {
55         }
56     }
57
58     public void testVariable() {
59         class Test {
60             // TZ;
61
// Z
62
public Z f;
63         }
64         Type type = getType(Test.class);
65         assertVariable(type);
66     }
67
68     public void testMemberNonGeneric() {
69         class Test {
70             // _FieldGenericTestCase<TZ;>.MemberOuterNonGeneric
71
// _FieldGenericTestCase<Z>.MemberOuterNonGeneric
72
public MemberOuterNonGeneric f;
73         }
74         ParameterizedType outerType = getParameterizedType(Test.class);
75         assertEquals(MemberOuterNonGeneric.class, outerType.getRawType());
76         assertEquals(0, outerType.getActualTypeArguments().length);
77         assertThisType(outerType.getOwnerType());
78     }
79
80     public void testStaticMemberNonGeneric() {
81         class Test {
82             // null
83
// class _FieldGenericTestCase$StaticMemberOuterNonGeneric
84
public StaticMemberOuterNonGeneric f;
85         }
86         Type type = getType(Test.class);
87         assertEquals(StaticMemberOuterNonGeneric.class, type);
88     }
89
90     public void testMemberGeneric() {
91         class Test {
92             // _FieldGenericTestCase<TZ;>.MemberOuterGeneric<-[TZ;>
93
// _FieldGenericTestCase<Z>.MemberOuterGeneric<? super Z[]>
94
public MemberOuterGeneric<? super Z[]> f;
95         }
96         ParameterizedType outerType = getParameterizedType(Test.class);
97         assertEquals(MemberOuterGeneric.class, outerType.getRawType());
98         WildcardType wildcardType = (WildcardType) singleton(outerType.getActualTypeArguments());
99         assertEquals(Object JavaDoc.class, singleton(wildcardType.getUpperBounds()));
100         GenericArrayType arrayType = (GenericArrayType) singleton(wildcardType.getLowerBounds());
101         assertVariable(arrayType.getGenericComponentType());
102         assertThisType(outerType.getOwnerType());
103     }
104
105     public void testStaticMemberGeneric() {
106         class Test {
107             // _FieldGenericTestCase$StaticMemberOuterGeneric<Ljava/lang/String;>
108
// _FieldGenericTestCase._FieldGenericTestCase$StaticMemberOuterGeneric<java.lang.String>
109
public StaticMemberOuterGeneric<String JavaDoc> f;
110         }
111         ParameterizedType type = getParameterizedType(Test.class);
112         assertEquals(StaticMemberOuterGeneric.class, type.getRawType());
113         assertEquals(String JavaDoc.class, singleton(type.getActualTypeArguments()));
114         assertEquals(this.getClass(), type.getOwnerType());
115     }
116
117     public void testMemberOuterGeneric() {
118         class Test {
119             // _FieldGenericTestCase<TZ;>.MemberOuterGeneric<Ljava/lang/String;>.MemberInnerNonGeneric
120
// _FieldGenericTestCase<Z>.MemberOuterGeneric<java.lang.String>.MemberInnerNonGeneric
121
public MemberOuterGeneric<String JavaDoc>.MemberInnerNonGeneric f;
122         }
123         ParameterizedType innerType = getParameterizedType(Test.class);
124         assertEquals(MemberOuterGeneric.MemberInnerNonGeneric.class, innerType.getRawType());
125         assertEquals(0, innerType.getActualTypeArguments().length);
126         ParameterizedType outerType = (ParameterizedType) innerType.getOwnerType();
127         assertEquals(MemberOuterGeneric.class, outerType.getRawType());
128         assertEquals(String JavaDoc.class, singleton(outerType.getActualTypeArguments()));
129         assertThisType(outerType.getOwnerType());
130     }
131
132     public void testStaticMemberOuterGeneric() {
133         class Test {
134             // _FieldGenericTestCase$StaticMemberOuterGeneric<Ljava/lang/String;>.MemberInnerNonGeneric
135
// _FieldGenericTestCase._FieldGenericTestCase$StaticMemberOuterGeneric<java.lang.String>.MemberInnerNonGeneric
136
public StaticMemberOuterGeneric<String JavaDoc>.MemberInnerNonGeneric f;
137         }
138         ParameterizedType innerType = getParameterizedType(Test.class);
139         assertEquals(StaticMemberOuterGeneric.MemberInnerNonGeneric.class, innerType.getRawType());
140         assertEquals(0, innerType.getActualTypeArguments().length);
141         ParameterizedType outerType = (ParameterizedType) innerType.getOwnerType();
142         assertEquals(StaticMemberOuterGeneric.class, outerType.getRawType());
143         assertEquals(String JavaDoc.class, singleton(outerType.getActualTypeArguments()));
144         assertEquals(this.getClass(), outerType.getOwnerType());
145     }
146
147     private void assertThisType(Type thisType) {
148         ParameterizedType type = (ParameterizedType) thisType;
149         assertEquals(this.getClass(), type.getRawType());
150         assertNull(type.getOwnerType());
151         assertVariable(singleton(type.getActualTypeArguments()));
152     }
153
154     private void assertVariable(Type type) {
155         TypeVariable variable = (TypeVariable) type;
156         assertEquals("Z", variable.getName());
157         assertEquals(this.getClass(), variable.getGenericDeclaration());
158         assertEquals(Object JavaDoc.class, singleton(variable.getBounds()));
159     }
160 }
161
Popular Tags