Java example source code file (TypeResolverTest.java)

This example Java source code file (TypeResolverTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

illegalargumentexception, integer, list, map, number, parameterizedtype, reflection, string, type, typecapture, typedkeymap, typeresolver, util

The TypeResolverTest.java Java example source code

/*
 * 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
 */
@AndroidIncompatible // lots of failures, possibly some related to bad equals() implementations?
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() {}.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 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() {}.capture(),
            new TypeCapture<List() {}.capture())
        .resolveType(t));
    assertEquals(Types.subtypeOf(String.class), new TypeResolver()
        .where(new TypeCapture<List() {}.capture(),
            new TypeCapture<List() {}.capture())
        .resolveType(t));
    assertEquals(Types.supertypeOf(String.class), new TypeResolver()
        .where(new TypeCapture<List() {}.capture(),
            new TypeCapture<List() {}.capture())
        .resolveType(t));
  }

  public <T> void testWhere_wildcardTypeMapping() {
    Type t = new TypeCapture<T>() {}.capture();
    assertEquals(String.class, new TypeResolver()
        .where(new TypeCapture<List() {}.capture(),
            new TypeCapture<List() {}.capture())
        .resolveType(t));
    assertEquals(String.class, new TypeResolver()
        .where(new TypeCapture<List() {}.capture(),
            new TypeCapture<List() {}.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() {}.capture(), List.class);
      fail();
    } catch (IllegalArgumentException expected) {}
  }

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

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

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

  public <T> void testWhere_incompatibleWildcardBounds() {
    try {
      new TypeResolver().where(
          new TypeCapture<List() {}.capture(),
          new TypeCapture<List() {}.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() {}.capture(), aTypeVariable());
      fail();
    } catch (IllegalArgumentException expected) {}
  }

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

  public <K, V> void testWhere_actualArgHasWildcard() {
    TypeResolver resolver = new TypeResolver().where(
        new TypeCapture<Iterable>() {}.capture(),
        new TypeCapture<Iterable>() {}.capture());
    assertEquals(
        new TypeCapture<K>() {}.capture(), resolver.resolveType(new TypeCapture() {}.capture()));
    assertEquals(
        Integer.class, resolver.resolveType(new TypeCapture<V>() {}.capture()));
  }

  public <T> void testWhere_mapFromWildcard() {
    Type subtype = new TypeCapture<TypedKeyMap() {}.capture();
    assertEquals(new TypeCapture<TypedKeyMap() {}.capture(),
        new TypeResolver()
            .where(
                new TypeCapture<Map() {}.capture(),
                new TypeCapture<Map() {}.capture())
        .resolveType(subtype));
  }

  public <T> void testWhere_mapFromWildcardToParameterized() {
    Type subtype = new TypeCapture<TypedListKeyMap() {}.capture();
    assertEquals(new TypeCapture<TypedListKeyMap() {}.capture(),
        new TypeResolver()
            .where(
                new TypeCapture<Map>() {}.capture(),
                new TypeCapture<Map() {}.capture())
        .resolveType(subtype));
  }

  public <T> void testWhere_mapFromBoundedWildcard() {
    Type subtype = new TypeCapture<TypedKeyMap() {}.capture();
    // TODO(benyu): This should check equality to an expected value, see discussion in cl/98674873
    Type unused =
        new TypeResolver()
            .where(
                new TypeCapture<Map() {}.capture(),
                new TypeCapture<Map() {}.capture())
            .resolveType(subtype);
  }

  interface TypedKeyMap<T> extends Map {}
  interface TypedListKeyMap<T> extends Map, T> {}

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

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