Skip to content

Commit 8f8d417

Browse files
smdnsmdn
committed
override Stream.ReadAsync(Memory, CancellationToken)
1 parent af5ef29 commit 8f8d417

File tree

2 files changed

+95
-33
lines changed

2 files changed

+95
-33
lines changed

‎src/Smdn.Fundamental.Stream/Smdn.IO.Streams/PartialStream.cs‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -252,6 +252,20 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
252252
return Task.FromResult(0);
253253
}
254254

255+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
256+
public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
257+
{
258+
CheckDisposed();
259+
260+
var remainder = GetRemainderLength();
261+
262+
if (0L < remainder)
263+
return stream.ReadAsync(buffer.Slice(0, (int)Math.Min(buffer.Length, remainder)), cancellationToken); // XXX: long -> int
264+
265+
return new(0);
266+
}
267+
#endif
268+
255269
public override void Write(byte[] buffer, int offset, int count)
256270
{
257271
CheckDisposed();

‎tests/Smdn/Smdn.IO.Streams/PartialStream.cs‎

Lines changed: 81 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -159,17 +159,31 @@ private void TestClose(PartialStream stream)
159159
Assert.Throws<ObjectDisposedException>(() =>stream.ReadByte());
160160
Assert.Throws<ObjectDisposedException>(() => stream.Read(_Array.Empty<byte>(), 0, 0));
161161
Assert.Throws<ObjectDisposedException>(() => stream.ReadAsync(_Array.Empty<byte>(), 0, 0));
162+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
163+
Assert.Throws<ObjectDisposedException>(() => stream.ReadAsync(Memory<byte>.Empty));
164+
#endif
162165
Assert.Throws<ObjectDisposedException>(() =>stream.WriteByte(0x00));
163166
Assert.Throws<ObjectDisposedException>(() => stream.Write(_Array.Empty<byte>(), 0, 0));
164167
//Assert.Throws<ObjectDisposedException>(() => stream.WriteAsync(_Array.Empty<byte>(), 0, 0));
165168

166169
stream.Dispose();
167170
}
168171

169-
[Test] public Task TestRead_LengthSpecified() => TestRead_LengthSpecified(runAsync: false);
170-
[Test] public Task TestReadAsync_LengthSpecified() => TestRead_LengthSpecified(runAsync: true);
172+
enum ReadMethod {
173+
Read,
174+
ReadAsync,
175+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
176+
ReadAsyncToMemory
177+
#endif
178+
}
179+
180+
[Test] public Task TestRead_LengthSpecified() => TestRead_LengthSpecified(ReadMethod.Read);
181+
[Test] public Task TestReadAsync_LengthSpecified() => TestRead_LengthSpecified(ReadMethod.ReadAsync);
182+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
183+
[Test] public Task TestReadAsync_ToMemory_LengthSpecified() => TestRead_LengthSpecified(ReadMethod.ReadAsyncToMemory);
184+
#endif
171185

172-
private async Task TestRead_LengthSpecified(bool runAsync)
186+
private async Task TestRead_LengthSpecified(ReadMethod readMethod)
173187
{
174188
var inner = new MemoryStream(new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07});
175189
var stream = new PartialStream(inner, 2, 4);
@@ -180,15 +194,19 @@ private async Task TestRead_LengthSpecified(bool runAsync)
180194
Assert.AreEqual(4, stream.Length);
181195
Assert.AreEqual(0, stream.Position);
182196

183-
var buffer = new byte[2];
197+
var buffer = new byte[3];
184198

185199
Assert.AreEqual(
186200
2,
187-
runAsync
188-
? await stream.ReadAsync(buffer, 0, 2)
189-
: stream.Read(buffer, 0, 2)
201+
readMethod switch {
202+
ReadMethod.ReadAsync => await stream.ReadAsync(buffer, 0, 2),
203+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
204+
ReadMethod.ReadAsyncToMemory => await stream.ReadAsync(buffer.AsMemory(0, 2)),
205+
#endif
206+
_ => stream.Read(buffer, 0, 2),
207+
}
190208
);
191-
Assert.AreEqual(new byte[] {0x02, 0x03}, buffer);
209+
Assert.AreEqual(new byte[] {0x02, 0x03, 0x00}, buffer);
192210

193211
Assert.AreEqual(4, stream.InnerStream.Position);
194212
Assert.AreEqual(2, stream.Position);
@@ -197,28 +215,39 @@ private async Task TestRead_LengthSpecified(bool runAsync)
197215

198216
Assert.AreEqual(
199217
1,
200-
runAsync
201-
? await stream.ReadAsync(buffer, 0, 2)
202-
: stream.Read(buffer, 0, 2)
218+
readMethod switch {
219+
ReadMethod.ReadAsync => await stream.ReadAsync(buffer, 0, 2),
220+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
221+
ReadMethod.ReadAsyncToMemory => await stream.ReadAsync(buffer.AsMemory(0, 2)),
222+
#endif
223+
_ => stream.Read(buffer, 0, 2),
224+
}
203225
);
204-
Assert.AreEqual(new byte[] {0x05, 0x03}, buffer);
226+
Assert.AreEqual(new byte[] {0x05, 0x03, 0x00}, buffer);
205227

206228
Assert.AreEqual(6, stream.InnerStream.Position);
207229
Assert.AreEqual(4, stream.Position);
208230

