Inflater 已经解压完成，输入末尾为什么还留着 NEXT？

import java.io.ByteArrayOutputStream;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.zip.Deflater;
import java.util.zip.Inflater;

public class Main {
    private static int checks;
    private static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
        checks++;
    }
    private static byte[] compress(byte[] input) {
        Deflater encoder = new Deflater();
        try {
            encoder.setInput(input);
            encoder.finish();
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            byte[] block = new byte[16];
            while (!encoder.finished()) {
                int count = encoder.deflate(block);
                if (count == 0 && !encoder.finished()) throw new AssertionError("encoder stalled");
                out.write(block, 0, count);
            }
            return out.toByteArray();
        } finally { encoder.end(); }
    }
    private static byte[] drain(Inflater decoder, int blockSize) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] block = new byte[blockSize];
        for (int guard = 0; guard < 1000; guard++) {
            int count = decoder.inflate(block);
            out.write(block, 0, count);
            if (decoder.finished() || decoder.needsInput() || decoder.needsDictionary()) return out.toByteArray();
            if (count == 0) throw new AssertionError("decoder made no progress");
        }
        throw new AssertionError("fixture iteration limit");
    }
    private static byte[] append(byte[] first, byte[] second) {
        byte[] joined = Arrays.copyOf(first, first.length + second.length);
        System.arraycopy(second, 0, joined, first.length, second.length);
        return joined;
    }
    public static void main(String[] args) throws Exception {
        byte[] payload = "HELLO".getBytes(StandardCharsets.US_ASCII);
        byte[] encoded = compress(payload);
        byte[] tail = "NEXT".getBytes(StandardCharsets.US_ASCII);
        Inflater decoder = new Inflater();
        try {
            decoder.setInput(encoded, 0, 2);
            byte[] first = drain(decoder, 8);
            check(first.length == 0 && !decoder.finished() && decoder.needsInput(), "header alone is incomplete");
            System.out.println("header-only: output=" + first.length + " finished=" + decoder.finished()
                    + " needsInput=" + decoder.needsInput() + " remaining=" + decoder.getRemaining());
            decoder.setInput(encoded, 2, encoded.length - 2);
            check(Arrays.equals(drain(decoder, 1), payload) && decoder.finished(), "feed remaining input");
            check(decoder.getRemaining() == 0 && decoder.needsInput(), "complete input exactly consumed");
            System.out.println("exact: output=HELLO finished=" + decoder.finished()
                    + " needsInput=" + decoder.needsInput() + " remaining=" + decoder.getRemaining());

            decoder.reset();
            decoder.setInput(Arrays.copyOf(encoded, encoded.length - 2));
            byte[] truncated = drain(decoder, 8);
            check(Arrays.equals(truncated, payload) && !decoder.finished() && decoder.needsInput(), "payload is not stream completion");
            System.out.println("truncated: output=HELLO finished=" + decoder.finished()
                    + " needsInput=" + decoder.needsInput() + " remaining=" + decoder.getRemaining());

            decoder.reset();
            ByteBuffer framed = ByteBuffer.wrap(append(encoded, tail));
            decoder.setInput(framed);
            check(Arrays.equals(drain(decoder, 2), payload) && decoder.finished(), "first stream finished");
            check(decoder.getRemaining() == 4 && !decoder.needsInput(), "tail remains");
            check(framed.position() == encoded.length && framed.remaining() == 4, "byte buffer cursor identifies tail");
            byte[] recoveredTail = new byte[framed.remaining()];
            framed.get(recoveredTail);
            check(Arrays.equals(recoveredTail, tail), "next protocol field preserved");
            System.out.println("with-tail: output=HELLO finished=true needsInput=false remaining=4 tail="
                    + new String(recoveredTail, StandardCharsets.US_ASCII));
        } finally { decoder.end(); }

        for (int blockSize : new int[]{1, 2, 8}) for (int tailLength = 0; tailLength <= 4; tailLength++) {
            Inflater current = new Inflater();
            try {
                byte[] suffix = Arrays.copyOf(tail, tailLength);
                current.setInput(append(encoded, suffix));
                check(Arrays.equals(drain(current, blockSize), payload), "output block size does not lose bytes");
                check(current.finished() && current.getRemaining() == tailLength, "tail length preserved");
                check(current.needsInput() == (tailLength == 0), "needsInput is about available bytes");
            } finally { current.end(); }
        }
        System.out.println("matrix: 3 output sizes x 5 tail lengths checked");
        System.out.println("PASS " + checks + " checks; one zlib stream, no files or network I/O");
    }
}