public void WritesInChunks()
{
int bufferSize = 500;
int size = 3000;
var buffers = new List <ArraySegment <byte> >();
var writer = new BufferTextWriter((buffer, state) =>
{
buffers.Add(buffer);
},
null, reuseBuffers: true, bufferSize: bufferSize);
writer.Write(new string('C', size));
writer.Flush();
var expected = GetChunks(size, bufferSize).ToArray();
Assert.NotEmpty(buffers);
Assert.Equal(expected.Length, buffers.Count);
for (int i = 0; i < buffers.Count; i++)
{
Assert.Equal(expected[i], buffers[i].Count);
}
}
public void Ctor()
{
this.bufferTextWriter = new BufferTextWriter(this.sequence, DefaultEncoding);
Assert.Same(DefaultEncoding, this.bufferTextWriter.Encoding);
this.bufferTextWriter.Write('a');
this.AssertWritten("a");
}
public void CanInterleaveStringsAndRawBinary()
{
var buffers = new List <ArraySegment <byte> >();
var writer = new BufferTextWriter((buffer, state) =>
{
buffers.Add(buffer);
},
null, reuseBuffers: true, bufferSize: 128);
var encoding = new UTF8Encoding();
writer.Write('H');
writer.Write('e');
writer.Write("llo ");
writer.Write(new ArraySegment <byte>(encoding.GetBytes("World")));
writer.Flush();
Assert.Equal(2, buffers.Count);
var s = "";
foreach (var buffer in buffers)
{
s += encoding.GetString(buffer.Array, buffer.Offset, buffer.Count);
}
Assert.Equal("Hello World", s);
}
public void CanEncodingSurrogatePairsCorrectly()
{
var bytes = new List <byte>();
var writer = new BufferTextWriter((buffer, state) =>
{
for (int i = buffer.Offset; i < buffer.Count; i++)
{
bytes.Add(buffer.Array[i]);
}
}, null, reuseBuffers: true, bufferSize: 128);
writer.Write("\U00024B62"[0]);
writer.Write("\U00024B62"[1]);
writer.Flush();
var expected = new byte[] { 0xF0, 0xA4, 0xAD, 0xA2 };
Assert.Equal(expected, bytes);
}
public void Anything_Uninitialized(bool afterReset)
{
BufferTextWriter writer;
if (afterReset)
{
writer = this.bufferTextWriter;
writer.Reset();
}
else
{
writer = new BufferTextWriter();
}
Assert.Throws <InvalidOperationException>(() => writer.Flush());
Assert.IsType <InvalidOperationException>(writer.FlushAsync().Exception?.InnerException);
Assert.Throws <InvalidOperationException>(() => writer.Write(true));
Assert.Throws <InvalidOperationException>(() => writer.Write('a'));
Assert.Throws <InvalidOperationException>(() => writer.Write("a"));
}
public void WriteSameBufferIsUsedForWritingChunksIfReuseBuffersTrue()
{
var buffers = new List <ArraySegment <byte> >();
var writer = new BufferTextWriter((buffer, state) =>
{
buffers.Add(buffer);
},
null, reuseBuffers: true, bufferSize: 128);
writer.Write(new string('C', 10000));
writer.Flush();
Assert.True(buffers.Count > 1);
var underlyingBuffer = buffers[0].Array;
for (int i = 1; i < buffers.Count; i++)
{
Assert.Same(underlyingBuffer, buffers[i].Array);
}
}
public void TestBufferTextWriter()
{
var sw = new BufferTextWriter();
Assert.IsNotNull(sw.FormatProvider);
Assert.IsNotNull(sw.NewLine);
Assert.IsNotNull(sw.Encoding);
Assert.IsTrue(sw.ToString().Length == 0);
sw.Write("ABC");
Assert.IsTrue(sw.ToString().Length == 3);
sw.Write('a');
Assert.IsTrue(sw.ToString().Length == 4);
sw.Write(new char[3] {
'1', '1', '2'
}, 0, 3);
Assert.IsTrue(sw.ToString().Length == 7);
sw.Write(new char[3] {
'1', '1', '2'
});
Assert.IsTrue(sw.ToString().Length == 10);
}
public void Dispose_BeforeInitialize()
{
this.bufferTextWriter = new BufferTextWriter();
this.bufferTextWriter.Dispose();
this.bufferTextWriter.Dispose();
}
