From bd889b91cfe60b0293bfece1a18d46d426d597fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sat, 29 Oct 2022 03:59:05 +0200
Subject: [PATCH] Remove cancellation support from the synchronous API surface.

Closes #49.
---
 src/core/IO/TerminalReader.cs                 | 15 +++---
 src/core/IO/TerminalStream.cs                 |  5 +-
 src/core/IO/TerminalWriter.cs                 | 32 ++++++-------
 src/core/Terminal.cs                          | 48 +++++++++----------
 src/core/Terminals/NativeTerminalReader`2.cs  | 14 ++++--
 src/core/Terminals/NativeTerminalWriter`2.cs  | 14 ++++--
 src/core/Terminals/Unix/UnixTerminalReader.cs |  2 +-
 src/core/Terminals/Unix/UnixTerminalWriter.cs |  2 +-
 .../Windows/WindowsTerminalReader.cs          |  2 +-
 .../Windows/WindowsTerminalWriter.cs          |  2 +-
 src/core/VirtualTerminal.cs                   | 48 +++++++++----------
 src/testing/IO/TestTerminalReader.cs          | 10 ++--
 src/testing/IO/TestTerminalWriter.cs          | 10 ++--
 13 files changed, 100 insertions(+), 104 deletions(-)

diff --git a/src/core/IO/TerminalReader.cs b/src/core/IO/TerminalReader.cs
index 562f4e2..2a039c2 100644
--- a/src/core/IO/TerminalReader.cs
+++ b/src/core/IO/TerminalReader.cs
@@ -6,13 +6,13 @@ public abstract class TerminalReader : TerminalHandle
 
     public abstract TextReader TextReader { get; }
 
-    protected abstract int ReadPartialCore(scoped Span<byte> buffer, CancellationToken cancellationToken);
+    protected abstract int ReadPartialCore(scoped Span<byte> buffer);
 
     protected abstract ValueTask<int> ReadPartialCoreAsync(Memory<byte> buffer, CancellationToken cancellationToken);
 
-    public int ReadPartial(scoped Span<byte> buffer, CancellationToken cancellationToken = default)
+    public int ReadPartial(scoped Span<byte> buffer)
     {
-        var count = ReadPartialCore(buffer, cancellationToken);
+        var count = ReadPartialCore(buffer);
 
         InputRead?.Invoke(buffer[..count], this);
 
@@ -29,13 +29,13 @@ public async ValueTask<int> ReadPartialAsync(Memory<byte> buffer, CancellationTo
         return count;
     }
 
-    public int Read(scoped Span<byte> value, CancellationToken cancellationToken = default)
+    public int Read(scoped Span<byte> value)
     {
         var count = 0;
 
         while (count < value.Length)
         {
-            var ret = ReadPartial(value[count..], cancellationToken);
+            var ret = ReadPartial(value[count..]);
 
             // EOF?
             if (ret == 0)
@@ -66,11 +66,8 @@ public async ValueTask<int> ReadAsync(Memory<byte> value, CancellationToken canc
         return count;
     }
 
-    public string? ReadLine(CancellationToken cancellationToken = default)
+    public string? ReadLine()
     {
-        cancellationToken.ThrowIfCancellationRequested();
-
-        // TODO: Should we make more of an effort to honor the cancellation token?
         return TextReader.ReadLine();
     }
 
diff --git a/src/core/IO/TerminalStream.cs b/src/core/IO/TerminalStream.cs
index de95717..b0b044b 100644
--- a/src/core/IO/TerminalStream.cs
+++ b/src/core/IO/TerminalStream.cs
@@ -66,10 +66,7 @@ public override sealed void Write(byte[] buffer, int offset, int count)
     }
 
     public override sealed Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default)
+        byte[] buffer, int offset, int count, CancellationToken cancellationToken = default)
     {
         Check.Null(buffer);
 
diff --git a/src/core/IO/TerminalWriter.cs b/src/core/IO/TerminalWriter.cs
index db64905..9da520f 100644
--- a/src/core/IO/TerminalWriter.cs
+++ b/src/core/IO/TerminalWriter.cs
@@ -6,15 +6,14 @@ public abstract class TerminalWriter : TerminalHandle
 
     public abstract TextWriter TextWriter { get; }
 
-    protected abstract int WritePartialCore(scoped ReadOnlySpan<byte> buffer, CancellationToken cancellationToken);
+    protected abstract int WritePartialCore(scoped ReadOnlySpan<byte> buffer);
 
     protected abstract ValueTask<int> WritePartialCoreAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken);
