guava-tests/test/com/google/common/reflect/TypeResolverTest.java

/*
 * Copyright (C) 2012 The Guava Authors
 *
 * 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.common.reflect;

import junit.framework.TestCase;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

/**
 * Unit tests of {@link TypeResolver}.
 *
 * @author Ben Yu
 */
public class TypeResolverTest extends TestCase {

  public void testWhere_noMapping() {
    Type t = aTypeVariable();
    assertEquals(t, new TypeResolver().resolveType(t));
  }

  public void testWhere_typeVariableMapping() {
    Type t = aTypeVariable();
    assertEquals(String.class, new TypeResolver().where(t, String.class).resolveType(t));
  }

  public <T> void testWhere_indirectMapping() {
    Type t1 = new TypeCapture<T>() {}.capture();
    Type t2 = aTypeVariable();
    assertEquals(String.class,
        new TypeResolver().where(t1, t2).where(t2, String.class).resolveType(t1));
  }

  public void testWhere_typeVariableSelfMapping() {
    TypeResolver resolver = new TypeResolver();
    Type t = aTypeVariable();
    assertEquals(t, resolver.where(t, t).resolveType(t));
  }

  public <T> void testWhere_parameterizedSelfMapping() {
    TypeResolver resolver = new TypeResolver();
    Type t = new TypeCapture<List<T>>() {}.capture();
    assertEquals(t, resolver.where(t, t).resolveType(t));
  }

  public <T> void testWhere_genericArraySelfMapping() {
    TypeResolver resolver = new TypeResolver();
    Type t = new TypeCapture<T[]>() {}.capture();
    assertEquals(t, resolver.where(t, t).resolveType(t));
  }

  public <T> void testWhere_rawClassSelfMapping() {
    TypeResolver resolver = new TypeResolver();
    assertEquals(String.class,
        resolver.where(String.class, String.class).resolveType(String.class));
  }

  public <T> void testWhere_wildcardSelfMapping() {
    TypeResolver resolver = new TypeResolver();
    Type t = aWildcardType();
    assertEquals(t, resolver.where(t, t).resolveType(t));
  }

  public <T> void testWhere_duplicateMapping() {
    Type t = aTypeVariable();
    TypeResolver resolver = new TypeResolver().where(t, String.class);
    try {
      resolver.where(t, String.class);
      fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T1, T2 extends List<T1>> void testWhere_recursiveMapping() {
    Type t1 = new TypeCapture<T1>() {}.capture();
    Type t2 = new TypeCapture<T2>() {}.capture();
    assertEquals(t2, new TypeResolver().where(t1, t2).resolveType(t1));
  }

  public <T> void testWhere_genericArrayMapping() {
    Type t = new TypeCapture<T>() {}.capture();
    assertEquals(String.class, new TypeResolver()
        .where(new TypeCapture<T[]>() {}.capture(), String[].class)
        .resolveType(t));
  }

  public <T> void testWhere_primitiveArrayMapping() {
    Type t = new TypeCapture<T>() {}.capture();
    assertEquals(int.class,
        new TypeResolver().where(new TypeCapture<T[]>() {}.capture(), int[].class).resolveType(t));
  }

  public <T> void testWhere_parameterizedTypeMapping() {
    Type t = new TypeCapture<T>() {}.capture();
    assertEquals(String.class, new TypeResolver()
        .where(new TypeCapture<List<T>>() {}.capture(),
            new TypeCapture<List<String>>() {}.capture())
        .resolveType(t));
    assertEquals(Types.subtypeOf(String.class), new TypeResolver()
        .where(new TypeCapture<List<T>>() {}.capture(),
            new TypeCapture<List<? extends String>>() {}.capture())
        .resolveType(t));
    assertEquals(Types.supertypeOf(String.class), new TypeResolver()
        .where(new TypeCapture<List<T>>() {}.capture(),
            new TypeCapture<List<? super String>>() {}.capture())
        .resolveType(t));
  }

  public <T> void testWhere_wildcardTypeMapping() {
    Type t = new TypeCapture<T>() {}.capture();
    assertEquals(String.class, new TypeResolver()
        .where(new TypeCapture<List<? extends T>>() {}.capture(),
            new TypeCapture<List<? extends String>>() {}.capture())
        .resolveType(t));
    assertEquals(String.class, new TypeResolver()
        .where(new TypeCapture<List<? super T>>() {}.capture(),
            new TypeCapture<List<? super String>>() {}.capture())
        .resolveType(t));
  }

  public <T> void testWhere_incompatibleGenericArrayMapping() {
    try {
      new TypeResolver().where(new TypeCapture<T[]>() {}.capture(), String.class);
      fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T> void testWhere_incompatibleParameterizedTypeMapping() {
    try {
      new TypeResolver().where(new TypeCapture<Iterable<T>>() {}.capture(), List.class);
      fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T> void testWhere_impossibleParameterizedTypeMapping() {
    try {
      new TypeResolver().where(
          new TypeCapture<List<T>>() {}.capture(),
          new TypeCapture<Map<String, Integer>>() {}.capture());
      fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T> void testWhere_incompatibleWildcardUpperBound() {
    try {
      new TypeResolver().where(
          new TypeCapture<List<? extends String>>() {}.capture(),
          new TypeCapture<List<? extends Integer>>() {}.capture());
      fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T> void testWhere_incompatibleWildcardLowerBound() {
    try {
      new TypeResolver().where(
          new TypeCapture<List<? super String>>() {}.capture(),
          new TypeCapture<List<? super Integer>>() {}.capture());
      fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T> void testWhere_incompatibleWildcardBounds() {
    try {
      new TypeResolver().where(
          new TypeCapture<List<? extends T>>() {}.capture(),
          new TypeCapture<List<? super String>>() {}.capture());
      fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T> void testWhere_wrongOrder() {
    try {
      new TypeResolver().where(String.class, aTypeVariable());
     fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T> void testWhere_mapFromConcreteParameterizedType() {
    try {
      new TypeResolver().where(new TypeCapture<List<String>>() {}.capture(), aTypeVariable());
     fail();
    } catch (IllegalArgumentException expected) {}
  }

  public <T> void testWhere_mapFromConcreteGenericArrayType() {
    try {
      new TypeResolver().where(new TypeCapture<List<String>>() {}.capture(), aTypeVariable());
     fail();
    } catch (IllegalArgumentException expected) {}
  }

  private static <T> Type aTypeVariable() {
    return new TypeCapture<T>() {}.capture();
  }

  private static <T> Type aWildcardType() {
    ParameterizedType parameterizedType = (ParameterizedType)
        new TypeCapture<List<? extends T>>() {}.capture();
    return parameterizedType.getActualTypeArguments()[0];
  }
}