209231
Assert.AreEqual(
210232
0,
211-
runAsync
212-
? await stream.ReadAsync(buffer, 0, 3)
213-
: stream.Read(buffer, 0, 3)
233+
readMethod switch {
234+
ReadMethod.ReadAsync => await stream.ReadAsync(buffer, 0, 3),
235+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
236+
ReadMethod.ReadAsyncToMemory => await stream.ReadAsync(buffer.AsMemory(0, 3)),
237+
#endif
238+
_ => stream.Read(buffer, 0, 3),
239+
}
214240
);
215241
Assert.AreEqual(-1, stream.ReadByte());
216242
}
217243

218-
[Test] public Task TestRead_AfterEndOfInnerStream() => TestRead_AfterEndOfInnerStream(runAsync: false);
219-
[Test] public Task TestReadAsync_AfterEndOfInnerStream() => TestRead_AfterEndOfInnerStream(runAsync: true);
244+
[Test] public Task TestRead_AfterEndOfInnerStream() => TestRead_AfterEndOfInnerStream(ReadMethod.Read);
245+
[Test] public Task TestReadAsync_AfterEndOfInnerStream() => TestRead_AfterEndOfInnerStream(ReadMethod.ReadAsync);
246+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
247+
[Test] public Task TestReadAsync_ToMemory_AfterEndOfInnerStream() => TestRead_AfterEndOfInnerStream(ReadMethod.ReadAsyncToMemory);
248+
#endif
220249

221-
private async Task TestRead_AfterEndOfInnerStream(bool runAsync)
250+
private async Task TestRead_AfterEndOfInnerStream(ReadMethod readMethod)
222251
{
223252
var inner = new MemoryStream(new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07});
224253
var stream = new PartialStream(inner, inner.Length, 8);
@@ -230,17 +259,24 @@ private async Task TestRead_AfterEndOfInnerStream(bool runAsync)
230259

231260
Assert.AreEqual(
232261
0,
233-
runAsync
234-
? await stream.ReadAsync(buffer, 0, 2)
235-
: stream.Read(buffer, 0, 2)
262+
readMethod switch {
263+
ReadMethod.ReadAsync => await stream.ReadAsync(buffer, 0, 2),
264+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
265+
ReadMethod.ReadAsyncToMemory => await stream.ReadAsync(buffer.AsMemory(0, 2)),
266+
#endif
267+
_ => stream.Read(buffer, 0, 2),
268+
}
236269
);
237270
Assert.AreEqual(0, stream.Position);
238271
}
239272

240-
[Test] public Task TestRead_LengthNotSpecified() => TestRead_LengthNotSpecified(runAsync: false);
241-
[Test] public Task TestReadAsync_LengthNotSpecified() => TestRead_LengthNotSpecified(runAsync: true);
273+
[Test] public Task TestRead_LengthNotSpecified() => TestRead_LengthNotSpecified(ReadMethod.Read);
274+
[Test] public Task TestReadAsync_LengthNotSpecified() => TestRead_LengthNotSpecified(ReadMethod.ReadAsync);
275+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
276+
[Test] public Task TestReadAsync_ToMemory_LengthNotSpecified() => TestRead_LengthNotSpecified(ReadMethod.ReadAsyncToMemory);
277+
#endif
242278

243-
private async Task TestRead_LengthNotSpecified(bool runAsync)
279+
private async Task TestRead_LengthNotSpecified(ReadMethod readMethod)
244280
{
245281
var inner = new MemoryStream(new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07});
246282
var stream = new PartialStream(inner, 2);
@@ -255,9 +291,13 @@ private async Task TestRead_LengthNotSpecified(bool runAsync)
255291

256292
Assert.AreEqual(
257293
3,
258-
runAsync
259-
? await stream.ReadAsync(buffer, 0, 3)
260-
: stream.Read(buffer, 0, 3)
294+
readMethod switch {
295+
ReadMethod.ReadAsync => await stream.ReadAsync(buffer, 0, 3),
296+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
297+
ReadMethod.ReadAsyncToMemory => await stream.ReadAsync(buffer.AsMemory(0, 3)),
298+
#endif
299+
_ => stream.Read(buffer, 0, 3),
300+
}
261301
);
262302
Assert.AreEqual(new byte[] {0x02, 0x03, 0x04}, buffer);
263303

@@ -271,9 +311,13 @@ private async Task TestRead_LengthNotSpecified(bool runAsync)
271311

272312
Assert.AreEqual(
273313
2,
274-
runAsync
275-
? await stream.ReadAsync(buffer, 0, 3)
276-
: stream.Read(buffer, 0, 3)
314+
readMethod switch {
315+
ReadMethod.ReadAsync => await stream.ReadAsync(buffer, 0, 3),
316+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
317+
ReadMethod.ReadAsyncToMemory => await stream.ReadAsync(buffer.AsMemory(0, 3)),
318+
#endif
319+
_ => stream.Read(buffer, 0, 3),
320+
}
277321
);
278322
Assert.AreEqual(new byte[] {0x06, 0x07, 0x04}, buffer);
279323

@@ -282,9 +326,13 @@ private async Task TestRead_LengthNotSpecified(bool runAsync)
282326

283327
Assert.AreEqual(
284328
0,
285-
runAsync
286-
? await stream.ReadAsync(buffer, 0, 3)
287-
: stream.Read(buffer, 0, 3)
329+
readMethod switch {
330+
ReadMethod.ReadAsync => await stream.ReadAsync(buffer, 0, 3),
331+
#if SYSTEM_IO_STREAM_READASYNC_MEMORY_OF_BYTE
332+
ReadMethod.ReadAsyncToMemory => await stream.ReadAsync(buffer.AsMemory(0, 3)),
333+
#endif
334+
_ => stream.Read(buffer, 0, 3),
335+
}
288336
);
289337
Assert.AreEqual(-1, stream.ReadByte());
290338
}

0 commit comments

Comments
 (0)