+        ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken);
 
-    public int WritePartial(scoped ReadOnlySpan<byte> buffer, CancellationToken cancellationToken = default)
+    public int WritePartial(scoped ReadOnlySpan<byte> buffer)
     {
-        var count = WritePartialCore(buffer, cancellationToken);
+        var count = WritePartialCore(buffer);
 
         OutputWritten?.Invoke(buffer[..count], this);
 
@@ -23,8 +22,7 @@ public int WritePartial(scoped ReadOnlySpan<byte> buffer, CancellationToken canc
 
     [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))]
     public async ValueTask<int> WritePartialAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken = default)
+        ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
     {
         var count = await WritePartialCoreAsync(buffer, cancellationToken).ConfigureAwait(false);
 
@@ -33,9 +31,9 @@ public async ValueTask<int> WritePartialAsync(
         return count;
     }
 
-    public void Write(scoped ReadOnlySpan<byte> value, CancellationToken cancellationToken = default)
+    public void Write(scoped ReadOnlySpan<byte> value)
     {
-        for (var count = 0; count < value.Length; count += WritePartial(value[count..], cancellationToken))
+        for (var count = 0; count < value.Length; count += WritePartial(value[count..]))
         {
         }
     }
@@ -55,7 +53,7 @@ public ValueTask WriteAsync(Memory<byte> value, CancellationToken cancellationTo
         return WriteAsync((ReadOnlyMemory<byte>)value, cancellationToken);
     }
 
-    public void Write(scoped ReadOnlySpan<char> value, CancellationToken cancellationToken = default)
+    public void Write(scoped ReadOnlySpan<char> value)
     {
         var encoding = Terminal.Encoding;
         var len = encoding.GetByteCount(value);
@@ -67,7 +65,7 @@ public void Write(scoped ReadOnlySpan<char> value, CancellationToken cancellatio
 
             _ = encoding.GetBytes(value, span);
 
-            Write(span, cancellationToken);
+            Write(span);
         }
         finally
         {
@@ -101,9 +99,9 @@ public ValueTask WriteAsync(Memory<char> value, CancellationToken cancellationTo
         return WriteAsync((ReadOnlyMemory<char>)value, cancellationToken);
     }
 
-    public void Write<T>(T value, CancellationToken cancellationToken = default)
+    public void Write<T>(T value)
     {
-        Write((value?.ToString()).AsSpan(), cancellationToken);
+        Write((value?.ToString()).AsSpan());
     }
 
     public ValueTask WriteAsync<T>(T value, CancellationToken cancellationToken = default)
@@ -111,9 +109,9 @@ public ValueTask WriteAsync<T>(T value, CancellationToken cancellationToken = de
         return WriteAsync((value?.ToString()).AsMemory(), cancellationToken);
     }
 
-    public void WriteLine(CancellationToken cancellationToken = default)
+    public void WriteLine()
     {
-        WriteLine(string.Empty, cancellationToken);
+        WriteLine(string.Empty);
     }
 
     public ValueTask WriteLineAsync(CancellationToken cancellationToken = default)
@@ -121,9 +119,9 @@ public ValueTask WriteLineAsync(CancellationToken cancellationToken = default)
         return WriteLineAsync(string.Empty, cancellationToken);
     }
 
-    public void WriteLine<T>(T value, CancellationToken cancellationToken = default)
+    public void WriteLine<T>(T value)
     {
-        Write(value?.ToString() + Environment.NewLine, cancellationToken);
+        Write(value?.ToString() + Environment.NewLine);
     }
 
     public ValueTask WriteLineAsync<T>(T value, CancellationToken cancellationToken = default)
diff --git a/src/core/Terminal.cs b/src/core/Terminal.cs
index 287d4e7..1441ef6 100644
--- a/src/core/Terminal.cs
+++ b/src/core/Terminal.cs
@@ -70,9 +70,9 @@ public static void DisableRawMode()
         System.DisableRawMode();
     }
 
-    public static int Read(scoped Span<byte> value, CancellationToken cancellationToken = default)
+    public static int Read(scoped Span<byte> value)
     {
-        return System.Read(value, cancellationToken);
+        return System.Read(value);
     }
 
     public static ValueTask<int> ReadAsync(Memory<byte> value, CancellationToken cancellationToken = default)
@@ -80,9 +80,9 @@ public static ValueTask<int> ReadAsync(Memory<byte> value, CancellationToken can
         return System.ReadAsync(value, cancellationToken);
     }
 
-    public static string? ReadLine(CancellationToken cancellationToken = default)
+    public static string? ReadLine()
     {
-        return System.ReadLine(cancellationToken);
+        return System.ReadLine();
     }
 
     public static ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken = default)
