1 /*
2 * Copyright (c) 2004, 2008, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24
25 /*
26 * @test
27 * @bug 4853450 5009360 5055963
28 * @summary ClassType tests
29 * @library ../../lib
30 * @run main/othervm ClassTyp
31 */
32
33
34 import java.util.*;
35 import com.sun.mirror.declaration.*;
36 import com.sun.mirror.type.*;
37 import com.sun.mirror.util.*;
38
39
40 public class ClassTyp<T1,T2> extends Tester {
41
42 public static void main(String[] args) {
43 (new ClassTyp()).run();
44 }
45
46
47 // Declarations used by tests
48
49 static class C1<S> extends AbstractSet<S> implements Set<S> {
50 class C2<R> {
51 }
52
53 static class C3<R> {
54 class C4<Q> {
55 }
56 }
57
58 public Iterator<S> iterator() {
59 return null;
60 }
61
62 public int size() {
63 return 0;
64 }
65 }
66
67
68 // Generate some class types to test.
69 private C1<T1> f0;
70 private C1<String> f1;
71 private C1 f2;
72 private C1.C3<T2> f3;
73 private C1<T1>.C2<T2> f4;
74 private C1.C2 f5;
75 private C1<T1> f6;
76 private C1.C3<T2>.C4<T1> f7;
77 private static final int NUMTYPES = 8;
78
79 // Type mirrors corresponding to the types of the above fields
80 private ClassType[] t = new ClassType[NUMTYPES];
81
82 // One more type: our own.
83 private ClassTyp<T1,T2> me = this;
84
85
86 protected void init() {
87 for (int i = 0; i < t.length; i++) {
88 t[i] = (ClassType) getField("f"+i).getType();
89 }
90 }
91
92
93 // TypeMirror methods
94
95 @Test(result="class")
96 Collection<String> accept() {
97 final Collection<String> res = new ArrayList<String>();
98
99 t[0].accept(new SimpleTypeVisitor() {
100 public void visitReferenceType(ReferenceType t) {
101 res.add("ref type");
102 }
103 public void visitClassType(ClassType t) {
104 res.add("class");
105 }
106 public void visitInterfaceType(InterfaceType t) {
107 res.add("interface");
108 }
109 });
110 return res;
111 }
112
113 @Test(result="true")
114 boolean equals1() {
115 return t[0].equals(t[0]);
116 }
117
118 @Test(result="false")
119 boolean equals2() {
120 return t[0].equals(t[1]);
121 }
122
123 // Raw type is not same as type instantiated with unbounded type var.
124 @Test(result="false")
125 boolean equals3() {
126 return t[0].equals(t[2]);
127 }
128
129 // C1<T1> is same type as C1<T1>
130 @Test(result="true")
131 boolean equals4() {
132 return t[0].equals(t[6]);
133 }
134
135 @Test(result={
136 "ClassTyp.C1<T1>",
137 "ClassTyp.C1<java.lang.String>",
138 "ClassTyp.C1",
139 "ClassTyp.C1.C3<T2>",
140 "ClassTyp.C1<T1>.C2<T2>",
141 "ClassTyp.C1.C2",
142 "ClassTyp.C1<T1>",
143 "ClassTyp.C1.C3<T2>.C4<T1>"
144 },
145 ordered=true)
146 Collection<String> toStringTests() {
147 Collection<String> res = new ArrayList<String>();
148 for (ClassType c : t) {
149 res.add(c.toString());
150 }
151 return res;
152 }
153
154
155 // DeclaredType methods
156
157 @Test(result={"T1"})
158 Collection<TypeMirror> getActualTypeArguments1() {
159 return t[0].getActualTypeArguments();
160 }
161
162 @Test(result={})
163 Collection<TypeMirror> getActualTypeArguments2() {
164 return t[2].getActualTypeArguments();
165 }
166
167 @Test(result={"T2"})
168 Collection<TypeMirror> getActualTypeArguments3() {
169 return t[3].getActualTypeArguments();
170 }
171
172 @Test(result="null")
173 DeclaredType getContainingType1() {
174 ClassType thisType = (ClassType) getField("me").getType();
175 return thisType.getContainingType();
176 }
177
178 @Test(result="ClassTyp")
179 DeclaredType getContainingType2() {
180 return t[0].getContainingType();
181 }
182
183 @Test(result="ClassTyp.C1")
184 DeclaredType getContainingType3() {
185 return t[3].getContainingType();
186 }
187
188 @Test(result="ClassTyp.C1<T1>")
189 DeclaredType getContainingType4() {
190 return t[4].getContainingType();
191 }
192
193 @Test(result={"java.util.Set<T1>"})
194 Collection<InterfaceType> getSuperinterfaces() {
195 return t[0].getSuperinterfaces();
196 }
197
198
199 // ClassType methods
200
201 @Test(result="ClassTyp.C1<S>")
202 ClassDeclaration getDeclaration1() {
203 return t[0].getDeclaration();
204 }
205
206 @Test(result="ClassTyp.C1.C3<R>")
207 ClassDeclaration getDeclaration2() {
208 return t[3].getDeclaration();
209 }
210
211 @Test(result="ClassTyp.C1<S>.C2<R>")
212 ClassDeclaration getDeclaration3a() {
213 return t[4].getDeclaration();
214 }
215
216 @Test(result="ClassTyp.C1<S>.C2<R>")
217 ClassDeclaration getDeclaration3b() {
218 return t[5].getDeclaration();
219 }
220
221 @Test(result="true")
222 boolean getDeclarationEq() {
223 return t[0].getDeclaration() == t[6].getDeclaration();
224 }
225
226 @Test(result="java.util.AbstractSet<T1>")
227 ClassType getSuperclass1() {
228 return t[0].getSuperclass();
229 }
230
231 @Test(result="java.lang.Object")
232 ClassType getSuperclass2() {
233 return t[4].getSuperclass();
234 }
235
236 @Test(result="null")
237 ClassType getSuperclassOfObject() {
238 return t[4].getSuperclass().getSuperclass();
239 }
240 }