* is iterated are the individual lists created, and these are not retained after iteration.
   *
   * @param lists the lists to choose elements from, in the order that the elements chosen from
   *     those lists should appear in the resulting lists
   * @param <B> any common base class shared by all axes (often just {@link Object})

    stop();
    join();

    if (uncaughtThrowable != null) {
      throw new AssertionError("Uncaught throwable in " + getName(), uncaughtThrowable);
    }
  }

  /**
   * Causes this thread to call the named void method, and asserts that the call returns normally.
   */
  public void callAndAssertReturns(String methodName, Object... arguments) throws Exception {
    checkNotNull(methodName);
    checkNotNull(arguments);

 *
 * @author Kevin Bourrillion
 * @since 3.0
 */
@DoNotMock("Use Interners.new*Interner")
@J2ktIncompatible
@GwtIncompatible
public interface Interner<E> {
  /**
   * Chooses and returns the representative instance for any of a collection of instances that are
   * equal to each other. If two {@linkplain Object#equals equal} inputs are given to this method,

        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
    }

    /**
     * Closes this SAM alias handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {

      private var closed = false

      override fun close() {
        if (closed) return
        try {
          super.close()
        } finally {
          closedLatch.countDown()
        }
      }
    }.buffer()

  override val sink: BufferedSink =
    object : ForwardingSink(delegate.sink) {
      private var closed = false

      override fun close() {

            }
        }, "Multiple close operations should not cause issues");

        // Verify iterator still works after multiple closes
        assertFalse(emptyIterator.hasNext(), "Iterator should still work after multiple closes");
        assertNull(emptyIterator.next(), "Iterator should still return null after multiple closes");
    }

    @Test
    @DisplayName("EmptyIterator should handle remove operations multiple times")

  }

  @Test
  fun trailersWithServerTruncatedResponseHttp2() {
    trailersWithServerTruncatedResponse(Protocol.HTTP_2)
  }

  /**
   * If the server closes the connection while the client is consuming the response body, attempts
   * to peek or read the trailers should throw.
   */
  private fun trailersWithServerTruncatedResponse(protocol: Protocol) {

Você também pode declarar um corpo como um `dict` com chaves de algum tipo e valores de outro tipo.

Sem ter que saber de antemão quais são os nomes de campos/atributos válidos (como seria o caso dos modelos Pydantic).

Isso seria útil se você deseja receber chaves que ainda não conhece.

---

Outro caso útil é quando você deseja ter chaves de outro tipo, por exemplo, `int`.

É isso que vamos ver aqui.

     */
    protected ResultSetUtil() {
    }

    /**
     * Closes the result set.
     * <p>
     * If {@link ResultSet#close()} throws an exception, an error message is logged. The exception is not rethrown.
     * </p>
     *
     * @param resultSet
     *            The result set
     */
    public static void close(final ResultSet resultSet) {
        if (resultSet == null) {
            return;

     * @throws InvokerException if an error occurs during the invocation process.
     */
    int invoke(@Nonnull InvokerRequest invokerRequest) throws InvokerException;

    /**
     * Closes and disposes of this {@link Invoker} instance, releasing any resources it may hold.
     * This method is called automatically when using try-with-resources statements.
     *