@@ -90,9 +90,9 @@ public static ValueTask<int> ReadAsync(Memory<byte> value, CancellationToken can
         return System.ReadLineAsync(cancellationToken);
     }
 
-    public static void Out(scoped ReadOnlySpan<byte> value, CancellationToken cancellationToken = default)
+    public static void Out(scoped ReadOnlySpan<byte> value)
     {
-        System.Out(value, cancellationToken);
+        System.Out(value);
     }
 
     public static ValueTask OutAsync(ReadOnlyMemory<byte> value, CancellationToken cancellationToken = default)
@@ -105,9 +105,9 @@ public static ValueTask OutAsync(Memory<byte> value, CancellationToken cancellat
         return System.OutAsync(value, cancellationToken);
     }
 
-    public static void Out(scoped ReadOnlySpan<char> value, CancellationToken cancellationToken = default)
+    public static void Out(scoped ReadOnlySpan<char> value)
     {
-        System.Out(value, cancellationToken);
+        System.Out(value);
     }
 
     public static ValueTask OutAsync(ReadOnlyMemory<char> value, CancellationToken cancellationToken = default)
@@ -120,9 +120,9 @@ public static ValueTask OutAsync(Memory<char> value, CancellationToken cancellat
         return System.OutAsync(value, cancellationToken);
     }
 
-    public static void Out<T>(T value, CancellationToken cancellationToken = default)
+    public static void Out<T>(T value)
     {
-        System.Out(value, cancellationToken);
+        System.Out(value);
     }
 
     public static ValueTask OutAsync<T>(T value, CancellationToken cancellationToken = default)
@@ -130,9 +130,9 @@ public static ValueTask OutAsync<T>(T value, CancellationToken cancellationToken
         return System.OutAsync(value, cancellationToken);
     }
 
-    public static void OutLine(CancellationToken cancellationToken = default)
+    public static void OutLine()
     {
-        System.OutLine(cancellationToken);
+        System.OutLine();
     }
 
     public static ValueTask OutLineAsync(CancellationToken cancellationToken = default)
@@ -140,9 +140,9 @@ public static ValueTask OutLineAsync(CancellationToken cancellationToken = defau
         return System.OutLineAsync(cancellationToken);
     }
 
-    public static void OutLine<T>(T value, CancellationToken cancellationToken = default)
+    public static void OutLine<T>(T value)
     {
-        System.OutLine(value, cancellationToken);
+        System.OutLine(value);
     }
 
     public static ValueTask OutLineAsync<T>(T value, CancellationToken cancellationToken = default)
@@ -150,9 +150,9 @@ public static ValueTask OutLineAsync<T>(T value, CancellationToken cancellationT
         return System.OutLineAsync(value, cancellationToken);
     }
 
-    public static void Error(scoped ReadOnlySpan<byte> value, CancellationToken cancellationToken = default)
+    public static void Error(scoped ReadOnlySpan<byte> value)
     {
-        System.Error(value, cancellationToken);
+        System.Error(value);
     }
 
     public static ValueTask ErrorAsync(ReadOnlyMemory<byte> value, CancellationToken cancellationToken = default)
@@ -165,9 +165,9 @@ public static ValueTask ErrorAsync(Memory<byte> value, CancellationToken cancell
         return System.ErrorAsync(value, cancellationToken);
     }
 
