解压内容已经读出来，为什么最后一步仍会失败？

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class GzipTrailerBoundary {
    record Row(String name, String policy, int bytesReturned, boolean expectedPayload,
               boolean sawEof, String readError, String closeError) {
        String json() {
            return String.format(Locale.ROOT,
                "{\"case\":\"%s\",\"policy\":\"%s\",\"bytes_returned\":%d,"
                + "\"equals_expected_payload\":%s,\"saw_eof\":%s,"
                + "\"read_error\":\"%s\",\"close_error\":\"%s\"}",
                name, policy, bytesReturned, expectedPayload, sawEof, readError, closeError);
        }
        String csv() {
            return String.join(",", name, policy, Integer.toString(bytesReturned),
                Boolean.toString(expectedPayload), Boolean.toString(sawEof), readError, closeError);
        }
    }

    static void require(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
    }

    static byte[] compress(byte[] payload) throws IOException {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (GZIPOutputStream gzip = new GZIPOutputStream(bytes)) { gzip.write(payload); }
        return bytes.toByteArray(); // Read after close has finished the GZIP member.
    }

    static Row inspect(String name, byte[] encoded, byte[] payload, String policy, int limit)
            throws IOException {
        GZIPInputStream gzip = new GZIPInputStream(new ByteArrayInputStream(encoded));
        ByteArrayOutputStream returned = new ByteArrayOutputStream();
        byte[] buffer = new byte[7];
        boolean eof = false;
        String readError = "none";
        String closeError = "none";
        try {
            while (policy.equals("to_eof") || returned.size() < limit) {
                int wanted = policy.equals("to_eof") ? buffer.length
                    : Math.min(buffer.length, limit - returned.size());
                int count = gzip.read(buffer, 0, wanted);
                if (count == -1) { eof = true; break; }
                returned.write(buffer, 0, count);
            }
        } catch (IOException expected) {
            readError = expected.getClass().getSimpleName();
        } finally {
            try { gzip.close(); }
            catch (IOException failure) { closeError = failure.getClass().getSimpleName(); }
        }
        return new Row(name, policy, returned.size(), Arrays.equals(returned.toByteArray(), payload),
            eof, readError, closeError);
    }

    public static void main(String[] args) throws Exception {
        Path output = args.length == 0 ? Path.of("gzip-output") : Path.of(args[0]);
        byte[] payload = "id,label\n1,alpha\n2,beta\n3,gamma\n".getBytes(StandardCharsets.UTF_8);
        byte[] valid = compress(payload);
        byte[] badCrc = valid.clone();
        badCrc[badCrc.length - 8] ^= 1; // Single member: first byte of its CRC32 trailer field.
        byte[] badSize = valid.clone();
        badSize[badSize.length - 4] ^= 1; // First byte of its ISIZE field.
        byte[] truncated = Arrays.copyOf(valid, valid.length - 4);
        List<Row> rows = List.of(
            inspect("valid_full", valid, payload, "to_eof", 0),
            inspect("bad_crc_full", badCrc, payload, "to_eof", 0),
            inspect("bad_size_full", badSize, payload, "to_eof", 0),
            inspect("truncated_full", truncated, payload, "to_eof", 0),
            inspect("bad_crc_expected_length", badCrc, payload, "stop_at_limit", payload.length),
            inspect("bad_crc_prefix_only", badCrc, payload, "stop_at_limit", 7)
        );
        Row good = rows.get(0);
        require(good.expectedPayload && good.sawEof && good.readError.equals("none"), "valid fixture");
        for (int i = 1; i <= 3; i++) {
            Row row = rows.get(i);
            require(row.expectedPayload && !row.sawEof, row.name + ": payload must precede the error");
            require(row.readError.equals(i == 3 ? "EOFException" : "ZipException"), row.name);
        }
        Row exact = rows.get(4);
        require(exact.expectedPayload && !exact.sawEof && exact.readError.equals("none"), "exact stop");
        Row prefix = rows.get(5);
        require(prefix.bytesReturned == 7 && !prefix.expectedPayload && !prefix.sawEof
            && prefix.readError.equals("none"), "prefix stop");
        require(rows.stream().allMatch(row -> row.closeError.equals("none")), "close results");
        Files.createDirectories(output);
        Files.write(output.resolve("valid.gz"), valid);
        Files.write(output.resolve("bad-crc.gz"), badCrc);
        Files.write(output.resolve("bad-size.gz"), badSize);
        Files.write(output.resolve("truncated.gz"), truncated);
        String version = System.getProperty("java.version");
        String json = "{\n  \"java_version\":\"" + version + "\",\n  \"payload_bytes\":"
            + payload.length + ",\n  \"fixture\":\"single_gzip_member\",\n  \"rows\":[\n    "
            + String.join(",\n    ", rows.stream().map(Row::json).toList()) + "\n  ]\n}\n";
        String csv = "case,policy,bytes_returned,equals_expected_payload,saw_eof,read_error,close_error\n"
            + String.join("\n", rows.stream().map(Row::csv).toList()) + "\n";
        Files.writeString(output.resolve("report.json"), json, StandardCharsets.UTF_8);
        Files.writeString(output.resolve("matrix.csv"), csv, StandardCharsets.UTF_8);
        System.out.println("Java " + version + "; 6 cases; payload bytes=" + payload.length);
        System.out.println("full read: valid=EOF; bad CRC/size=ZipException; truncated=EOFException");
        System.out.println("bad CRC: stop at expected length or prefix + close reports no error");
        System.out.println("PASS; " + output);
    }
}