"Read timed out",
    )
    assertThat(webSocket.close(1000, null)).isFalse()
  }

  /**
   * There's no read timeout when reading the first byte of a new frame. But as soon as we start
   * reading a frame we enable the read timeout. In this test we have the server returning the first
   * byte of a frame but no more frames.
   */
  @Test
  fun readTimeoutAppliesWithinFrames() {
    webServer.dispatcher =

     * comparator.
     *
     * <p>The sort order is stable, that is, if two entries have values that compare as equivalent,
     * the entry that was inserted first will be first in the built map's iteration order.
     *
     * @throws IllegalStateException if this method was already called
     * @since 19.0
     */
    @CanIgnoreReturnValue
    @Override

        assertEquals(4, entrySet.size());

        String[] keys = entrySet.stream().map(Map.Entry::getKey).toArray(String[]::new);

        boolean langFirst = "lang".equals(keys[0]);
        assertTrue("lang should be first or sorted normally", langFirst || Arrays.asList(keys).contains("lang"));

        assertTrue(Arrays.asList(keys).contains("apple"));
        assertTrue(Arrays.asList(keys).contains("banana"));

        assertEquals("value1-value2", ResourceUtil.resolve(value));

        // Test nested-like patterns (but not actual nesting)
        value = "${var1${var2}}"; // The ${var2} part gets replaced first
        assertEquals("${var1value2}", ResourceUtil.resolve(value));

        // Test with special characters in replacement
        System.setProperty("special", "value$with\\backslash");
        value = "${special}";

        byte[] dst = new byte[256];
        int bytesWritten = packet.writeTrailerWireFormat(dst, 0);

        assertTrue(bytesWritten > 0);
        assertNotEquals(0, dst[0]); // First byte should be written
    }

    private static Stream<Arguments> provideNamesForWriteTest() {
        return Stream.of(Arguments.of("SERVER", 0x20, "CLIENT", 0x00), Arguments.of("WORKSTATION", 0x00, "USER", 0x03),

        /*
         * NOTE: "invoker:install" vs "appassembler:assemble": Both mojos use the artifact installer to put an artifact
         * into a repository. In the first case, the result needs to be a proper local repository that one can use for
         * local artifact resolution. In the second case, the result needs to precisely obey the path information of the

### Import typing's `List` { #import-typings-list }

In Python 3.9 and above you can use the standard `list` to declare these type annotations as we'll see below. 💡

But in Python versions before 3.9 (3.6 and above), you first need to import `List` from standard Python's `typing` module:

{* ../../docs_src/body_nested_models/tutorial002.py hl[1] *}

### Declare a `list` with a type parameter { #declare-a-list-with-a-type-parameter }

...is what **FastAPI** will actually use to know what is the dependency.

It is from this one that FastAPI will extract the declared parameters and that is what FastAPI will actually call.

---

In this case, the first `CommonQueryParams`, in:

//// tab | Python 3.8+

```Python
commons: Annotated[CommonQueryParams, ...
```

////

//// tab | Python 3.8+ non-Annotated

/// tip

        TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256.javaName,
      )
    }
  }

  private fun expectedConnectionCipherSuites(client: OkHttpClient): Set<String> =
    client.connectionSpecs
      .first()
      .cipherSuites!!
      .map {
        it.javaName
      }.intersect(defaultEnabledCipherSuites.toSet())

  private fun makeClient(
    connectionSpec: ConnectionSpec? = null,

    private static final long serialVersionUID = 1L;

    /** Default page size for pagination. */
    public static final int DEFAULT_PAGE_SIZE = 20;

    /** Default current page number (first page). */
    public static final int DEFAULT_CURRENT_PAGE_NUMBER = 1;

    /** Total number of records across all pages. */
    private int allRecordCount;

    /** Total number of pages. */