-    public static void Error(scoped ReadOnlySpan<char> value, CancellationToken cancellationToken = default)
+    public static void Error(scoped ReadOnlySpan<char> value)
     {
-        System.Error(value, cancellationToken);
+        System.Error(value);
     }
 
     public static ValueTask ErrorAsync(ReadOnlyMemory<char> value, CancellationToken cancellationToken = default)
@@ -180,9 +180,9 @@ public static ValueTask ErrorAsync(Memory<char> value, CancellationToken cancell
         return System.ErrorAsync(value, cancellationToken);
     }
 
-    public static void Error<T>(T value, CancellationToken cancellationToken = default)
+    public static void Error<T>(T value)
     {
-        System.Error(value, cancellationToken);
+        System.Error(value);
     }
 
     public static ValueTask ErrorAsync<T>(T value, CancellationToken cancellationToken = default)
@@ -190,9 +190,9 @@ public static ValueTask ErrorAsync<T>(T value, CancellationToken cancellationTok
         return System.ErrorAsync(value, cancellationToken);
     }
 
-    public static void ErrorLine(CancellationToken cancellationToken = default)
+    public static void ErrorLine()
     {
-        System.ErrorLine(cancellationToken);
+        System.ErrorLine();
     }
 
     public static ValueTask ErrorLineAsync(CancellationToken cancellationToken = default)
@@ -200,9 +200,9 @@ public static ValueTask ErrorLineAsync(CancellationToken cancellationToken = def
         return System.ErrorLineAsync(cancellationToken);
     }
 
-    public static void ErrorLine<T>(T value, CancellationToken cancellationToken = default)
+    public static void ErrorLine<T>(T value)
     {
-        System.ErrorLine(value, cancellationToken);
+        System.ErrorLine(value);
     }
 
     public static ValueTask ErrorLineAsync<T>(T value, CancellationToken cancellationToken = default)
diff --git a/src/core/Terminals/NativeTerminalReader`2.cs b/src/core/Terminals/NativeTerminalReader`2.cs
index 42dff34..3e1d9a3 100644
--- a/src/core/Terminals/NativeTerminalReader`2.cs
+++ b/src/core/Terminals/NativeTerminalReader`2.cs
@@ -34,13 +34,19 @@ protected NativeTerminalReader(TTerminal terminal, string name, THandle handle)
         IsInteractive = terminal.IsHandleInteractive(handle);
     }
 
+    protected abstract int ReadPartialNative(scoped Span<byte> buffer, CancellationToken cancellationToken);
+
+    protected override sealed int ReadPartialCore(scoped Span<byte> buffer)
+    {
+        return ReadPartialNative(buffer, default);
+    }
+
     protected override sealed ValueTask<int> ReadPartialCoreAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken)
+        Memory<byte> buffer, CancellationToken cancellationToken)
     {
-        // We currently have no async support.
+        // We currently have no native async support.
         return cancellationToken.IsCancellationRequested ?
             ValueTask.FromCanceled<int>(cancellationToken) :
-            new(Task.Run(() => ReadPartialCore(buffer.Span, cancellationToken), cancellationToken));
+            new(Task.Run(() => ReadPartialNative(buffer.Span, cancellationToken), cancellationToken));
     }
 }
diff --git a/src/core/Terminals/NativeTerminalWriter`2.cs b/src/core/Terminals/NativeTerminalWriter`2.cs
index bc48062..b936cef 100644
--- a/src/core/Terminals/NativeTerminalWriter`2.cs
+++ b/src/core/Terminals/NativeTerminalWriter`2.cs
@@ -35,13 +35,19 @@ protected NativeTerminalWriter(TTerminal terminal, string name, THandle handle)
         IsInteractive = terminal.IsHandleInteractive(handle);
     }
 
+    protected abstract int WritePartialNative(scoped ReadOnlySpan<byte> buffer, CancellationToken cancellationToken);
+
+    protected override sealed int WritePartialCore(scoped ReadOnlySpan<byte> buffer)
+    {
+        return WritePartialNative(buffer, default);
+    }
+
     protected override sealed ValueTask<int> WritePartialCoreAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken)
