PrintWriter 没抛异常，输出就一定成功了吗？

import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class PrintWriterBoundary {
    // Deliberate in-memory fault injection, not a real disk failure.
    static final class ProbeWriter extends Writer {
        final boolean failWrite;
        final boolean failFlush;
        final StringBuilder accepted = new StringBuilder();
        int flushCalls;
        boolean closed;

        ProbeWriter(boolean failWrite, boolean failFlush) {
            this.failWrite = failWrite;
            this.failFlush = failFlush;
        }
        @Override public void write(char[] chars, int offset, int length) throws IOException {
            if (closed) throw new IOException("closed");
            if (failWrite) throw new IOException("injected write failure");
            accepted.append(chars, offset, length);
        }
        @Override public void flush() throws IOException {
            if (closed) throw new IOException("closed");
            flushCalls++;
            if (failFlush) throw new IOException("injected flush failure");
        }
        @Override public void close() throws IOException {
            if (!closed) {
                try { flush(); } finally { closed = true; }
            }
        }
    }

    record Row(String name, String writeOutcome, Boolean checkError,
               int acceptedChars, int flushesBeforeCheck, int flushesAfterCheck) {
        String json() {
            return String.format(Locale.ROOT,
                "{\"case\":\"%s\",\"write_outcome\":\"%s\",\"check_error\":%s,"
                + "\"accepted_chars\":%d,\"flushes_before_check\":%d,\"flushes_after_check\":%d}",
                name, writeOutcome, checkError, acceptedChars,
                flushesBeforeCheck, flushesAfterCheck);
        }
        String csv() {
            return String.join(",", name, writeOutcome,
                checkError == null ? "not_applicable" : checkError.toString(),
                Integer.toString(acceptedChars), Integer.toString(flushesBeforeCheck),
                Integer.toString(flushesAfterCheck));
        }
    }

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

    static Row directFailure() throws IOException {
        ProbeWriter sink = new ProbeWriter(true, false);
        String outcome = "returned";
        try {
            try { sink.write("hello"); }
            catch (IOException expected) { outcome = expected.getClass().getSimpleName(); }
            require(outcome.equals("IOException"), "direct Writer must report the injected failure");
            return new Row("direct_write_failure", outcome, null, sink.accepted.length(),
                sink.flushCalls, sink.flushCalls);
        } finally { sink.close(); }
    }

    static Row wrapped(String name, boolean failWrite, boolean failFlush,
                       boolean autoFlush, String operation, int expectedBefore,
                       boolean expectedError) {
        ProbeWriter sink = new ProbeWriter(failWrite, failFlush);
        PrintWriter writer = new PrintWriter(sink, autoFlush);
        try {
            // None of these PrintWriter calls declares IOException.
            switch (operation) {
                case "write" -> writer.write("hello");
                case "newline" -> writer.write("hello\n");
                case "println" -> writer.println("hello");
                case "printf" -> writer.printf("%s", "hello");
                default -> throw new IllegalArgumentException(operation);
            }
            int before = sink.flushCalls;
            boolean error = writer.checkError(); // This call also flushes an open writer.
            int after = sink.flushCalls;
            require(before == expectedBefore, name + ": unexpected automatic flush");
            require(after == before + 1, name + ": checkError must perform one flush here");
            require(error == expectedError, name + ": unexpected error flag");
            require(failWrite ? sink.accepted.length() == 0 : sink.accepted.length() > 0,
                name + ": unexpected accepted characters");
            return new Row(name, "returned", error, sink.accepted.length(), before, after);
        } finally { writer.close(); }
    }

    public static void main(String[] args) throws Exception {
        Path output = args.length == 0 ? Path.of("printwriter-output") : Path.of(args[0]);
        List<Row> rows = new ArrayList<>();
        rows.add(directFailure());
        rows.add(wrapped("wrapped_write_failure", true, false, false, "write", 0, true));
        rows.add(wrapped("flush_failure_on_check", false, true, false, "write", 0, true));
        rows.add(wrapped("healthy_control", false, false, false, "write", 0, false));
        rows.add(wrapped("auto_write_newline", false, false, true, "newline", 0, false));
        rows.add(wrapped("auto_println", false, false, true, "println", 1, false));
        rows.add(wrapped("auto_printf_no_newline", false, false, true, "printf", 1, false));
        Files.createDirectories(output);
        String version = System.getProperty("java.version");
        String json = "{\n  \"java_version\":\"" + version
            + "\",\n  \"fault_model\":\"in_memory_ordinary_IOException\",\n  \"rows\":[\n    "
            + String.join(",\n    ", rows.stream().map(Row::json).toList()) + "\n  ]\n}\n";
        String csv = "case,write_outcome,check_error,accepted_chars,flushes_before_check,flushes_after_check\n"
            + String.join("\n", rows.stream().map(Row::csv).toList()) + "\n";
        // Report creation deliberately uses an API that propagates IOException.
        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 + "; 7 cases; " + output);
        System.out.println("direct: IOException; wrapped: returned + checkError=true");
        System.out.println("autoFlush before check: write(newline)=0; println=1; printf(no newline)=1");
        System.out.println("PASS");
    }
}