// Close should have sent FindClose2 exactly once
        ArgumentCaptor<SmbComFindClose2> captor = ArgumentCaptor.forClass(SmbComFindClose2.class);
        verify(tree, times(1)).send(captor.capture(), any());
        assertNotNull(captor.getValue());

        // Tree handle is released after close
        verify(tree, atLeastOnce()).release();
    }

    @Test

	}
	dstRec.KVS = kvs
	dstRec.SelectFormat = sql.SelectFmtJSON
	return dstRec, nil
}

// Close - closes underlying reader.
func (r *Reader) Close() error {
	// Close the input.
	err := r.readCloser.Close()
	for range r.valueCh {
		// Drain values so we don't leak a goroutine.
		// Since we have closed the input, it should fail rather quickly.
	}
	return err
}

      if (civilizedFileSystem) return fileSource

      lockingSourceCount++
      return object : ForwardingSource(fileSource) {
        private var closed = false

        override fun close() {
          super.close()
          if (!closed) {
            closed = true
            synchronized(this@DiskLruCache) {
              lockingSourceCount--
              if (lockingSourceCount == 0 && zombie) {

                return originalStream.read(b, off, len);
            }

            @Override
            public void close() throws IOException {
                closedFlag.set(true);
                originalStream.close();
            }

            @Override
            public int available() throws IOException {
                return originalStream.available();
            }

        @DisplayName("close() closes handle; does not close file when not unshared")
        void closeClosesHandle() throws Exception {
            SmbFileInputStream in = newStream();
            in.close();
            verify(mockHandle, times(1)).close();
            verify(mockFile, never()).close();
        }

        @Test
        @DisplayName("seToIoe maps Interrupted cause to InterruptedIOException")

  /**
   * Closes the response body. Equivalent to `body().close()`.
   *
   * Prior to OkHttp 5.0, it was an error to close a response that is not eligible for a body. This
   * includes the responses returned from [cacheResponse], [networkResponse], and [priorResponse].
   */
  override fun close() {
    body.close()
  }

     */
    protected abstract FileEntry[] getResults();

    /**
     * Closes the enumeration and releases resources.
     *
     * @throws CIFSException if an error occurs during closing
     */
    protected synchronized void doClose() throws CIFSException {
        // otherwise already closed
        if (!this.closed) {
            this.closed = true;
            try {
                doCloseInternal();

        assertFalse(auth.isClosed());

        // Close the authenticator
        auth.close();

        // Verify it's closed
        assertTrue(auth.isClosed());
        // Cannot check password after closing as it now throws IllegalStateException
        // This is actually good security practice - closed authenticators cannot be accessed

        // Verify multiple closes don't cause issues

        h.close(777L);

        // Verify SMB2 close path
        verify(tree, times(1)).send(isA(Smb2CloseRequest.class), eq(RequestParam.NO_RETRY));
        // Tree is always released in finally
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("close(long) sends SMB1 close request and releases tree when SMB1")

	}

	// Delete the event from store.
	return target.store.Del(key)
}

// Close - closes underneath connections to PostgreSQL database.
func (target *PostgreSQLTarget) Close() error {
	close(target.quitCh)
	if target.updateStmt != nil {
		// FIXME: log returned error. ignore time being.
		_ = target.updateStmt.Close()
	}

	if target.deleteStmt != nil {
		// FIXME: log returned error. ignore time being.