001: /*
002: * Copyright 2007 Google Inc.
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License"); you may not
005: * use this file except in compliance with the License. You may obtain a copy of
006: * the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
012: * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
013: * License for the specific language governing permissions and limitations under
014: * the License.
015: */
016: package com.google.gwt.core.ext.typeinfo;
017:
018: import com.google.gwt.core.ext.TreeLogger;
019: import com.google.gwt.core.ext.UnableToCompleteException;
020: import com.google.gwt.core.ext.typeinfo.test.CA;
021: import com.google.gwt.core.ext.typeinfo.test.CB;
022: import com.google.gwt.core.ext.typeinfo.test.CC;
023: import com.google.gwt.dev.util.log.PrintWriterTreeLogger;
024:
025: import java.util.Arrays;
026: import java.util.HashSet;
027: import java.util.Set;
028:
029: /**
030: * Test for {@link JWildcardType}.
031: */
032: public class JWildcardTypeTest extends JDelegatingClassTypeTestBase {
033: private final boolean logToConsole = false;
034: private final ModuleContext moduleContext = new ModuleContext(
035: logToConsole ? new PrintWriterTreeLogger()
036: : TreeLogger.NULL,
037: "com.google.gwt.core.ext.typeinfo.TypeOracleTest");
038:
039: public JWildcardTypeTest() throws UnableToCompleteException {
040: }
041:
042: @Override
043: public void testFindConstructor() {
044: // Wildcard types do not have constructors
045: }
046:
047: @Override
048: public void testFindNestedType() {
049: // Wildcard do not have nested types...
050: }
051:
052: @Override
053: public void testGetConstructors() {
054: }
055:
056: @Override
057: public void testGetEnclosingType() {
058: // Wildcard do not have nested types...
059: }
060:
061: public void testGetMethods() throws NotFoundException {
062: super .testGetMethods();
063: }
064:
065: @Override
066: public void testGetNestedType() {
067: // No nested types
068: }
069:
070: @Override
071: public void testGetNestedTypes() {
072: // No nested types
073: }
074:
075: @Override
076: public void testGetOverridableMethods() {
077: // No overridable methods
078: }
079:
080: @Override
081: public void testGetSubtypes() {
082: // Tested by testGetSubtypes_LowerBound() and testGetSubtypes_UpperBound()
083: }
084:
085: public void testGetSubtypes_LowerBound() throws NotFoundException {
086: TypeOracle oracle = moduleContext.getOracle();
087: // <? super Number>
088: JWildcardType lowerBoundWildcard = oracle
089: .getWildcardType(new JLowerBound(oracle
090: .getType(Number.class.getName())));
091: JClassType[] subtypes = lowerBoundWildcard.getSubtypes();
092: assertEquals(0, subtypes.length);
093: // assertEquals(oracle.getJavaLangObject(), subtypes[0]);
094: }
095:
096: public void testGetSubtypes_UpperBound() throws NotFoundException {
097: TypeOracle oracle = moduleContext.getOracle();
098: // <? extends CA>
099: JWildcardType upperBoundWildcard = oracle
100: .getWildcardType(new JUpperBound(oracle
101: .getType(CA.class.getName())));
102:
103: JClassType[] expected = new JClassType[] {
104: oracle.getType(CB.class.getName()),
105: oracle.getType(CC.class.getName()) };
106: Set<JClassType> expectedSet = new HashSet<JClassType>();
107: expectedSet.addAll(Arrays.asList(expected));
108:
109: JClassType[] actual = upperBoundWildcard.getSubtypes();
110: assertEquals(expectedSet.size(), actual.length);
111:
112: for (int i = 0; i < actual.length; ++i) {
113: expectedSet.remove(actual[i]);
114: }
115: assertTrue(expectedSet.isEmpty());
116: }
117:
118: @Override
119: public void testIsAssignableFrom() {
120: // Covered by the different testIsAssignableFrom*() variants below.
121: }
122:
123: /**
124: * Tests that <? extends Number> is assignable from <? extends Integer> and
125: * that the reverse is not <code>true</code>.
126: */
127: public void testIsAssignableFrom_Extends_Number_To_Extends_Integer()
128: throws NotFoundException {
129: TypeOracle oracle = moduleContext.getOracle();
130: JClassType numberType = oracle.getType(Number.class.getName());
131: JClassType integerType = oracle
132: .getType(Integer.class.getName());
133:
134: JUpperBound numberBound = new JUpperBound(numberType);
135: JUpperBound integerBound = new JUpperBound(integerType);
136:
137: JWildcardType numberWildcard = oracle
138: .getWildcardType(numberBound);
139: JWildcardType integerWildcard = oracle
140: .getWildcardType(integerBound);
141:
142: assertTrue(numberWildcard.isAssignableFrom(integerWildcard));
143: assertFalse(integerWildcard.isAssignableFrom(numberWildcard));
144: }
145:
146: /**
147: * Tests that <? extends Number> is assignable from <? extends Integer> and
148: * that the reverse is not <code>true</code>.
149: */
150: public void testIsAssignableFrom_Extends_Object_From_Super_Object() {
151: TypeOracle oracle = moduleContext.getOracle();
152:
153: JClassType javaLangObject = oracle.getJavaLangObject();
154: JLowerBound lowerBound = new JLowerBound(javaLangObject);
155: JUpperBound upperBound = new JUpperBound(javaLangObject);
156:
157: JWildcardType lowerWildcard = oracle
158: .getWildcardType(lowerBound);
159: JWildcardType upperWildcard = oracle
160: .getWildcardType(upperBound);
161:
162: assertTrue(upperWildcard.isAssignableFrom(lowerWildcard));
163: assertFalse(lowerWildcard.isAssignableFrom(upperWildcard));
164: }
165:
166: /**
167: * Tests that <? super Integer> is assignable from <? super Number> and that
168: * the reverse is not <code>true</code>.
169: */
170: public void testIsAssignableFrom_Super_Integer_From_Super_Number()
171: throws NotFoundException {
172: TypeOracle oracle = moduleContext.getOracle();
173: JClassType numberType = oracle.getType(Number.class.getName());
174: JClassType integerType = oracle
175: .getType(Integer.class.getName());
176:
177: JLowerBound numberBound = new JLowerBound(numberType);
178: JLowerBound integerBound = new JLowerBound(integerType);
179:
180: JWildcardType numberWildcard = oracle
181: .getWildcardType(numberBound);
182: JWildcardType integerWildcard = oracle
183: .getWildcardType(integerBound);
184:
185: assertFalse(numberWildcard.isAssignableFrom(integerWildcard));
186: assertTrue(numberWildcard.isAssignableTo(integerWildcard));
187: assertTrue(integerWildcard.isAssignableFrom(numberWildcard));
188: assertFalse(integerWildcard.isAssignableTo(numberWildcard));
189: }
190:
191: /**
192: * Tests that <? super Number> is assignable to <? super Integer> and that the
193: * reverse is not <code>true</code>.
194: */
195: public void testIsAssignableFrom_Super_Number_To_Super_Integer()
196: throws NotFoundException {
197: TypeOracle oracle = moduleContext.getOracle();
198: JClassType numberType = oracle.getType(Number.class.getName());
199: JClassType integerType = oracle
200: .getType(Integer.class.getName());
201:
202: JLowerBound numberBound = new JLowerBound(numberType);
203: JLowerBound integerBound = new JLowerBound(integerType);
204:
205: JWildcardType numberWildcard = oracle
206: .getWildcardType(numberBound);
207: JWildcardType integerWildcard = oracle
208: .getWildcardType(integerBound);
209:
210: assertTrue(numberWildcard.isAssignableTo(integerWildcard));
211: assertFalse(integerWildcard.isAssignableTo(numberWildcard));
212: }
213:
214: @Override
215: public void testIsAssignableTo() {
216: // NOTE These cases were tested as part of testIsAssignableFrom.
217: }
218:
219: /**
220: * Tests that <? extends Integer> is assignable to <? extends Number> and that
221: * the reverse is not <code>true</code>.
222: */
223: public void testIsAssignableTo_Extends_Integer_To_Extends_Number()
224: throws NotFoundException {
225: TypeOracle oracle = moduleContext.getOracle();
226: JClassType numberType = oracle.getType(Number.class.getName());
227: JClassType integerType = oracle
228: .getType(Integer.class.getName());
229:
230: JUpperBound numberBound = new JUpperBound(numberType);
231: JUpperBound integerBound = new JUpperBound(integerType);
232:
233: JWildcardType numberWildcard = oracle
234: .getWildcardType(numberBound);
235: JWildcardType integerWildcard = oracle
236: .getWildcardType(integerBound);
237:
238: assertTrue(integerWildcard.isAssignableTo(numberWildcard));
239: assertFalse(numberWildcard.isAssignableTo(integerWildcard));
240: }
241:
242: /**
243: * Tests that <? super Number> is assignable to <? super Integer> and that
244: * the reverse is not <code>true</code>.
245: */
246: public void testIsAssignableTo_Super_Number_To_Super_Integer()
247: throws NotFoundException {
248: TypeOracle oracle = moduleContext.getOracle();
249: JClassType numberType = oracle.getType(Number.class.getName());
250: JClassType integerType = oracle
251: .getType(Integer.class.getName());
252:
253: JLowerBound numberBound = new JLowerBound(numberType);
254: JLowerBound integerBound = new JLowerBound(integerType);
255:
256: JWildcardType numberWildcard = oracle
257: .getWildcardType(numberBound);
258: JWildcardType integerWildcard = oracle
259: .getWildcardType(integerBound);
260:
261: assertFalse(integerWildcard.isAssignableTo(numberWildcard));
262: assertTrue(numberWildcard.isAssignableTo(integerWildcard));
263: }
264:
265: @Override
266: protected Substitution getSubstitution() {
267: return new Substitution() {
268: public JType getSubstitution(JType type) {
269: return type;
270: }
271: };
272: }
273:
274: @Override
275: protected JWildcardType getTestType() throws NotFoundException {
276: TypeOracle oracle = moduleContext.getOracle();
277: return oracle.getWildcardType(new JUpperBound(oracle
278: .getType(Number.class.getName())));
279: }
280: }
|