2.4/dev/core/test/com/google/gwt/dev/javac/typemodel/JGenericTypeTest.java

/*
 * 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;
  }
}