--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+ <!--
+ Microsoft ResX Schema
+
+ Version 2.0
+
+ The primary goals of this format is to allow a simple XML format
+ that is mostly human readable. The generation and parsing of the
+ various data types are done through the TypeConverter classes
+ associated with the data types.
+
+ Example:
+
+ ... ado.net/XML headers & schema ...
+ <resheader name="resmimetype">text/microsoft-resx</resheader>
+ <resheader name="version">2.0</resheader>
+ <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+ <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+ <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+ <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+ <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+ <value>[base64 mime encoded serialized .NET Framework object]</value>
+ </data>
+ <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+ <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+ <comment>This is a comment</comment>
+ </data>
+
+ There are any number of "resheader" rows that contain simple
+ name/value pairs.
+
+ Each data row contains a name, and value. The row also contains a
+ type or mimetype. Type corresponds to a .NET class that support
+ text/value conversion through the TypeConverter architecture.
+ Classes that don't support this are serialized and stored with the
+ mimetype set.
+
+ The mimetype is used for serialized objects, and tells the
+ ResXResourceReader how to depersist the object. This is currently not
+ extensible. For a given mimetype the value must be set accordingly:
+
+ Note - application/x-microsoft.net.object.binary.base64 is the format
+ that the ResXResourceWriter will generate, however the reader can
+ read any of the formats listed below.
+
+ mimetype: application/x-microsoft.net.object.binary.base64
+ value : The object must be serialized with
+ : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+ : and then encoded with base64 encoding.
+
+ mimetype: application/x-microsoft.net.object.soap.base64
+ value : The object must be serialized with
+ : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+ : and then encoded with base64 encoding.
+
+ mimetype: application/x-microsoft.net.object.bytearray.base64
+ value : The object must be serialized into a byte array
+ : using a System.ComponentModel.TypeConverter
+ : and then encoded with base64 encoding.
+ -->
+ <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+ <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+ <xsd:element name="root" msdata:IsDataSet="true">
+ <xsd:complexType>
+ <xsd:choice maxOccurs="unbounded">
+ <xsd:element name="metadata">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" />
+ </xsd:sequence>
+ <xsd:attribute name="name" use="required" type="xsd:string" />
+ <xsd:attribute name="type" type="xsd:string" />
+ <xsd:attribute name="mimetype" type="xsd:string" />
+ <xsd:attribute ref="xml:space" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="assembly">
+ <xsd:complexType>
+ <xsd:attribute name="alias" type="xsd:string" />
+ <xsd:attribute name="name" type="xsd:string" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="data">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+ <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+ </xsd:sequence>
+ <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+ <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+ <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+ <xsd:attribute ref="xml:space" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="resheader">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+ </xsd:sequence>
+ <xsd:attribute name="name" type="xsd:string" use="required" />
+ </xsd:complexType>
+ </xsd:element>
+ </xsd:choice>
+ </xsd:complexType>
+ </xsd:element>
+ </xsd:schema>
+ <resheader name="resmimetype">
+ <value>text/microsoft-resx</value>
+ </resheader>
+ <resheader name="version">
+ <value>2.0</value>
+ </resheader>
+ <resheader name="reader">
+ <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+ </resheader>
+ <resheader name="writer">
+ <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+ </resheader>
+ <data name="AdvanceToInvalidCursor" xml:space="preserve">
+ <value>Pipe is already advanced past provided cursor.</value>
+ </data>
+ <data name="BackpressureDeadlock" xml:space="preserve">
+ <value>Advancing examined to the end would cause pipe to deadlock because FlushAsync is waiting.</value>
+ </data>
+ <data name="CannotAdvancePastCurrentBufferSize" xml:space="preserve">
+ <value>Can't advance past buffer size.</value>
+ </data>
+ <data name="CannotCompleteWhileReading" xml:space="preserve">
+ <value>Can't complete reader while reading.</value>
+ </data>
+ <data name="CannotCompleteWhiteWriting" xml:space="preserve">
+ <value>Can't complete writer while writing.</value>
+ </data>
+ <data name="ConcurrentOperationsNotSupported" xml:space="preserve">
+ <value>Concurrent reads or writes are not supported.</value>
+ </data>
+ <data name="GetResultBeforeCompleted" xml:space="preserve">
+ <value>Can't GetResult unless awaiter is completed.</value>
+ </data>
+ <data name="NoReadingOperationToComplete" xml:space="preserve">
+ <value>No reading operation to complete.</value>
+ </data>
+ <data name="NoWritingOperation" xml:space="preserve">
+ <value>No writing operation. Make sure GetMemory() was called.</value>
+ </data>
+ <data name="ReaderAndWriterHasToBeCompleted" xml:space="preserve">
+ <value>Both reader and writer has to be completed to be able to reset the pipe.</value>
+ </data>
+ <data name="ReadingAfterCompleted" xml:space="preserve">
+ <value>Reading is not allowed after reader was completed.</value>
+ </data>
+ <data name="ReadingIsInProgress" xml:space="preserve">
+ <value>Reading is already in progress.</value>
+ </data>
+ <data name="WritingAfterCompleted" xml:space="preserve">
+ <value>Writing is not allowed after writer was completed.</value>
+ </data>
+</root>
\ No newline at end of file
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'netstandard-Debug|AnyCPU'" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'netstandard-Release|AnyCPU'" />
<ItemGroup>
+ <Compile Include="Properties\InternalsVisibleTo.cs" />
<Compile Include="System\IO\Pipelines\BufferSegment.cs" />
<Compile Include="System\IO\Pipelines\FlushResult.cs" />
<Compile Include="System\IO\Pipelines\InlineScheduler.cs" />
<Compile Include="System\IO\Pipelines\PipeWriter.cs" />
<Compile Include="System\IO\Pipelines\ReadResult.cs" />
<Compile Include="System\IO\Pipelines\ResultFlags.cs" />
- <Compile Include="System\IO\Pipelines\SpanLiteralExtensions.cs" />
<Compile Include="System\IO\Pipelines\ThreadPoolScheduler.cs" />
<Compile Include="System\IO\Pipelines\ThrowHelper.cs" />
</ItemGroup>
{
if (options == null)
{
- throw new ArgumentNullException(nameof(options));
- }
-
- if (options.ResumeWriterThreshold < 0)
- {
- throw new ArgumentOutOfRangeException(nameof(options.ResumeWriterThreshold));
- }
-
- if (options.PauseWriterThreshold < 0)
- {
- throw new ArgumentOutOfRangeException(nameof(options.PauseWriterThreshold));
- }
-
- if (options.ResumeWriterThreshold > options.PauseWriterThreshold)
- {
- throw new ArgumentException(nameof(options.PauseWriterThreshold) + " should be greater or equal to " + nameof(options.ResumeWriterThreshold), nameof(options.PauseWriterThreshold));
+ ThrowHelper.ThrowArgumentNullException(ExceptionArgument.options);
}
_bufferSegmentPool = new BufferSegment[SegmentPoolSize];
{
if (callback == null)
{
- throw new ArgumentNullException(nameof(callback));
+ ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.callback);
}
PipeCompletionCallbacks completionCallbacks;
{
if (callback == null)
{
- throw new ArgumentNullException(nameof(callback));
+ ThrowHelper.ThrowArgumentNullException(ExceptionArgument.callback);
}
PipeCompletionCallbacks completionCallbacks;
{
if (!_disposed)
{
- throw new InvalidOperationException("Both reader and writer need to be completed to be able to reset ");
+ ThrowHelper.ThrowInvalidOperationException_ResetIncompleteReaderWriter();
}
_disposed = false;
long resumeWriterThreshold = 0,
int minimumSegmentSize = 2048)
{
+
+ if (resumeWriterThreshold < 0 && resumeWriterThreshold > pauseWriterThreshold)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.resumeWriterThreshold);
+ }
+
+ if (pauseWriterThreshold < 0)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.pauseWriterThreshold);
+ }
+
Pool = pool ?? MemoryPool<byte>.Shared;
ReaderScheduler = readerScheduler;
WriterScheduler = writerScheduler;
/// </summary>
public virtual PipeAwaiter<FlushResult> WriteAsync(ReadOnlyMemory<byte> source)
{
- Span<byte> destination = GetSpan();
- var sourceSpan = source.Span;
- // Fast path, try copying to the available memory directly
- if (sourceSpan.Length <= destination.Length)
- {
- sourceSpan.CopyTo(destination);
- Advance(sourceSpan.Length);
- return FlushAsync();
- }
-
- var remaining = sourceSpan.Length;
- var offset = 0;
-
- while (remaining > 0)
- {
- var writable = Math.Min(remaining, destination.Length);
-
- destination = GetSpan(writable);
-
- if (writable == 0)
- {
- continue;
- }
-
- sourceSpan.Slice(offset, writable).CopyTo(destination);
-
- remaining -= writable;
- offset += writable;
-
- Advance(writable);
- }
-
+ this.Write(source.Span);
return FlushAsync();
}
}
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Text;
-
-namespace System.IO.Pipelines
-{
- internal class SpanLiteralExtensions
- {
- internal static void AppendAsLiteral(ReadOnlySpan<byte> span, StringBuilder sb)
- {
- for (int i = 0; i < span.Length; i++)
- {
- AppendCharLiteral((char) span[i], sb);
- }
- }
-
- internal static void AppendCharLiteral(char c, StringBuilder sb)
- {
- switch (c)
- {
- case '\'':
- sb.Append(@"\'");
- break;
- case '\"':
- sb.Append("\\\"");
- break;
- case '\\':
- sb.Append(@"\\");
- break;
- case '\0':
- sb.Append(@"\0");
- break;
- case '\a':
- sb.Append(@"\a");
- break;
- case '\b':
- sb.Append(@"\b");
- break;
- case '\f':
- sb.Append(@"\f");
- break;
- case '\n':
- sb.Append(@"\n");
- break;
- case '\r':
- sb.Append(@"\r");
- break;
- case '\t':
- sb.Append(@"\t");
- break;
- case '\v':
- sb.Append(@"\v");
- break;
- default:
- // ASCII printable character
- if (!char.IsControl(c))
- {
- sb.Append(c);
- // As UTF16 escaped character
- }
- else
- {
- sb.Append(@"\u");
- sb.Append(((int) c).ToString("x4"));
- }
- break;
- }
- }
- }
-}
[MethodImpl(MethodImplOptions.NoInlining)]
private static Exception CreateArgumentOutOfRangeException(ExceptionArgument argument) { return new ArgumentOutOfRangeException(argument.ToString()); }
+ internal static void ThrowArgumentNullException(ExceptionArgument argument) { throw CreateArgumentNullException(argument); }
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private static Exception CreateArgumentNullException(ExceptionArgument argument) { return new ArgumentOutOfRangeException(argument.ToString()); }
+
public static void ThrowInvalidOperationException_NotWritingNoAlloc()
{
throw CreateInvalidOperationException_NotWritingNoAlloc();
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_NotWritingNoAlloc()
{
- return new InvalidOperationException("No writing operation. Make sure GetMemory() was called.");
+ return new InvalidOperationException(SR.NoWritingOperation);
}
public static void ThrowInvalidOperationException_AlreadyReading()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_AlreadyReading()
{
- return new InvalidOperationException("Already reading.");
+ return new InvalidOperationException(SR.ReadingIsInProgress);
}
public static void ThrowInvalidOperationException_NoReadToComplete()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_NoReadToComplete()
{
- return new InvalidOperationException("No reading operation to complete.");
+ return new InvalidOperationException(SR.NoReadingOperationToComplete);
}
public static void ThrowInvalidOperationException_NoConcurrentOperation()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_NoConcurrentOperation()
{
- return new InvalidOperationException("Concurrent reads or writes are not supported.");
+ return new InvalidOperationException(SR.ConcurrentOperationsNotSupported);
}
public static void ThrowInvalidOperationException_GetResultNotCompleted()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_GetResultNotCompleted()
{
- return new InvalidOperationException("Can't GetResult unless completed");
+ return new InvalidOperationException(SR.GetResultBeforeCompleted);
}
public static void ThrowInvalidOperationException_NoWritingAllowed()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_NoWritingAllowed()
{
- return new InvalidOperationException("Writing is not allowed after writer was completed");
+ return new InvalidOperationException(SR.ReadingAfterCompleted);
}
public static void ThrowInvalidOperationException_NoReadingAllowed()
public static Exception CreateInvalidOperationException_NoReadingAllowed()
{
- return new InvalidOperationException("Reading is not allowed after reader was completed");
+ return new InvalidOperationException(SR.WritingAfterCompleted);
}
public static void ThrowInvalidOperationException_CompleteWriterActiveWriter()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_CompleteWriterActiveWriter()
{
- return new InvalidOperationException("Can't complete writer while writing.");
+ return new InvalidOperationException(SR.CannotCompleteWhiteWriting);
}
public static void ThrowInvalidOperationException_CompleteReaderActiveReader()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_CompleteReaderActiveReader()
{
- return new InvalidOperationException("Can't complete reader while reading.");
+ return new InvalidOperationException(SR.CannotCompleteWhileReading);
}
public static void ThrowInvalidOperationException_AdvancingPastBufferSize()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_AdvancingPastBufferSize()
{
- return new InvalidOperationException("Can't advance past buffer size");
+ return new InvalidOperationException(SR.CannotAdvancePastCurrentBufferSize);
}
public static void ThrowInvalidOperationException_BackpressureDeadlock()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_BackpressureDeadlock()
{
- return new InvalidOperationException("Advancing examined to the end would cause pipe to deadlock because FlushAsync is waiting");
+ return new InvalidOperationException(SR.BackpressureDeadlock);
}
public static void ThrowInvalidOperationException_AdvanceToInvalidCursor()
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception CreateInvalidOperationException_AdvanceToInvalidCursor()
{
- return new InvalidOperationException("Pipe is already advanced past provided cursor");
+ return new InvalidOperationException(SR.AdvanceToInvalidCursor);
+ }
+
+ public static void ThrowInvalidOperationException_ResetIncompleteReaderWriter()
+ {
+ throw CreateInvalidOperationException_ResetIncompleteReaderWriter();
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static Exception CreateInvalidOperationException_ResetIncompleteReaderWriter()
+ {
+ return new InvalidOperationException(SR.AdvanceToInvalidCursor);
}
}
internal enum ExceptionArgument
{
minimumSize,
- bytesWritten
+ bytesWritten,
+ callback,
+ options,
+
+ pauseWriterThreshold,
+
+ resumeWriterThreshold
}
}
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.IO.Pipelines.Tests
-{
- public class PipeLengthTests : IDisposable
- {
- public PipeLengthTests()
- {
- _pool = new TestMemoryPool();
- _pipe = new Pipe(new PipeOptions(_pool));
- }
-
- public void Dispose()
- {
- _pipe.Writer.Complete();
- _pipe.Reader.Complete();
- _pool?.Dispose();
- }
-
- private readonly TestMemoryPool _pool;
-
- private readonly Pipe _pipe;
-
- [Fact]
- public void ByteByByteTest()
- {
- for (var i = 1; i <= 1024 * 1024; i++)
- {
- _pipe.Writer.GetMemory(100);
- _pipe.Writer.Advance(1);
- _pipe.Writer.Commit();
-
- Assert.Equal(i, _pipe.Length);
- }
-
- _pipe.Writer.FlushAsync();
-
- for (int i = 1024 * 1024 - 1; i >= 0; i--)
- {
- ReadResult result = _pipe.Reader.ReadAsync().GetResult();
- SequencePosition consumed = result.Buffer.Slice(1).Start;
-
- Assert.Equal(i + 1, result.Buffer.Length);
-
- _pipe.Reader.AdvanceTo(consumed, consumed);
-
- Assert.Equal(i, _pipe.Length);
- }
- }
-
- [Fact]
- public void LengthCorrectAfterAlloc0AdvanceCommit()
- {
- _pipe.Writer.GetMemory(0);
- _pipe.Writer.WriteEmpty(10);
- _pipe.Writer.Commit();
-
- Assert.Equal(10, _pipe.Length);
- }
-
- [Fact]
- public void LengthCorrectAfterAllocAdvanceCommit()
- {
- PipeWriter writableBuffer = _pipe.Writer.WriteEmpty(10);
- writableBuffer.Commit();
-
- Assert.Equal(10, _pipe.Length);
- }
-
- [Fact]
- public void LengthDecreasedAfterReadAdvanceConsume()
- {
- _pipe.Writer.GetMemory(100);
- _pipe.Writer.Advance(10);
- _pipe.Writer.Commit();
- _pipe.Writer.FlushAsync();
-
- ReadResult result = _pipe.Reader.ReadAsync().GetResult();
- SequencePosition consumed = result.Buffer.Slice(5).Start;
- _pipe.Reader.AdvanceTo(consumed, consumed);
-
- Assert.Equal(5, _pipe.Length);
- }
-
- [Fact]
- public void LengthNotChangeAfterReadAdvanceExamine()
- {
- PipeWriter writableBuffer = _pipe.Writer.WriteEmpty(10);
- writableBuffer.Commit();
- writableBuffer.FlushAsync();
-
- ReadResult result = _pipe.Reader.ReadAsync().GetResult();
- _pipe.Reader.AdvanceTo(result.Buffer.Start, result.Buffer.End);
-
- Assert.Equal(10, _pipe.Length);
- }
- }
-}
+//// Licensed to the .NET Foundation under one or more agreements.
+//// The .NET Foundation licenses this file to you under the MIT license.
+//// See the LICENSE file in the project root for more information.
+
+//using Xunit;
+
+//namespace System.IO.Pipelines.Tests
+//{
+// public class PipeLengthTests : IDisposable
+// {
+// public PipeLengthTests()
+// {
+// _pool = new TestMemoryPool();
+// _pipe = new Pipe(new PipeOptions(_pool));
+// }
+
+// public void Dispose()
+// {
+// _pipe.Writer.Complete();
+// _pipe.Reader.Complete();
+// _pool?.Dispose();
+// }
+
+// private readonly TestMemoryPool _pool;
+
+// private readonly Pipe _pipe;
+
+// [Fact]
+// public void ByteByByteTest()
+// {
+// for (var i = 1; i <= 1024 * 1024; i++)
+// {
+// _pipe.Writer.GetMemory(100);
+// _pipe.Writer.Advance(1);
+// _pipe.Writer.Commit();
+
+// Assert.Equal(i, _pipe.Length);
+// }
+
+// _pipe.Writer.FlushAsync();
+
+// for (int i = 1024 * 1024 - 1; i >= 0; i--)
+// {
+// ReadResult result = _pipe.Reader.ReadAsync().GetResult();
+// SequencePosition consumed = result.Buffer.Slice(1).Start;
+
+// Assert.Equal(i + 1, result.Buffer.Length);
+
+// _pipe.Reader.AdvanceTo(consumed, consumed);
+
+// Assert.Equal(i, _pipe.Length);
+// }
+// }
+
+// [Fact]
+// public void LengthCorrectAfterAlloc0AdvanceCommit()
+// {
+// _pipe.Writer.GetMemory(0);
+// _pipe.Writer.WriteEmpty(10);
+// _pipe.Writer.Commit();
+
+// Assert.Equal(10, _pipe.Length);
+// }
+
+// [Fact]
+// public void LengthCorrectAfterAllocAdvanceCommit()
+// {
+// PipeWriter writableBuffer = _pipe.Writer.WriteEmpty(10);
+// writableBuffer.Commit();
+
+// Assert.Equal(10, _pipe.Length);
+// }
+
+// [Fact]
+// public void LengthDecreasedAfterReadAdvanceConsume()
+// {
+// _pipe.Writer.GetMemory(100);
+// _pipe.Writer.Advance(10);
+// _pipe.Writer.Commit();
+// _pipe.Writer.FlushAsync();
+
+// ReadResult result = _pipe.Reader.ReadAsync().GetResult();
+// SequencePosition consumed = result.Buffer.Slice(5).Start;
+// _pipe.Reader.AdvanceTo(consumed, consumed);
+
+// Assert.Equal(5, _pipe.Length);
+// }
+
+// [Fact]
+// public void LengthNotChangeAfterReadAdvanceExamine()
+// {
+// PipeWriter writableBuffer = _pipe.Writer.WriteEmpty(10);
+// writableBuffer.Commit();
+// writableBuffer.FlushAsync();
+
+// ReadResult result = _pipe.Reader.ReadAsync().GetResult();
+// _pipe.Reader.AdvanceTo(result.Buffer.Start, result.Buffer.End);
+
+// Assert.Equal(10, _pipe.Length);
+// }
+// }
+//}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+using System.Buffers;
using System.Threading.Tasks;
using Xunit;
_pipe.Reset();
- Assert.Equal(0, _pipe.Length);
+ //Assert.Equal(0, _pipe.Length);
}
[Fact]
[InlineData(3, 4, 4)]
public void ThrowsForInvalidParameters(int arrayLength, int offset, int length)
{
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
+ PipeWriter writer = Pipe.Writer;
var array = new byte[arrayLength];
for (var i = 0; i < array.Length; i++)
{
[InlineData(1, 1, 1)]
public void CanWriteWithOffsetAndLenght(int alloc, int offset, int length)
{
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
+ PipeWriter writer = Pipe.Writer;
var array = new byte[] { 1, 2, 3 };
writer.Write(new Span<byte>(array, offset, length));
[Fact]
public void CanWriteEmpty()
{
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
+ PipeWriter writer = Pipe.Writer;
var array = new byte[] { };
writer.Write(array);
[Fact]
public void CanWriteIntoHeadlessBuffer()
{
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
+ PipeWriter writer = Pipe.Writer;
writer.Write(new byte[] { 1, 2, 3 });
Assert.Equal(new byte[] { 1, 2, 3 }, Read());
[Fact]
public void CanWriteMultipleTimes()
{
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
+ PipeWriter writer = Pipe.Writer;
writer.Write(new byte[] { 1 });
writer.Write(new byte[] { 2 });
public void CanWriteOverTheBlockLength()
{
Memory<byte> memory = Pipe.Writer.GetMemory();
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
+ PipeWriter writer = Pipe.Writer;
IEnumerable<byte> source = Enumerable.Range(0, memory.Length).Select(i => (byte)i);
byte[] expectedBytes = source.Concat(source).Concat(source).ToArray();
[Fact]
public void EnsureAllocatesSpan()
{
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
- writer.Ensure(10);
+ PipeWriter writer = Pipe.Writer;
+ var span = writer.GetSpan(10);
- Assert.True(writer.Span.Length > 10);
- Assert.Equal(new byte[] { }, Read());
- }
-
- [Fact]
- public void ExposesSpan()
- {
- int initialLength = Pipe.Writer.GetMemory().Length;
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
- Assert.Equal(initialLength, writer.Span.Length);
+ Assert.True(span.Length >= 10);
Assert.Equal(new byte[] { }, Read());
}
[Fact]
public void SlicesSpanAndAdvancesAfterWrite()
{
- int initialLength = Pipe.Writer.GetMemory().Length;
+ int initialLength = Pipe.Writer.GetSpan(3).Length;
- OutputWriter<PipeWriter> writer = OutputWriter.Create(Pipe.Writer);
+ PipeWriter writer = Pipe.Writer;
writer.Write(new byte[] { 1, 2, 3 });
+ Span<byte> span = Pipe.Writer.GetSpan();
- Assert.Equal(initialLength - 3, writer.Span.Length);
- Assert.Equal(Pipe.Writer.GetMemory().Length, writer.Span.Length);
+ Assert.Equal(initialLength - 3, span.Length);
Assert.Equal(new byte[] { 1, 2, 3 }, Read());
}
projects / platform / upstream / dotnet / runtime.git / commitdiff