+        ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
     {
-        // We currently have no async support.
+        // We currently have no native async support.
         return cancellationToken.IsCancellationRequested ?
             ValueTask.FromCanceled<int>(cancellationToken) :
-            new(Task.Run(() => WritePartialCore(buffer.Span, cancellationToken), cancellationToken));
+            new(Task.Run(() => WritePartialNative(buffer.Span, cancellationToken), cancellationToken));
     }
 }
diff --git a/src/core/Terminals/Unix/UnixTerminalReader.cs b/src/core/Terminals/Unix/UnixTerminalReader.cs
index 7c883fc..4da4735 100644
--- a/src/core/Terminals/Unix/UnixTerminalReader.cs
+++ b/src/core/Terminals/Unix/UnixTerminalReader.cs
@@ -20,7 +20,7 @@ public UnixTerminalReader(
         _cancellationPipe = cancellationPipe;
     }
 
-    protected override int ReadPartialCore(scoped Span<byte> buffer, CancellationToken cancellationToken)
+    protected override int ReadPartialNative(scoped Span<byte> buffer, CancellationToken cancellationToken)
     {
         using var guard = Terminal.Control.Guard();
 
diff --git a/src/core/Terminals/Unix/UnixTerminalWriter.cs b/src/core/Terminals/Unix/UnixTerminalWriter.cs
index 6c947b8..596f91d 100644
--- a/src/core/Terminals/Unix/UnixTerminalWriter.cs
+++ b/src/core/Terminals/Unix/UnixTerminalWriter.cs
@@ -12,7 +12,7 @@ public UnixTerminalWriter(UnixVirtualTerminal terminal, string name, int handle,
         _semaphore = semaphore;
     }
 
-    protected override int WritePartialCore(
+    protected override int WritePartialNative(
         scoped ReadOnlySpan<byte> buffer, CancellationToken cancellationToken)
     {
         using var guard = Terminal.Control.Guard();
diff --git a/src/core/Terminals/Windows/WindowsTerminalReader.cs b/src/core/Terminals/Windows/WindowsTerminalReader.cs
index f46df6e..68d2acc 100644
--- a/src/core/Terminals/Windows/WindowsTerminalReader.cs
+++ b/src/core/Terminals/Windows/WindowsTerminalReader.cs
@@ -22,7 +22,7 @@ public WindowsTerminalReader(
         _buffer = new byte[Cathode.Terminal.Encoding.GetMaxByteCount(2)];
     }
 
-    protected override unsafe int ReadPartialCore(scoped Span<byte> buffer, CancellationToken cancellationToken)
+    protected override unsafe int ReadPartialNative(scoped Span<byte> buffer, CancellationToken cancellationToken)
     {
         using var guard = Terminal.Control.Guard();
 
diff --git a/src/core/Terminals/Windows/WindowsTerminalWriter.cs b/src/core/Terminals/Windows/WindowsTerminalWriter.cs
index 606bd7f..06a0df3 100644
--- a/src/core/Terminals/Windows/WindowsTerminalWriter.cs
+++ b/src/core/Terminals/Windows/WindowsTerminalWriter.cs
@@ -16,7 +16,7 @@ public WindowsTerminalWriter(
         _semaphore = semaphore;
     }
 
-    protected override unsafe int WritePartialCore(
+    protected override unsafe int WritePartialNative(
         scoped ReadOnlySpan<byte> buffer, CancellationToken cancellationToken)
     {
         using var guard = Terminal.Control.Guard();
diff --git a/src/core/VirtualTerminal.cs b/src/core/VirtualTerminal.cs
index bee58fa..579c124 100644
--- a/src/core/VirtualTerminal.cs
+++ b/src/core/VirtualTerminal.cs
@@ -28,9 +28,9 @@ public abstract class VirtualTerminal
 
     public abstract void DisableRawMode();
 
-    public int Read(scoped Span<byte> value, CancellationToken cancellationToken = default)
+    public int Read(scoped Span<byte> value)
     {
-        return StandardIn.ReadPartial(value, cancellationToken);
+        return StandardIn.ReadPartial(value);
     }
 
     public ValueTask<int> ReadAsync(Memory<byte> value, CancellationToken cancellationToken = default)
@@ -38,9 +38,9 @@ public ValueTask<int> ReadAsync(Memory<byte> value, CancellationToken cancellati
         return StandardIn.ReadPartialAsync(value, cancellationToken);
     }
 
-    public string? ReadLine(CancellationToken cancellationToken = default)
+    public string? ReadLine()
     {
-        return StandardIn.ReadLine(cancellationToken);
+        return StandardIn.ReadLine();
     }
 
     public ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken = default)
@@ -48,9 +48,9 @@ public ValueTask<int> ReadAsync(Memory<byte> value, CancellationToken cancellati
         return StandardIn.ReadLineAsync(cancellationToken);
     }
 
-    public void Out(scoped ReadOnlySpan<byte> value, CancellationToken cancellationToken = default)
+    public void Out(scoped ReadOnlySpan<byte> value)
     {
-        StandardOut.Write(value, cancellationToken);
+        StandardOut.Write(value);
     }
 
     public ValueTask OutAsync(ReadOnlyMemory<byte> value, CancellationToken cancellationToken = default)
@@ -63,9 +63,9 @@ public ValueTask OutAsync(Memory<byte> value, CancellationToken cancellationToke
         return StandardOut.WriteAsync(value, cancellationToken);
     }
 
-    public void Out(scoped ReadOnlySpan<char> value, CancellationToken cancellationToken = default)
+    public void Out(scoped ReadOnlySpan<char> value)
     {
-        StandardOut.Write(value, cancellationToken);
+        StandardOut.Write(value);
     }
 
     public ValueTask OutAsync(ReadOnlyMemory<char> value, CancellationToken cancellationToken = default)
@@ -78,9 +78,9 @@ public ValueTask OutAsync(Memory<char> value, CancellationToken cancellationToke
         return StandardOut.WriteAsync(value, cancellationToken);
     }
 
-    public void Out<T>(T value, CancellationToken cancellationToken = default)
+    public void Out<T>(T value)
     {
-        StandardOut.Write(value, cancellationToken);
+        StandardOut.Write(value);
     }
 
     public ValueTask OutAsync<T>(T value, CancellationToken cancellationToken = default)
@@ -88,9 +88,9 @@ public ValueTask OutAsync<T>(T value, CancellationToken cancellationToken = defa
         return StandardOut.WriteAsync(value, cancellationToken);
     }
 
-    public void OutLine(CancellationToken cancellationToken = default)
+    public void OutLine()
     {
-        StandardOut.WriteLine(cancellationToken);
+        StandardOut.WriteLine();
     }
 
     public ValueTask OutLineAsync(CancellationToken cancellationToken = default)
@@ -98,9 +98,9 @@ public ValueTask OutLineAsync(CancellationToken cancellationToken = default)
         return StandardOut.WriteLineAsync(cancellationToken);
     }
 
-    public void OutLine<T>(T value, CancellationToken cancellationToken = default)
+    public void OutLine<T>(T value)
     {
-        StandardOut.WriteLine(value, cancellationToken);
+        StandardOut.WriteLine(value);
     }
 
     public ValueTask OutLineAsync<T>(T value, CancellationToken cancellationToken = default)
@@ -108,9 +108,9 @@ public ValueTask OutLineAsync<T>(T value, CancellationToken cancellationToken =
         return StandardOut.WriteLineAsync(value, cancellationToken);
     }
 
-    public void Error(scoped ReadOnlySpan<byte> value, CancellationToken cancellationToken = default)
+    public void Error(scoped ReadOnlySpan<byte> value)
     {
-        StandardError.Write(value, cancellationToken);
+        StandardError.Write(value);
     }
 
     public ValueTask ErrorAsync(ReadOnlyMemory<byte> value, CancellationToken cancellationToken = default)
@@ -123,9 +123,9 @@ public ValueTask ErrorAsync(Memory<byte> value, CancellationToken cancellationTo
         return StandardError.WriteAsync(value, cancellationToken);
     }
 
-    public void Error(scoped ReadOnlySpan<char> value, CancellationToken cancellationToken = default)
+    public void Error(scoped ReadOnlySpan<char> value)
     {
-        StandardError.Write(value, cancellationToken);
+        StandardError.Write(value);
     }
 
     public ValueTask ErrorAsync(ReadOnlyMemory<char> value, CancellationToken cancellationToken = default)
@@ -138,9 +138,9 @@ public ValueTask ErrorAsync(Memory<char> value, CancellationToken cancellationTo
         return StandardError.WriteAsync(value, cancellationToken);
     }
 
-    public void Error<T>(T value, CancellationToken cancellationToken = default)
+    public void Error<T>(T value)
     {
-        StandardError.Write(value, cancellationToken);
+        StandardError.Write(value);
     }
 
     public ValueTask ErrorAsync<T>(T value, CancellationToken cancellationToken = default)
@@ -148,9 +148,9 @@ public ValueTask ErrorAsync<T>(T value, CancellationToken cancellationToken = de
         return StandardError.WriteAsync(value, cancellationToken);
     }
 
-    public void ErrorLine(CancellationToken cancellationToken = default)
+    public void ErrorLine()
     {
-        StandardError.WriteLine(cancellationToken);
+        StandardError.WriteLine();
     }
 
     public ValueTask ErrorLineAsync(CancellationToken cancellationToken = default)
@@ -158,9 +158,9 @@ public ValueTask ErrorLineAsync(CancellationToken cancellationToken = default)
         return StandardError.WriteLineAsync(cancellationToken);
     }
 
-    public void ErrorLine<T>(T value, CancellationToken cancellationToken = default)
+    public void ErrorLine<T>(T value)
     {
-        StandardError.WriteLine(value, cancellationToken);
+        StandardError.WriteLine(value);
     }
 
     public ValueTask ErrorLineAsync<T>(T value, CancellationToken cancellationToken = default)
diff --git a/src/testing/IO/TestTerminalReader.cs b/src/testing/IO/TestTerminalReader.cs
index c9871ed..bcea688 100644
--- a/src/testing/IO/TestTerminalReader.cs
+++ b/src/testing/IO/TestTerminalReader.cs
@@ -25,17 +25,14 @@ public TestTerminalReader()
     }
 
     [SuppressMessage("", "VSTHRD002")]
-    protected override sealed int ReadPartialCore(scoped Span<byte> buffer, CancellationToken cancellationToken)
+    protected override sealed int ReadPartialCore(scoped Span<byte> buffer)
     {
         var len = buffer.Length;
         var array = ArrayPool<byte>.Shared.Rent(len);
 
         try
         {
-            var read = ReadPartialCoreAsync(array.AsMemory(..len), cancellationToken)
-                .AsTask()
-                .GetAwaiter()
-                .GetResult();
+            var read = ReadPartialCoreAsync(array.AsMemory(..len), default).AsTask().GetAwaiter().GetResult();
 
             array.AsSpan(..read).CopyTo(buffer);
 
@@ -48,8 +45,7 @@ protected override sealed int ReadPartialCore(scoped Span<byte> buffer, Cancella
     }
 
     protected override sealed async ValueTask<int> ReadPartialCoreAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken)
+        Memory<byte> buffer, CancellationToken cancellationToken)
     {
         if (buffer.IsEmpty || !_isValid)
             return 0;
diff --git a/src/testing/IO/TestTerminalWriter.cs b/src/testing/IO/TestTerminalWriter.cs
index 746504c..ffc7c12 100644
--- a/src/testing/IO/TestTerminalWriter.cs
+++ b/src/testing/IO/TestTerminalWriter.cs
@@ -25,17 +25,14 @@ public TestTerminalWriter()
     }
 
     protected override sealed int WritePartialCore(
-        scoped ReadOnlySpan<byte> buffer, CancellationToken cancellationToken)
+        scoped ReadOnlySpan<byte> buffer)
     {
         var len = buffer.Length;
         var array = ArrayPool<byte>.Shared.Rent(len);
 
         try
         {
-            return WritePartialCoreAsync(array.AsMemory(..len), cancellationToken)
-                .AsTask()
-                .GetAwaiter()
-                .GetResult();
+            return WritePartialCoreAsync(array.AsMemory(..len), default).AsTask().GetAwaiter().GetResult();
         }
         finally
         {
@@ -44,8 +41,7 @@ protected override sealed int WritePartialCore(
     }
 
     protected override sealed async ValueTask<int> WritePartialCoreAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken)
+        ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
     {
         if (buffer.IsEmpty || !_isValid)
             return 0;