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

  public void testVisitWildcardType() {
    WildcardType type = Types.subtypeOf(String.class);
    assertVisited(type);
    new BaseTypeVisitor() {
      @Override
      void visitWildcardType(WildcardType t) {}
    }.visit(type);
  }

  public <T> void testVisitGenericArrayType() {

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

  public void testVisitWildcardType() {
    WildcardType type = Types.subtypeOf(String.class);
    assertVisited(type);
    new BaseTypeVisitor() {
      @Override
      void visitWildcardType(WildcardType t) {}
    }.visit(type);
  }

  public <T> void testVisitGenericArrayType() {

    Type subtype = new TypeCapture<TypedKeyMap<T>>() {}.capture();
    assertEquals(
        new TypeCapture<TypedKeyMap<String>>() {}.capture(),
        new TypeResolver()
            .where(
                new TypeCapture<Map<Integer, T>>() {}.capture(),
                new TypeCapture<Map<?, String>>() {}.capture())
            .resolveType(subtype));
  }

        return methodParametersFromSignature(methodInSubClass) == methodParametersFromSignature(method)
            // Subclass can override method return type
            && methodInSubClass.returnType.subtypeOf(method.returnType)
    }

    /**
     * Returns method parameters from method signature, e.g. "(Ljava/lang/String;I)V" -> "(Ljava/lang/String;I)"
     */

    Type subtype = new TypeCapture<TypedKeyMap<T>>() {}.capture();
    assertEquals(
        new TypeCapture<TypedKeyMap<String>>() {}.capture(),
        new TypeResolver()
            .where(
                new TypeCapture<Map<Integer, T>>() {}.capture(),
                new TypeCapture<Map<?, String>>() {}.capture())
            .resolveType(subtype));
  }

 * annotated by {@link TestSubtype}.
 *
 * <p>These declaration methods rely on Java static type checking to make sure what we want to
 * assert as subtypes are really subtypes according to javac. For example:
 *
 * {@snippet :
 * class MySubtypeTests extends SubtypeTester {
 *   @TestSubtype(suppressGetSubtype = true, suppressGetSupertype = true)

 * annotated by {@link TestSubtype}.
 *
 * <p>These declaration methods rely on Java static type checking to make sure what we want to
 * assert as subtypes are really subtypes according to javac. For example:
 *
 * {@snippet :
 * class MySubtypeTests extends SubtypeTester {
 *   @TestSubtype(suppressGetSubtype = true, suppressGetSupertype = true)

The string will be checked to be a valid URL, and documented in JSON Schema / OpenAPI as such.

## Attributes with lists of submodels { #attributes-with-lists-of-submodels }

You can also use Pydantic models as subtypes of `list`, `set`, etc.:

{* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}

This will expect (convert, validate, document, etc.) a JSON body like:

```JSON hl_lines="11"
{

  }

  @Test fun testInvalidParse() {
    assertInvalid("", "No subtype found for: \"\"")
    assertInvalid("/", "No subtype found for: \"/\"")
    assertInvalid("text", "No subtype found for: \"text\"")
    assertInvalid("text/", "No subtype found for: \"text/\"")
    assertInvalid("te<t/plain", "No subtype found for: \"te<t/plain\"")
    assertInvalid(" text/plain", "No subtype found for: \" text/plain\"")

   */
  @get:JvmName("type") val type: String,
  /**
   * Returns a specific media subtype, such as "plain" or "png", "mpeg", "mp4" or "xml".
   */
  @get:JvmName("subtype") val subtype: String,
  /** Alternating parameter names with their values, like `["charset", "utf-8"]`. */
  private val parameterNamesAndValues: Array<String>,
) {
  /**