| /* |
| * Copyright 2008 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.dev.javac.typemodel; |
| |
| import com.google.gwt.core.ext.TreeLogger; |
| import com.google.gwt.core.ext.UnableToCompleteException; |
| import com.google.gwt.core.ext.typeinfo.NotFoundException; |
| import com.google.gwt.dev.javac.typemodel.test.GenericClass; |
| import com.google.gwt.dev.javac.typemodel.test.GenericClassWithDependentTypeBounds; |
| import com.google.gwt.dev.javac.typemodel.test.GenericClassWithTypeBound; |
| import com.google.gwt.dev.util.log.PrintWriterTreeLogger; |
| |
| import junit.framework.TestCase; |
| |
| import java.io.Serializable; |
| |
| /** |
| * Tests for {@link JGenericType}. |
| */ |
| public class JGenericTypeTest extends TestCase { |
| private final boolean logToConsole = false; |
| private final ModuleContext moduleContext = new ModuleContext(logToConsole |
| ? new PrintWriterTreeLogger() : TreeLogger.NULL, |
| "com.google.gwt.dev.javac.typemodel.TypeOracleTest"); |
| |
| public JGenericTypeTest() throws UnableToCompleteException { |
| } |
| |
| /** |
| * Test method for |
| * {@link com.google.gwt.core.ext.typeinfo.JGenericType#getTypeParameters()}. |
| * This test goes beyond |
| * {@link com.google.gwt.core.ext.typeinfo.JGenericTypeTest#testGetTypeParameters()} |
| * by testing generic types that have type parameters which are dependent on |
| * one another. |
| * |
| * NOTE: This test does not make use of the |
| * {@link com.google.gwt.core.ext.typeinfo.JGenericTypeTest#getTestType()} |
| * method. The test types used are: |
| * {@link GenericClassWithDependentTypeBounds} |
| * {@link GenericClassWithTypeBound} |
| * |
| * @throws NotFoundException |
| */ |
| public void testGetDependentTypeParameters() throws NotFoundException { |
| |
| TypeOracle oracle = moduleContext.getOracle(); |
| |
| // Get the generic type |
| |
| JClassType type = oracle.getType(GenericClassWithDependentTypeBounds.class.getName()); |
| JGenericType genericType = type.isGenericType(); |
| assertNotNull(genericType); |
| |
| // Get its type parameters |
| |
| JTypeParameter[] typeParameters = genericType.getTypeParameters(); |
| assertEquals(2, typeParameters.length); |
| |
| // Examine the first type parameter. Its name should be 'C'. |
| |
| JTypeParameter typeParameter = typeParameters[0]; |
| assertEquals("C", typeParameter.getName()); |
| |
| // Check the bound of the first type parameter. It should be a single |
| // upper bound. |
| JClassType[] genericTypeBounds = typeParameter.getBounds(); |
| assertEquals(1, genericTypeBounds.length); |
| |
| // Check to see that the upper bound is a parameterized type. |
| |
| JClassType upperBoundType = genericTypeBounds[0]; |
| JParameterizedType upperBoundParameterizedType = upperBoundType.isParameterized(); |
| assertNotNull(upperBoundParameterizedType); |
| |
| // Examine the parameterized type. Its name should be |
| // 'GenericClassWithTypeBound'. The base type of the parameterized type |
| // should be a reference to the class 'GenericClassWithTypeBound'. |
| |
| assertEquals("GenericClassWithTypeBound", |
| upperBoundParameterizedType.getName()); |
| assertEquals(upperBoundParameterizedType.getBaseType(), |
| oracle.getType(GenericClassWithTypeBound.class.getName())); |
| |
| // Check the type arguments for the parameterized type. There should be a |
| // single type argument. |
| |
| JClassType[] typeArgs = upperBoundParameterizedType.getTypeArgs(); |
| assertEquals(1, typeArgs.length); |
| |
| // Examine the first type argument. It should be a type parameter. |
| |
| JClassType typeArg = typeArgs[0]; |
| JTypeParameter typeArgTypeParameter = typeArg.isTypeParameter(); |
| assertNotNull(typeArgTypeParameter); |
| |
| // Check the name of the type parameter. It should be 'M'. |
| |
| assertEquals("M", typeArgTypeParameter.getName()); |
| |
| // Check the bound of the type parameter. It should have a single upper |
| // bound. |
| JClassType[] typeArgBounds = typeArgTypeParameter.getBounds(); |
| assertEquals(1, typeArgBounds.length); |
| |
| // Verify that the bound type is actually a reference to |
| // java.io.Serializable. |
| |
| JClassType typeArgUpperBoundType = typeArgBounds[0]; |
| assertEquals(typeArgUpperBoundType, |
| oracle.getType(Serializable.class.getName())); |
| |
| // Now look at the second type parameter on the generic type. It should |
| // be identical to the type argument of the the first type parameter |
| // (remember, the first type parameter was a paramaterized type). |
| |
| JTypeParameter secondTypeParameter = typeParameters[1]; |
| assertEquals(secondTypeParameter, typeArgTypeParameter); |
| } |
| |
| /** |
| * Test method for |
| * {@link com.google.gwt.core.ext.typeinfo.JGenericType#getErasedType()}. |
| * |
| * @throws NotFoundException |
| */ |
| public void testGetErasedType() throws NotFoundException { |
| JGenericType genericClass = getTestType(); |
| |
| assertEquals(genericClass.getRawType(), genericClass.getErasedType()); |
| } |
| |
| /** |
| * Test method for |
| * {@link com.google.gwt.core.ext.typeinfo.JGenericType#getRawType()}. |
| * |
| * @throws NotFoundException |
| */ |
| public void testGetRawType() throws NotFoundException { |
| JGenericType genericClass = getTestType(); |
| |
| JDelegatingClassTypeTestBase.validateTypeSubstitution(genericClass, |
| genericClass.getRawType(), new Substitution() { |
| public JClassType getSubstitution(JClassType type) { |
| return type.getErasedType(); |
| } |
| }); |
| } |
| |
| /** |
| * Test method for |
| * {@link com.google.gwt.core.ext.typeinfo.JGenericType#getTypeParameters()}. |
| * |
| * @throws NotFoundException |
| */ |
| public void testGetTypeParameters() throws NotFoundException { |
| JGenericType genericType = getTestType(); |
| JTypeParameter[] typeParameters = genericType.getTypeParameters(); |
| |
| assertEquals(1, typeParameters.length); |
| |
| JTypeParameter typeParameter = typeParameters[0]; |
| assertEquals("T", typeParameter.getName()); |
| |
| JClassType[] bounds = typeParameter.getBounds(); |
| assertEquals(1, bounds.length); |
| assertEquals( |
| moduleContext.getOracle().getType(Serializable.class.getName()), |
| bounds[0]); |
| } |
| |
| /** |
| * Test method for |
| * {@link com.google.gwt.core.ext.typeinfo.JGenericType#isAssignableFrom(JClassType)} |
| * . |
| * |
| * @throws NotFoundException |
| */ |
| public void testIsAssignableFrom() throws NotFoundException { |
| JGenericType genericType = getTestType(); |
| |
| // Check that the generic type's superclass is assignable from the generic |
| // type |
| assertTrue(genericType.getSuperclass().isAssignableFrom(genericType)); |
| |
| // Check that each implemented interface is assignable from the generic type |
| JClassType[] implementedInterfaces = genericType.getImplementedInterfaces(); |
| for (JClassType implementedInterface : implementedInterfaces) { |
| assertTrue(implementedInterface.isAssignableFrom(genericType)); |
| assertTrue(implementedInterface.isAssignableFrom(genericType.getRawType())); |
| } |
| } |
| |
| /** |
| * Test method for |
| * {@link com.google.gwt.core.ext.typeinfo.JGenericType#isAssignableTo(JClassType)} |
| * . |
| * |
| * @throws NotFoundException |
| */ |
| public void testIsAssignableTo() throws NotFoundException { |
| JGenericType genericType = getTestType(); |
| |
| // Check that generic type is assignable to its superclass |
| assertTrue(genericType.isAssignableTo(genericType.getSuperclass())); |
| |
| // Check that the generic class is assignable to any implemented interface |
| JClassType[] implementedInterfaces = genericType.getImplementedInterfaces(); |
| for (JClassType implementedInterface : implementedInterfaces) { |
| assertTrue(genericType.isAssignableTo(implementedInterface)); |
| |
| if (implementedInterface.isParameterized() != null) { |
| assertTrue(genericType.isAssignableTo(implementedInterface.isParameterized().getRawType())); |
| } |
| } |
| } |
| |
| /** |
| * Returns the generic version of {@link GenericClass}. |
| */ |
| protected JGenericType getTestType() throws NotFoundException { |
| JClassType type = moduleContext.getOracle().getType( |
| GenericClass.class.getName()); |
| JGenericType genericType = type.isGenericType(); |
| assertNotNull(genericType); |
| return genericType; |
| } |
| } |