* 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>,
) {
  /**

    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));
  }

    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));
  }

import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import org.jspecify.annotations.Nullable;

/**
 * An abstract implementation of {@link Hasher}, which only requires subtypes to implement {@link
 * #putByte}. Subtypes may provide more efficient implementations, however.
 *
 * @author Dimitris Andreou
 */
abstract class AbstractHasher implements Hasher {
  @Override
  @CanIgnoreReturnValue

            parent.appendChild(list);
            Element segtitle = document.createElement("segtitle");
            list.appendChild(segtitle);
            segtitle.appendChild(document.createTextNode("Known Subtypes"));
            Element listItem = document.createElement("seglistitem");
            list.appendChild(listItem);
            Element seg = document.createElement("seg");
            listItem.appendChild(seg);

func (args *ReaderArgs) IsEmpty() bool {
	return !args.unmarshaled
}

// UnmarshalXML - decodes XML data.
func (args *ReaderArgs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	// Make subtype to avoid recursive UnmarshalXML().
	type subReaderArgs ReaderArgs
	parsedArgs := subReaderArgs{}
	if err := d.DecodeElement(&parsedArgs, &start); err != nil {
		return err
	}