OutputStreamMonitor.getContents() inserts U+FFFD when a multibyte character is split across two reads

--- a/debug/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/OutputStreamMonitor.java
+++ b/debug/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/OutputStreamMonitor.java
@@ -70,7 +70,9 @@
 	 * of an incomplete character.
 	 */
 	private StreamDecoder fBufferedDecoder;
+	/** Decoded form of the first {@link #fDecodedLength} bytes of {@link #fContents}. */
 	private String fCachedDecodedContents;
+	private int fDecodedLength;
 
 	/**
 	 * The thread which reads from the stream
@@ -193,11 +195,12 @@
 		if (!isBuffered()) {
 			return ""; //$NON-NLS-1$
 		}
-		if (fCachedDecodedContents != null) {
-			return fCachedDecodedContents;
-		}
 		byte[] data = getData();
-		fCachedDecodedContents = fBufferedDecoder.decode(data, 0, data.length);
+		if (fDecodedLength < data.length) {
+			// decode only the bytes not yet fed to the stateful decoder
+			fCachedDecodedContents += fBufferedDecoder.decode(data, fDecodedLength, data.length - fDecodedLength);
+			fDecodedLength = data.length;
+		}
 		return fCachedDecodedContents;
 	}
 
@@ -236,7 +239,6 @@
 					if (read > 0) {
 						synchronized (this) {
 							if (isBuffered()) {
-								fCachedDecodedContents = null;
 								fContents.write(buffer, 0, read);
 							}
 							fireStreamAppended(buffer, 0, read);
@@ -306,7 +308,8 @@
 	@Override
 	public synchronized void setBuffered(boolean buffer) {
 		if (isBuffered() != buffer) {
-			fCachedDecodedContents = null;
+			fCachedDecodedContents = ""; //$NON-NLS-1$
+			fDecodedLength = 0;
 			if (buffer) {
 				fContents = new ByteArrayOutputStream();
 				fBufferedDecoder = new StreamDecoder(fCharset == null ? Charset.defaultCharset() : fCharset);
@@ -320,7 +323,8 @@
 	@Override
 	public synchronized void flushContents() {
 		if (isBuffered()) {
-			fCachedDecodedContents = null;
+			fCachedDecodedContents = ""; //$NON-NLS-1$
+			fDecodedLength = 0;
 			fContents.reset();
 		}
 	}

/**
 * A multibyte character split across two reads must not be corrupted when
 * getContents() is called after each read without flushing in between.
 */
@Test
public void testBufferedContentsWithSplitCharacterAndNoFlush() throws Exception {
	String input = "oöO";
	byte[] byteInput = input.getBytes(StandardCharsets.UTF_8);
	BinaryListener binaryListener = new BinaryListener();
	monitor.addBinaryListener(binaryListener);

	sysout.write(byteInput, 0, 2);
	sysout.flush();
	monitor.startMonitoring();
	binaryListener.waitForBytes(2);
	assertThat(monitor.getContents()).isEqualTo(input.substring(0, 1));

	sysout.write(byteInput, 2, byteInput.length - 2);
	sysout.flush();
	binaryListener.waitForBytes(byteInput.length);
	assertThat(monitor.getContents()).isEqualTo(input);
	binaryListener.assertNoExceptions();
}

Compile OutputStreamMonitor.java and StreamDecoder.java from master together with this file
against the Eclipse SDK plug-ins (JDK 17+), run Repro; exit code 1 on the current code, 0 with
the patch.

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.nio.charset.StandardCharsets;

import org.eclipse.debug.core.IBinaryStreamListener;
import org.eclipse.debug.internal.core.OutputStreamMonitor;

public class Repro {
	static class TestOutputStreamMonitor extends OutputStreamMonitor {
		TestOutputStreamMonitor(java.io.InputStream in) { super(in, StandardCharsets.UTF_8); }
		public void startMonitoring() { super.startMonitoring("repro"); }
	}

	public static void main(String[] args) throws Exception {
		String input = "oöO";
		byte[] bytes = input.getBytes(StandardCharsets.UTF_8);   // 6F C3 B6 4F
		PipedOutputStream sysout = new PipedOutputStream();
		PipedInputStream in = new PipedInputStream(sysout);
		TestOutputStreamMonitor monitor = new TestOutputStreamMonitor(in);
		int[] received = {0};
		monitor.addBinaryListener((IBinaryStreamListener) (data, m) -> { synchronized (received) { received[0] += data.length; received.notifyAll(); } });

		sysout.write(bytes, 0, 2);                        // 'o' + first byte of 'ö'
		sysout.flush();
		monitor.startMonitoring();
		waitFor(received, 2);
		String first = monitor.getContents();             // "o", decoder keeps 0xC3

		sysout.write(bytes, 2, 2);                        // second byte of 'ö' + 'O', no flushContents in between
		sysout.flush();
		waitFor(received, 4);
		String second = monitor.getContents();
		sysout.close();

		System.out.println("first  getContents(): " + show(first));
		System.out.println("second getContents(): " + show(second) + "   expected " + show(input));
		System.exit(second.equals(input) ? 0 : 1);
	}

	static void waitFor(int[] c, int n) throws InterruptedException {
		synchronized (c) { long end = System.currentTimeMillis() + 10000; while (c[0] < n && System.currentTimeMillis() < end) c.wait(100); }
	}

	static String show(String s) {
		StringBuilder b = new StringBuilder("\"");
		for (char ch : s.toCharArray()) b.append(ch < 128 ? String.valueOf(ch) : String.format("<U+%04X>", (int) ch));
		return b.append('"').toString();
	}
}