// We cannot read all, as the source does not close.
    // Instead, we ensure that all bytes from source have been processed by inflater.
    do {
      inflaterSource.readOrInflate(buffer, Long.MAX_VALUE)
    } while (inflater.bytesRead < totalBytesToRead && !inflater.finished())
  }

  @Throws(IOException::class)
  override fun close() = inflaterSource.close()

import org.jspecify.annotations.Nullable;
import org.junit.Ignore;

/**
 * Base class for map testers.
 *
 * <p>TODO: see how much of this is actually needed once Map testers are written. (It was cloned
 * from AbstractCollectionTester.)
 *
 * @param <K> the key type of the map to be tested.
 * @param <V> the value type of the map to be tested.
 * @author George van den Driessche
 */
@GwtCompatible

                            return new FileInputStream(testFile);
                        }

                        @Override
                        public void close() throws IOException {
                            // Nothing to close
                        }
                    };
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }

	}
	w.comment = comment
	return nil
}

// Close finishes writing the zip file by writing the central directory.
// It does not close the underlying writer.
func (w *Writer) Close() error {
	if w.last != nil && !w.last.closed {
		if err := w.last.close(); err != nil {
			return err
		}
		w.last = nil
	}
	if w.closed {
		return errors.New("zip: writer closed twice")
	}
	w.closed = true

	unset MINIO_KMS_AUTO_ENCRYPTION # do not auto-encrypt objects
	export MINIO_CI_CD=1

	mkdir ${WORK_DIR}
	C_PWD=${PWD}
	if [ ! -x "$PWD/mc" ]; then
		MC_BUILD_DIR="mc-$RANDOM"
		if ! git clone --quiet https://github.com/minio/mc "$MC_BUILD_DIR"; then
			echo "failed to download https://github.com/minio/mc"
			purge "${MC_BUILD_DIR}"
			exit 1
		fi

		(cd "${MC_BUILD_DIR}" && go build -o "$C_PWD/mc")

        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2, 3, 4 });
        assertFalse(cos.done);
        assertTrue(cos.isInMemory());
        cos.close();
        assertFalse(cos.done);
    }

    @Test
    public void inFile() throws IOException {
        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);

        when(pooledSpy.disconnect(false, false)).thenReturn(true); // In use
        when(nonPooledSpy.disconnect(false, false)).thenReturn(false); // Not in use

        // When: Close the pool
        boolean inUse = pool.close();

        // Then: Should report in-use and call disconnect on all
        assertTrue(inUse, "Should report connections in use");
        verify(pooledSpy).disconnect(false, false);

        doThrow(new IOException("Close network error")).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarClose.class));

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {
            handle.close();
        });

        assertEquals("Close network error", thrown.getMessage());

        // Mock isOpen to return false after close
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                when(smbFile.isOpen()).thenReturn(false);
                return null;
            }
        }).when(smbFile).close(anyLong());

        smbRandomAccessFile.close();

      is CloseStream -> {
        if (stream != null) {
          stream.close(ErrorCode.fromHttp2(effect.http2ErrorCode)!!, null)
        } else {
          socket.close()
        }
      }

      ShutdownConnection -> {
        if (stream != null) {
          stream.connection.shutdown(ErrorCode.NO_ERROR)
        } else {
          socket.close()
        }
      }

      is CloseSocket -> {