// First close call
        handle.close();

        // Act
        // Second close call
        handle.close();

        // Assert
        // sendrecv for open is called once
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcSamrOpenDomain.class));
        // sendrecv for close is called only once, even if close() is called multiple times

        }).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrCloseHandle.class));

        // First close call
        aliasHandle.close();

        // Act: Call close again
        aliasHandle.close();

        // Assert: Verify sendrecv for MsrpcSamrCloseHandle was called only once
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcSamrCloseHandle.class));
    }

    delegate!!.sslParameters = p
  }

  @Throws(IOException::class)
  override fun close() {
    delegate!!.close()
  }

  override fun getInetAddress(): InetAddress = delegate!!.inetAddress

  @Throws(IOException::class)
  override fun getInputStream(): InputStream = delegate!!.inputStream

  @Throws(SocketException::class)
  override fun getKeepAlive(): Boolean = delegate!!.keepAlive

Any function that is valid to use with:

* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" class="external-link" target="_blank">`@contextlib.contextmanager`</a> or
* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager" class="external-link" target="_blank">`@contextlib.asynccontextmanager`</a>

would be valid to use as a **FastAPI** dependency.

    }
    handler.windowUpdate(streamId, increment)
  }

  @Throws(IOException::class)
  override fun close() {
    source.close()
  }

  /**
   * Decompression of the header block occurs above the framing layer. This class lazily reads
   * continuation frames as they are needed by [Hpack.Reader.readHeaders].
   */
  internal class ContinuationSource(
    private val source: BufferedSource,
  ) : Source {

											}

											exprs = append(exprs, clause.Expr{SQL: onSQL, Vars: vars})
										}
									}
								}
							}

							return clause.Join{
								Type:  joinType,
								Table: clause.Table{Name: relation.FieldSchema.Table, Alias: tableAliasName},
								ON:    clause.Where{Exprs: exprs},
							}
						}

						parentTableName := clause.CurrentTable
						for idx, rel := range relations {

 *   <li>{@code close()} - Closes the stream and deletes the temporary file if it is not needed.</li>
 * </ul>
 */
public class ContentOutputStream extends DeferredFileOutputStream {

    /**
     * The logger for this class.
     */
    protected static final Logger logger = Logger.getLogger(ContentOutputStream.class.getName());

    /**
     * The prefix for the temporary file name.

        // After last element, hasNext should be false and calling close() should send Smb2CloseRequest once
        assertFalse(it.hasNext(), "Iterator should be exhausted");

        // Close explicitly to exercise doCloseInternal
        it.close();

        // Verify interactions: one create, two additional directory queries (for fetchMore), one close

        doThrow(expectedException).when(watchHandle).close();

        // Execute and verify
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            watchHandle.close();
        });

        assertEquals("Failed to close handle", thrown.getMessage());
        verify(watchHandle, times(1)).close();
    }

    /**

    }

    void close(final int f, final long lastWriteTime) throws SmbException {

        if (LogStream.level >= 3) {
            log.println("close: " + f);
        }

        /*
         * Close Request / Response
         */

        send(new SmbComClose(f, lastWriteTime), blank_resp());
    }

    void close(final long lastWriteTime) throws SmbException {