assertEquals(HashMap.class, ourType.getRawType());
    assertThat(ourType.getActualTypeArguments())
        .asList()
        .containsExactlyElementsIn(asList(jvmType.getActualTypeArguments()))
        .inOrder();
    assertEquals(
        Arrays.asList(String.class, Types.newArrayType(Types.newArrayType(int.class))),
        Arrays.asList(ourType.getActualTypeArguments()));
    assertThat(ourType.getOwnerType()).isNull();
  }

            "Inconsistent raw type: %s vs. %s",
            fromParameterizedType,
            to);
        Type[] fromArgs = fromParameterizedType.getActualTypeArguments();
        Type[] toArgs = toParameterizedType.getActualTypeArguments();
        checkArgument(
            fromArgs.length == toArgs.length,
            "%s not compatible with %s",
            fromParameterizedType,

    Type type = new TypeCapture<EnumSet<E>>() {}.capture();
    assertVisited(type);
    new BaseTypeVisitor() {
      @Override
      void visitParameterizedType(ParameterizedType t) {
        visit(t.getActualTypeArguments());
      }

      @Override
      void visitTypeVariable(TypeVariable<?> t) {
        visit(t.getBounds());
      }
    }.visit(type);
  }

  private static void assertVisited(Type type) {

                                .getGenericReturnType();
                        if (returnType instanceof ParameterizedType parameterizedType) {
                            return !parameterizedType.getActualTypeArguments()[0].equals(String.class);
                        } else {
                            return false;
                        }
                    } catch (ReflectiveOperationException | SecurityException e) {

 *
 * {@snippet :
 * new TypeVisitor() {
 *   protected void visitParameterizedType(ParameterizedType t) {
 *     visit(t.getOwnerType());
 *     visit(t.getActualTypeArguments());
 *   }
 *   protected void visitGenericArrayType(GenericArrayType t) {
 *     visit(t.getGenericComponentType());
 *   }
 *   protected void visitTypeVariable(TypeVariable<?> t) {

    Type type = new TypeCapture<EnumSet<E>>() {}.capture();
    assertVisited(type);
    new BaseTypeVisitor() {
      @Override
      void visitParameterizedType(ParameterizedType t) {
        visit(t.getActualTypeArguments());
      }

      @Override
      void visitTypeVariable(TypeVariable<?> t) {
        visit(t.getBounds());
      }
    }.visit(type);
  }

  private static void assertVisited(Type type) {

  }

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

  }

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

        visit(type.getLowerBounds());
        visit(type.getUpperBounds());
      }

      @Override
      void visitParameterizedType(ParameterizedType type) {
        visit(type.getActualTypeArguments());
        visit(type.getOwnerType());
      }

      @Override
      void visitGenericArrayType(GenericArrayType type) {
        visit(type.getGenericComponentType());
      }

    assertEquals(type, returnType.getRawType());
    assertEquals(
        ImmutableList.copyOf(type.getTypeParameters()),
        ImmutableList.copyOf(returnType.getActualTypeArguments()));
  }

  public void testConstructor_exceptionTypes() throws Exception {
    assertEquals(
        ImmutableList.of(TypeToken.of(NullPointerException.class)),