try {
                return copyInternal(is, os);
            } finally {
                CloseableUtil.close(os);
            }
        } finally {
            CloseableUtil.close(is);
        }
    }

    /**
     * Copies from a file with the specified encoding to a file with the platform default encoding.
     *

    void testReadWriteMethodsReturnValues() {
        SmbComClose close = new SmbComClose(10, 5000L);
        assertEquals(0, close.readParameterWordsWireFormat(new byte[10], 0));
        assertEquals(0, close.readBytesWireFormat(new byte[10], 0));
        assertEquals(0, close.writeBytesWireFormat(new byte[10], 0));
        assertEquals(6, close.writeParameterWordsWireFormat(new byte[10], 0));
    }

    /**

	}

	// 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.

   * CharStreams} method returns a singleton writer whose {@code close} method has no effect, while
   * the {@link Writer#nullWriter()} method returns a new instance whose methods throw after the
   * instance is {@link Writer#close() closed}.
   *
   * @since 15.0
   */
  public static Writer nullWriter() {
    return NullWriter.INSTANCE;
  }

        cos.close();
    }

    @Test
    public void testExactThreshold() throws IOException {
        // Writing exactly threshold bytes should stay in memory
        ContentOutputStream cos = new ContentOutputStream(5, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2, 3, 4 });
        assertTrue(cos.isInMemory());
        assertFalse(cos.done);
        cos.close();
    }

    @Test

// the upstream reader after close has been called.
type disconnectReader struct {
	r  io.Reader
	mu sync.Mutex
}

func (d *disconnectReader) Read(p []byte) (n int, err error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	if d.r != nil {
		return d.r.Read(p)
	}
	return 0, errors.New("reader closed")
}

func (d *disconnectReader) Close() error {
	d.mu.Lock()
	d.r = nil

        // Mock close success for the first call
        doAnswer(invocation -> {
            MsrpcSamrCloseHandle rpc = invocation.getArgument(0);
            rpc.retval = 0;
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrCloseHandle.class));

        // First close call
        aliasHandle.close();

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

    //     we find them, regardless of what the address policies need.
    //
    //  2. EVICTABLE: Connections not required by any address policy. This matches connections that
    //     don't participate in any policy, plus connections whose policies won't be violated if the
    //     connection is closed. We only close these if the idle connection limit is exceeded.
    //

        /**
         * Verifies that the close method can be called without throwing an exception.
         * @throws CIFSException if an error occurs during close.
         */
        @Test
        public void testClose() throws CIFSException {
            assertDoesNotThrow(() -> smbPipeHandle.close(), "close() should not throw an exception on a mock object.");
            // Verify that the close method was called

        }

        @Override
        public void close() throws Exception {
            if (closed) {
                return;
            }

            try {
                resource.close();
            } finally {
                closed = true;
                manager.markClosed(resourceId);
                manager.unregisterResource(resourceId);
            }
        }
    }