throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

  public void testAssertContainsAllOf() {
    List<?> list = asList("a", "a", "b", "c");
    assertContainsAllOf(list, "a");
    assertContainsAllOf(list, "a", "a");
    assertContainsAllOf(list, "a", "b", "c");
    assertContainsAllOf(list, "a", "b", "c", "a");

    try {
      assertContainsAllOf(list, "d");

        // Arrange
        String host = "testHost";
        when(nameServiceClient.getNbtAllByAddress(host)).thenThrow(new UnknownHostException("Host not found"));

        // Act & Assert
        assertThrows(UnknownHostException.class, () -> nameServiceClient.getNbtAllByAddress(host));
        verify(nameServiceClient, times(1)).getNbtAllByAddress(host);
    }

    @Test

    assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 2)));

    list.add("pants");
    assertFalse(Iterators.limit(list.iterator(), 0).hasNext());
    assertEquals(ImmutableList.of("cool"), newArrayList(Iterators.limit(list.iterator(), 1)));
    assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 2)));
    assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 3)));
  }

  /**
   * Don't call through to the proxy selector if we don't have a host name.
   * https://github.com/square/okhttp/issues/5770
   */
  @Test fun proxySelectorNotCalledForNullHost() {
    // The string '>' is okay in a hostname in HttpUrl, which does very light hostname validation.
    // It is not okay in URI, and so it's stripped and we get a URI with a null host.
    val bogusHostname = ">"
    val address =

# Without aliases


@app.post("/optional-list-str", operation_id="optional_list_str")
async def read_optional_list_str(
    p: Annotated[Optional[list[str]], Body(embed=True)] = None,
):
    return {"p": p}


class BodyModelOptionalListStr(BaseModel):
    p: Optional[list[str]] = None


@app.post("/model-optional-list-str", operation_id="model_optional_list_str")

# Without aliases


@app.post("/optional-list-bytes")
async def read_optional_list_bytes(p: Annotated[Optional[list[bytes]], File()] = None):
    return {"file_size": [len(file) for file in p] if p else None}


@app.post("/optional-list-uploadfile")
async def read_optional_list_uploadfile(
    p: Annotated[Optional[list[UploadFile]], File()] = None,
):

  private final transient int[] axesSizeProduct;

  static <E> List<List<E>> create(List<? extends List<? extends E>> lists) {
    ImmutableList.Builder<List<E>> axesBuilder = new ImmutableList.Builder<>(lists.size());
    for (List<? extends E> list : lists) {
      List<E> copy = ImmutableList.copyOf(list);
      if (copy.isEmpty()) {
        return ImmutableList.of();
      }
      axesBuilder.add(copy);
    }

          </description>
          <type>String</type>
          <defaultValue>8080</defaultValue>
        </field>
        <field>
          <name>host</name>
          <version>1.0.0+</version>
          <description>
            The proxy host.
          </description>
          <type>String</type>
          <required>true</required>
        </field>
        <field>
          <name>nonProxyHosts</name>

    List<Integer> list = asList(3, 4, 5, -1);
    List<Integer> result = numberOrdering.leastOf(list, list.size() + 1);
    assertTrue(result instanceof RandomAccess);
    assertListImmutable(result);
    assertEquals(ImmutableList.of(-1, 3, 4, 5), result);
  }

  public void testLeastOfIterator_simple_nPlusOne() {
    List<Integer> list = asList(3, 4, 5, -1);

    List<Integer> list = asList(3, 4, 5, -1);
    List<Integer> result = numberOrdering.leastOf(list, list.size() + 1);
    assertTrue(result instanceof RandomAccess);
    assertListImmutable(result);
    assertEquals(ImmutableList.of(-1, 3, 4, 5), result);
  }

  public void testLeastOfIterator_simple_nPlusOne() {
    List<Integer> list = asList(3, 4, 5, -1);