assertThat(new TypeToken<Object>() {}.getGenericSuperclass()).isNull();
    assertEquals(TypeToken.of(Object.class), new TypeToken<Object[]>() {}.getGenericSuperclass());
    assertThat(new TypeToken<List<String>>() {}.getGenericSuperclass()).isNull();
    assertEquals(
        TypeToken.of(Object.class), new TypeToken<List<String>[]>() {}.getGenericSuperclass());
  }

    assertThat(new TypeToken<Object>() {}.getGenericSuperclass()).isNull();
    assertEquals(TypeToken.of(Object.class), new TypeToken<Object[]>() {}.getGenericSuperclass());
    assertThat(new TypeToken<List<String>>() {}.getGenericSuperclass()).isNull();
    assertEquals(
        TypeToken.of(Object.class), new TypeToken<List<String>[]>() {}.getGenericSuperclass());
  }

/**
 * Captures the actual type of {@code T}.
 *
 * @author Ben Yu
 */
abstract class TypeCapture<T> {

  /** Returns the captured type. */
  final Type capture() {
    Type superclass = getClass().getGenericSuperclass();
    checkArgument(superclass instanceof ParameterizedType, "%s isn't parameterized", superclass);
    return ((ParameterizedType) superclass).getActualTypeArguments()[0];
  }

    assertThat(ourType.getOwnerType()).isNull();
  }

  public void testNewParameterizedType_nonStaticLocalClass() {
    class LocalClass<T> {}
    Type jvmType = new LocalClass<String>() {}.getClass().getGenericSuperclass();
    Type ourType = Types.newParameterizedType(LocalClass.class, String.class);
    assertEquals(jvmType, ourType);
  }

  public void testNewParameterizedType_staticLocalClass() {

   * Object} or an interface. This method is similar but different from {@link
   * Class#getGenericSuperclass}. For example, {@code new TypeToken<StringArrayList>()
   * {}.getGenericSuperclass()} will return {@code new TypeToken<ArrayList<String>>() {}}; while
   * {@code StringArrayList.class.getGenericSuperclass()} will return {@code ArrayList<E>}, where
   * {@code E} is the type variable declared by class {@code ArrayList}.
   *

 *
 * @author Ben Yu
 */
@NullUnmarked
public class TypeVisitorTest extends TestCase {

  public void testVisitNull() {
    new BaseTypeVisitor()
        .visit(((ParameterizedType) ArrayList.class.getGenericSuperclass()).getOwnerType());
  }

  public void testVisitClass() {
    assertVisited(String.class);
    new BaseTypeVisitor() {
      @Override
      void visitClass(Class<?> t) {}
    }.visit(String.class);
  }

 *
 * @author Ben Yu
 */
@NullUnmarked
public class TypeVisitorTest extends TestCase {

  public void testVisitNull() {
    new BaseTypeVisitor()
        .visit(((ParameterizedType) ArrayList.class.getGenericSuperclass()).getOwnerType());
  }

  public void testVisitClass() {
    assertVisited(String.class);
    new BaseTypeVisitor() {
      @Override
      void visitClass(Class<?> t) {}
    }.visit(String.class);
  }

            map.put(typeParameter, getActualClass(typeParameter.getBounds()[0], map));
        }

        final Class<?> superClass = clazz.getSuperclass();
        final Type superClassType = clazz.getGenericSuperclass();
        if (superClass != null) {
            gatherTypeVariables(superClass, superClassType, map);
        }

        final Class<?>[] interfaces = clazz.getInterfaces();

      introspector.visit(contextType);
      return ImmutableMap.copyOf(introspector.mappings);
    }

    @Override
    void visitClass(Class<?> clazz) {
      visit(clazz.getGenericSuperclass());
      visit(clazz.getGenericInterfaces());
    }

    @Override
    void visitParameterizedType(ParameterizedType parameterizedType) {
      Class<?> rawClass = (Class<?>) parameterizedType.getRawType();

      // requireNonNull is safe because we're examining a type that's known to have a superclass.
      ParameterizedType parameterizedType =
          requireNonNull((ParameterizedType) subclass.getGenericSuperclass());
      for (ClassOwnership behavior : ClassOwnership.values()) {
        if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) {
          return behavior;
        }
      }