public void Empty()
{
var stream = new TestStream (new MemoryStream (), null);
var rpcStream = new RPCStream (stream);
Assert.IsFalse (rpcStream.DataAvailable);
//rpcStream.Read ();
}
public void ReadMultipleRequests ()
{
var multipleRequestBytes = new byte [requestBytes.Length * 5];
for (int i = 0; i < 5; i++)
Array.Copy (requestBytes, 0, multipleRequestBytes, i * requestBytes.Length, requestBytes.Length);
var byteStream = new TestStream (multipleRequestBytes);
var rpcStream = new RPCStream (byteStream);
Assert.AreEqual (0, rpcStream.BytesWritten);
Assert.AreEqual (0, rpcStream.BytesRead);
for (int i = 0; i < 5; i++) {
Assert.IsTrue (rpcStream.DataAvailable);
Assert.AreEqual (0, rpcStream.BytesWritten);
Assert.AreEqual (multipleRequestBytes.Length, rpcStream.BytesRead);
Request request = rpcStream.Read ();
if (i < 4)
Assert.IsTrue (rpcStream.DataAvailable);
else {
Assert.IsFalse (rpcStream.DataAvailable);
Assert.Throws<KRPC.Server.Message.NoRequestException> (() => rpcStream.Read ());
}
Assert.AreEqual (expectedRequest.Service, request.Service);
Assert.AreEqual (expectedRequest.Procedure, request.Procedure);
Assert.AreEqual (0, rpcStream.BytesWritten);
Assert.AreEqual (multipleRequestBytes.Length, rpcStream.BytesRead);
}
Assert.IsFalse (byteStream.Closed);
}
public void NoHelloMessage()
{
var responseStream = new MemoryStream ();
var stream = new TestStream (new MemoryStream (), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock<IClient<byte,byte>> ();
mockByteClient.Setup (x => x.Stream).Returns (stream);
var byteClient = mockByteClient.Object;
var server = new StreamServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse (eventArgs.Request.ShouldAllow);
Assert.IsTrue (eventArgs.Request.ShouldDeny);
Assert.AreEqual (0, responseStream.Length);
}
public void ValidHelloMessage ()
{
var responseStream = new MemoryStream ();
var stream = new TestStream (new MemoryStream (helloMessage), responseStream);
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var byteClient = new TestClient (stream);
var server = new RPCServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionEventArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsTrue (eventArgs.Request.ShouldAllow);
Assert.IsFalse (eventArgs.Request.ShouldDeny);
server.Update ();
Assert.AreEqual (1, server.Clients.Count ());
Assert.AreEqual ("Jebediah Kerman!!!", server.Clients.First ().Name);
byte[] bytes = responseStream.ToArray ();
byte[] responseBytes = byteClient.Guid.ToByteArray ();
Assert.IsTrue (responseBytes.SequenceEqual (bytes));
}
private void Test_Read1() {
string s;
string crlf = "\r\n";
var stream = new TestStream(false, B(
"ab\r\r\n" +
"e" + (s = "fgh" + crlf + "ijkl" + crlf + "mnop" + crlf + crlf + crlf + crlf + "qrst") +
crlf + "!"
));
int s_crlf_count = 6;
var io = new RubyIO(Context, stream, "r");
Assert(io.PeekByte() == (byte)'a');
var buffer = MutableString.CreateBinary(B("foo:"));
Assert(io.AppendBytes(buffer, 4) == 4);
Assert(buffer.ToString() == "foo:ab\r\n");
buffer = MutableString.CreateBinary();
Assert(io.AppendBytes(buffer, 1) == 1);
Assert(buffer.ToString() == "e");
buffer = MutableString.CreateMutable("x:");
int c = s.Length - s_crlf_count - 2;
Assert(io.AppendBytes(buffer, c) == c);
Assert(buffer.ToString() == "x:" + s.Replace(crlf, "\n").Substring(0, c));
buffer = MutableString.CreateBinary();
Assert(io.AppendBytes(buffer, 10) == 4);
Assert(buffer.ToString() == "st\n!");
buffer = MutableString.CreateBinary();
Assert(io.AppendBytes(buffer, 10) == 0);
Assert(buffer.ToString() == "");
}
public void Setup()
{
_testStream = new TestStream();
_dut = new Mavlink(_testStream);
_dut.PacketReceived += (sender, e) => _decodedPackets.Add(e);
_decodedPackets = new List<MavlinkPacket>();
_dut.Start();
}
public void DoesntWrapSeekableStream()
{
var s = new TestStream(true, "some data");
using (var actual = SeekableStreamWrapper.FromStream(s))
{
Assert.AreSame(s, actual);
Assert.IsTrue(actual.CanSeek);
}
}
public void Empty()
{
var stream = new TestStream (new MemoryStream (), null);
var rpcStream = new RPCStream (stream);
Assert.IsFalse (rpcStream.DataAvailable);
//rpcStream.Read ();
Assert.AreEqual (0, rpcStream.BytesWritten);
Assert.AreEqual (0, rpcStream.BytesRead);
}
public void Empty ()
{
var byteStream = new TestStream (new MemoryStream ());
var rpcStream = new RPCStream (byteStream);
Assert.IsFalse (rpcStream.DataAvailable);
Assert.Throws<KRPC.Server.Message.NoRequestException> (() => rpcStream.Read ());
Assert.AreEqual (0, rpcStream.BytesWritten);
Assert.AreEqual (0, rpcStream.BytesRead);
Assert.IsFalse (byteStream.Closed);
}
public void ReadSingleRequest()
{
var stream = new TestStream (new MemoryStream (requestBytes), null);
var rpcStream = new RPCStream (stream);
Assert.IsTrue (rpcStream.DataAvailable);
Request request = rpcStream.Read ();
Assert.IsFalse (rpcStream.DataAvailable);
Assert.AreEqual (expectedRequest.Service, request.Service);
Assert.AreEqual (expectedRequest.Procedure, request.Procedure);
}
public void ReadAllBytes_Resize(bool canSeek)
{
var sourceArray = new byte[] { 1, 2 };
var stream = new TestStream(
canSeek: canSeek,
backingStream: new MemoryStream(sourceArray),
length: 3
);
Assert.Equal(new byte[] { 1, 2 }, stream.ReadAllBytes());
}
public async Task ShouldReturnNullWhenNonSeekableStreamIsEmpty()
{
using (var stream = new TestStream())
{
stream.DisableSeeking();
byte[] bytes = await stream.ToArrayAsync();
Assert.IsNull(bytes);
}
}
public void WhenLeaveOpenIsTrueDisposeInNotCalled()
{
var test = new TestStream();
var dec = LZ4Stream.Decode(test, leaveOpen: true);
var enc = LZ4Stream.Encode(test, leaveOpen: true);
enc.Close();
dec.Close();
Assert.Equal(0, test.Disposed);
}
public void Dispose_IsIdempotent()
{
using (var stream = new TestStream())
using (var result = new DownloadResourceResult(stream))
{
result.Dispose();
result.Dispose();
Assert.Equal(1, stream.DisposeCallCount);
}
}
public void Empty()
{
var byteStream = new TestStream(new MemoryStream());
var rpcStream = new KRPC.Server.SerialIO.RPCStream(byteStream, null);
Assert.IsFalse(rpcStream.DataAvailable);
Assert.Throws <KRPC.Server.Message.NoRequestException> (() => rpcStream.Read());
Assert.AreEqual(0, rpcStream.BytesWritten);
Assert.AreEqual(0, rpcStream.BytesRead);
Assert.IsFalse(byteStream.Closed);
}
public void TestThrowOnSetPositionOnUnseekableStream()
{
using (MemoryStream memoryStream = new MemoryStream()) {
TestStream testStream = new TestStream(memoryStream, true, true, false);
PartialStream partialStream = new PartialStream(testStream, 0, 0);
Assert.Throws <NotSupportedException>(
delegate() { partialStream.Position = 0; }
);
}
}
public void ReadAllBytes(bool canSeek)
{
var sourceArray = new byte[] { 1, 2, 3, 4 };
var stream = new TestStream(
canSeek: canSeek,
backingStream: new MemoryStream(sourceArray)
);
stream.ReadByte();
Assert.Equal(new byte[] { 2, 3, 4 }, stream.ReadAllBytes());
}
public async Task When_reading_a_non_PDB()
{
var sut = new Pdb70SymbolMetadataProvider();
var stream = new TestStream(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
using (var metadata = await sut.TryGetSymbolMetadataAsync(stream))
{
Assert.Null(metadata);
}
}
public async Task When_getting_the_metadata_for_unsupported_data()
{
var sut = new FallbackSymbolsMetadataProvider();
var stream = new TestStream(MZ.Exes.NuGet);
using (var file = await sut.TryGetSymbolMetadataAsync(stream, CancellationToken.None))
{
Assert.Equal("7f71c74f53a9138b31495107e33077d1", file.Identifier);
Assert.False(file.SupportsSourceServerInformation);
}
}
public void WrapsNonSeekableStream()
{
var s = new TestStream(false, "some data");
using (var actual = SeekableStreamWrapper.FromStream(s))
{
Assert.AreNotSame(s, actual);
Assert.IsInstanceOfType(typeof(SeekableStreamWrapper), actual);
Assert.IsTrue(actual.CanSeek);
Assert.IsFalse(actual.CanWrite);
}
}
public void TestThrowOnReadFromUnreadableStream()
{
using (MemoryStream memoryStream = new MemoryStream()) {
TestStream testStream = new TestStream(memoryStream, false, true, true);
PartialStream partialStream = new PartialStream(testStream, 0, 0);
byte[] test = new byte[10];
Assert.Throws <NotSupportedException>(
delegate() { Console.WriteLine(partialStream.Read(test, 0, 10)); }
);
}
}
public void Ctor_Streams()
{
Assert.Throws <ArgumentException>(() => new PEReader(new TestStream(canRead: false, canSeek: false, canWrite: false)));
Assert.Throws <ArgumentException>(() => new PEReader(new TestStream(canRead: true, canSeek: false, canWrite: false)));
var s = new TestStream(canRead: true, canSeek: true, canWrite: false);
new PEReader(s);
new PEReader(s, PEStreamOptions.Default, 0);
Assert.Throws <ArgumentOutOfRangeException>(() => new PEReader(s, PEStreamOptions.Default, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => new PEReader(s, PEStreamOptions.Default, 1));
}
public void ShouldThrowExceptionWhenStreamCannotSeek()
{
var optimizer = new ImageOptimizer();
using (TestStream stream = new TestStream(true, true, false))
{
ExceptionAssert.ThrowsArgumentException("stream", () =>
{
optimizer.Compress(stream);
});
}
}
public void Constructor_StreamIsTooLong_ThrowsException()
{
using (TestStream stream = new TestStream(true, true, true))
{
stream.SetLength(long.MaxValue);
ExceptionAssert.ThrowsArgumentException("length", () =>
{
new Bytes(stream);
});
}
}
public async Task UploadsStreamInBlocksIfLengthNotAvailable()
{
TestStream content = new TestStream(_async, null, TestStream.Read(0, 10));
TrackingArrayPool testPool = new TrackingArrayPool();
StagingSink sink = new StagingSink();
Mock <BlockBlobClient> clientMock = new Mock <BlockBlobClient>(MockBehavior.Strict, new Uri("http://mock"), new BlobClientOptions());
clientMock.SetupGet(c => c.ClientConfiguration).CallBase();
SetupInternalStaging(clientMock, sink);
var uploader = new PartitionedUploader <BlobUploadOptions, BlobContentInfo>(BlockBlobClient.GetPartitionedUploaderBehaviors(clientMock.Object), default, arrayPool: testPool);
public void CStringExceptionTest()
{
TestStream stream = new TestStream(15, EndiannessType.LittleEndian);
Assert.ThrowsException <IndexOutOfRangeException>(() => stream.WriteCString("Sample string longer than 15 chars"));
// There shouldn't be null termination in first 15 bytes.
stream.WriteString("Sample string1");
stream.Seek(0);
Assert.ThrowsException <IndexOutOfRangeException>(() => stream.ReadCString());
}
public void When_having_a_readable_stream_be_not_write_only_should_succeed()
{
// Arrange
using var stream = new TestStream { Readable = true, Writable = true };
// Act
Action act = () =>
stream.Should().NotBeWriteOnly();
// Assert
act.Should().NotThrow();
}
public void When_having_a_non_writable_stream_be_not_writable_should_succeed()
{
// Arrange
using var stream = new TestStream { Writable = false };
// Act
Action act = () =>
stream.Should().NotBeWritable();
// Assert
act.Should().NotThrow();
}
public void When_a_stream_does_not_have_an_unexpected_length_it_should_succeed()
{
// Arrange
using var stream = new TestStream { Seekable = true, WithLength = 1 };
// Act
Action act = () =>
stream.Should().NotHaveLength(10);
// Assert
act.Should().NotThrow();
}
public async Task UploadsStreamInBlocksIfLengthNotAvailable()
{
TestStream content = new TestStream(_async, null, TestStream.Read(0, 10));
TrackingArrayPool testPool = new TrackingArrayPool();
StagingSink sink = new StagingSink();
Mock <BlockBlobClient> clientMock = new Mock <BlockBlobClient>(MockBehavior.Strict, new Uri("http://mock"), new BlobClientOptions());
clientMock.SetupGet(c => c.ClientDiagnostics).CallBase();
SetupAsyncStaging(clientMock, sink);
PartitionedUploader uploader = new PartitionedUploader(clientMock.Object, default, arrayPool: testPool);
public void ReadIsCancelledOnTimeoutWithAdditionalToken()
{
var testStream = new TestStream(true);
var timeoutStream = new ReadTimeoutStream(testStream, _defaultTimeout);
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(1000000);
var cancellationToken = cancellationTokenSource.Token;
Assert.ThrowsAsync <OperationCanceledException>(() => timeoutStream.ReadAsync(_buffer, 0, 1, cancellationToken));
}
public void WrapsNonSeekableStream()
{
var s = new TestStream(false, "some data");
using (var actual = SeekableStreamWrapper.FromStream(s))
{
Assert.AreNotSame(s, actual);
Assert.IsInstanceOfType(typeof(SeekableStreamWrapper), actual);
Assert.IsTrue(actual.CanSeek);
Assert.IsFalse(actual.CanWrite);
}
}
public void When_a_stream_has_the_expected_position_it_should_succeed()
{
// Arrange
using var stream = new TestStream { Seekable = true, Position = 10 };
// Act
Action act = () =>
stream.Should().HavePosition(10);
// Assert
act.Should().NotThrow();
}
public void When_having_a_readable_stream_be_readable_should_succeed()
{
// Arrange
using var stream = new TestStream { Readable = true };
// Act
Action act = () =>
stream.Should().BeReadable();
// Assert
act.Should().NotThrow();
}
private FileBundle CreateBundle(TestStream memoryStream)
{
var mockFileSystem = new Mock <IFileSystemService>();
mockFileSystem.Setup(f => f.FileExists(BundleFileName)).Returns(false);
mockFileSystem.Setup(f => f.CreateFile(BundleFileName)).Returns(memoryStream);
mockFileSystem.Setup(f => f.OpenFile(BundleFileName, OpenFileMode.Read)).Returns(memoryStream);
mockFileSystem.Setup(f => f.OpenFile(BundleFileName, OpenFileMode.ReadWrite)).Returns(memoryStream);
var bundle = new FileBundle(BundleFileName, 3, mockFileSystem.Object);
return(bundle);
}
public void ShouldThrowExceptionWhenStreamCannotRead()
{
var optimizer = new ImageOptimizer();
using (TestStream stream = new TestStream(false, true, true))
{
ExceptionAssert.Throws <ArgumentException>("stream", () =>
{
optimizer.LosslessCompress(stream);
});
}
}
protected override async Task When()
{
GroupName = Guid.NewGuid().ToString();
SubscriptionPath = string.Format("/subscriptions/{0}/{1}", TestStream.Substring(9), GroupName);
Response = await MakeJsonPut(SubscriptionPath,
new {
ResolveLinkTos = true,
BufferSize = 10,
ReadBatchSize = 11
},
_admin);
}
public void WrapsNonSeekableStream()
{
var s = new TestStream(false, "some data");
using (var actual = SeekableStreamWrapper.FromStream(s))
{
Assert.NotSame(s, actual);
Assert.IsAssignableFrom(typeof(SeekableStreamWrapper), actual);
Assert.True(actual.CanSeek);
Assert.False(actual.CanWrite);
}
}
protected override async Task When()
{
GroupName = Guid.NewGuid().ToString();
SubscriptionPath = string.Format("/subscriptions/{0}/{1}", TestStream.Substring(9), GroupName);
Response = await MakeJsonPut(SubscriptionPath,
new {
ResolveLinkTos = true,
},
_admin);
SubsciptionInfo = await GetJson <JObject>(SubscriptionPath + "/info", ContentType.Json);
}
public void WriteSingleResponse()
{
var stream = new MemoryStream();
var byteStream = new TestStream(null, stream);
var rpcStream = new RPCStream(byteStream);
rpcStream.Write(expectedResponse);
Assert.AreEqual(responseBytes.ToHexString(), stream.ToArray().ToHexString());
Assert.AreEqual(responseBytes.Length, rpcStream.BytesWritten);
Assert.AreEqual(0, rpcStream.BytesRead);
Assert.IsFalse(byteStream.Closed);
}
public async Task ReceiveAsync_MultipleReads_ReadEnvelopeJsonFromStream()
{
var content = DataUtil.CreateTextContent();
var message = DataUtil.CreateMessage(content);
var messageJson = DataUtil.CreateMessageJson();
var cancelationToken = DataUtil.CreateCancellationToken();
var bufferParts = DataUtil.CreateRandomInt(10) + 1;
byte[] messageBuffer = Encoding.UTF8.GetBytes(
messageJson);
var bufferPartSize = messageBuffer.Length / bufferParts;
byte[][] messageBufferParts = new byte[bufferParts][];
for (int i = 0; i < bufferParts; i++)
{
if (i + 1 == bufferParts)
{
messageBufferParts[i] = messageBuffer
.Skip(i * bufferPartSize)
.ToArray();
}
else
{
messageBufferParts[i] = messageBuffer
.Skip(i * bufferPartSize)
.Take(bufferPartSize)
.ToArray();
}
}
int bufferSize = messageBuffer.Length + DataUtil.CreateRandomInt(1000);
var stream = new TestStream(messageBufferParts);
var target = await GetTargetAndOpenAsync(bufferSize, stream);
_envelopeSerializer
.Setup(e => e.Deserialize(messageJson))
.Returns(message)
.Verifiable();
var actual = await target.ReceiveAsync(cancelationToken);
_stream.Verify();
_envelopeSerializer.Verify();
Assert.AreEqual(message, actual);
Assert.AreEqual(messageBufferParts.Length, stream.ReadCount);
}
public async Task ShouldReturnEmptyArrayWhenStreamOnlyContainsPreamable()
{
using (var stream = new TestStream())
{
stream.Write(Utf8Preamable, 0, Utf8Preamable.Length);
stream.Position = 0;
byte[] bytes = await stream.ToArrayAsync();
Assert.IsNotNull(bytes);
Assert.AreEqual(0, bytes.Length);
}
}
public void TestCanSeek()
{
MemoryStream yesStream = new MemoryStream();
TestStream noStream = new TestStream(yesStream, true, true, false);
Stream[] yesGroup = new Stream[] { yesStream, yesStream, yesStream, yesStream };
Stream[] partialGroup = new Stream[] { yesStream, yesStream, noStream, yesStream };
Stream[] noGroup = new Stream[] { noStream, noStream, noStream, noStream };
Assert.IsTrue(new ChainStream(yesGroup).CanSeek);
Assert.IsFalse(new ChainStream(partialGroup).CanSeek);
Assert.IsFalse(new ChainStream(noGroup).CanSeek);
}
public async Task When_reading_NuGet_exe()
{
var sut = new MZSymbolMetadataProvider();
// Authoritative identifiers can be calculated with:
// "C:\Program Files (x86)\Windows Kits\8.1\Debuggers\x64\symstore.exe" add /f NuGet.exe /s "C:\symbols" /t symblr
// Make sure the file is larger than 32k.
var stream = new TestStream(Exes.NuGet);
using (var file = await sut.TryGetSymbolMetadataAsync(stream, CancellationToken.None))
{
Assert.Equal("550953A8c000", file.Identifier);
Assert.False(file.SupportsSourceServerInformation);
}
}
public void ReadSingleRequest ()
{
var byteStream = new TestStream (requestBytes);
var rpcStream = new RPCStream (byteStream);
Assert.AreEqual (0, rpcStream.BytesWritten);
Assert.AreEqual (0, rpcStream.BytesRead);
Assert.IsTrue (rpcStream.DataAvailable);
Assert.AreEqual (0, rpcStream.BytesWritten);
Assert.AreEqual (requestBytes.Length, rpcStream.BytesRead);
Request request = rpcStream.Read ();
Assert.IsFalse (rpcStream.DataAvailable);
Assert.Throws<KRPC.Server.Message.NoRequestException> (() => rpcStream.Read ());
Assert.AreEqual (expectedRequest.Service, request.Service);
Assert.AreEqual (expectedRequest.Procedure, request.Procedure);
Assert.AreEqual (0, rpcStream.BytesWritten);
Assert.AreEqual (requestBytes.Length, rpcStream.BytesRead);
Assert.IsFalse (byteStream.Closed);
}
public async Task When_reading_a_file_with_source_server_information()
{
var sut = new Pdb70SymbolMetadataProvider();
var ms = new MemoryStream();
var stream = new TestStream(ms);
await stream.WriteAsync(Pdbs.RealSrcSrv, 0, Pdbs.RealSrcSrv.Length);
stream.Position = 0;
using (var metadata = await sut.TryGetSymbolMetadataAsync(stream))
{
Assert.NotNull(metadata);
Assert.True(metadata.SupportsSourceServerInformation);
Assert.Equal("63ba9bb5992dfc429f6bcc52135dbb092", metadata.Identifier);
Assert.True(metadata.HasSourceServerInformation);
Assert.Equal(581, metadata.SourceInformation.Count);
Assert.False(metadata.SourceInformation.Any(x => string.IsNullOrEmpty(x.TargetPath)));
}
}
public void File_AppendBytes1()
{
string s;
string crlf = "\r\n";
var stream = new TestStream(false, B(
"ab\r\r\n" +
"e" + (s = "fgh" + crlf + "ijkl" + crlf + "mnop" + crlf + crlf + crlf + crlf + "qrst") +
crlf + "!"
));
int s_crlf_count = 6;
var io = new RubyBufferedStream(stream);
Assert(io.PeekByte() == (byte)'a');
var buffer = MutableString.CreateBinary(B("foo:"));
Assert(io.AppendBytes(buffer, 4, false) == 4);
Assert(buffer.ToString() == "foo:ab\r\n");
buffer = MutableString.CreateBinary();
Assert(io.AppendBytes(buffer, 1, false) == 1);
Assert(buffer.ToString() == "e");
buffer = MutableString.CreateMutable("x:", RubyEncoding.Binary);
int c = s.Length - s_crlf_count - 2;
Assert(io.AppendBytes(buffer, c, false) == c);
Assert(buffer.ToString() == "x:" + s.Replace(crlf, "\n").Substring(0, c));
buffer = MutableString.CreateBinary();
Assert(io.AppendBytes(buffer, 10, false) == 4);
Assert(buffer.ToString() == "st\n!");
buffer = MutableString.CreateBinary();
Assert(io.AppendBytes(buffer, 10, false) == 0);
Assert(buffer.ToString() == "");
stream = new TestStream(false, B(s = "abcd" + crlf + "xyz" + crlf + "qqq;"));
io = new RubyBufferedStream(stream);
buffer = MutableString.CreateBinary();
Assert(io.AppendBytes(buffer, Int32.MaxValue, true) == s.Length);
io.BaseStream.Seek(0, SeekOrigin.Begin);
Assert(io.AppendBytes(buffer, Int32.MaxValue, false) == s.Length - 2);
Assert(buffer.ToString() == s + s.Replace(crlf, "\n"));
}
public async Task When_reading_a_PDB_with_no_source_server_stream()
{
var stream = new TestStream(Pdbs.NoSrcSrv);
using (var file = await Pdb70File.TryOpenAsync(stream))
{
Assert.Equal(1, file.Age);
Assert.Equal(0x555CE245, file.Signature);
Assert.Equal(20000404, file.Version);
Assert.Equal(Guid.Parse("{b59bba63-2d99-42fc-9f6b-cc52135dbb09}"), file.Guid);
Assert.False(file.StreamExists("SRCSRV"));
Assert.True(file.StreamExists(1));
Assert.True(file.StreamNames.Any(x => x.StartsWith("/src/files/")));
Assert.True(file.StreamNames.Any(x => x.StartsWith("/LinkInfo")));
}
Assert.True(stream.IsDisposed);
Assert.True(stream.DidRead);
Assert.False(stream.DidWrite);
}
public void InvalidHelloMessageIdentifier()
{
helloMessage [15] = 0x00;
var stream = new TestStream (new MemoryStream (helloMessage));
// Create mock byte server and client
var mockByteServer = new Mock<IServer<byte,byte>> ();
var byteServer = mockByteServer.Object;
var mockByteClient = new Mock<IClient<byte,byte>> ();
mockByteClient.Setup (x => x.Stream).Returns (stream);
var byteClient = mockByteClient.Object;
var server = new RPCServer (byteServer);
server.OnClientRequestingConnection += (sender, e) => e.Request.Allow ();
server.Start ();
// Fire a client connection event
var eventArgs = new ClientRequestingConnectionArgs<byte,byte> (byteClient);
mockByteServer.Raise (m => m.OnClientRequestingConnection += null, eventArgs);
Assert.IsFalse (eventArgs.Request.ShouldAllow);
Assert.IsTrue (eventArgs.Request.ShouldDeny);
}
public async Task When_writing_to_a_PDB_with_no_source_server_stream()
{
var longString = new StringBuilder();
for (var i = 0; i < 1000; i++)
longString.AppendFormat("Line {0}", i).AppendLine();
var ms = new MemoryStream();
var stream = new TestStream(ms);
await stream.WriteAsync(Pdbs.NoSrcSrv, 0, Pdbs.NoSrcSrv.Length);
stream.Position = 0;
using (var file = await Pdb70File.TryOpenAsync(stream))
{
using (var srcsrv = file.GetStream("SRCSRV"))
using (var writer = new StreamWriter(srcsrv))
{
await writer.WriteAsync(longString.ToString());
await writer.FlushAsync();
}
await file.SaveAsync();
stream = new TestStream(ms.ToArray());
stream.Position = 0;
}
using (var file = await Pdb70File.TryOpenAsync(stream))
{
using (var srcsrv = file.GetStream("SRCSRV"))
using (var reader = new StreamReader(srcsrv))
{
var data = await reader.ReadToEndAsync();
Assert.Equal(longString.ToString(), data);
}
}
}
public void When_syncrhonously_writing_to_a_PDB_with_no_source_server_stream()
{
var longString = new StringBuilder();
for (var i = 0; i < 1000; i++)
longString.AppendFormat("Line {0}", i).AppendLine();
var ms = new MemoryStream();
var stream = new TestStream(ms);
stream.Write(Pdbs.NoSrcSrv, 0, Pdbs.NoSrcSrv.Length);
stream.Position = 0;
using (var file = Pdb70File.TryOpenAsync(stream).Result)
{
using (var srcsrv = file.GetStream("SRCSRV"))
using (var writer = new StreamWriter(srcsrv))
{
writer.Write(longString.ToString());
writer.Flush();
}
file.SaveAsync().Wait();
stream = new TestStream(ms.ToArray());
stream.Position = 0;
}
using (var file = Pdb70File.TryOpenAsync(stream).Result)
{
using (var srcsrv = file.GetStream("SRCSRV"))
using (var reader = new StreamReader(srcsrv))
{
var data = reader.ReadToEnd();
Assert.Equal(longString.ToString(), data);
}
}
}
public unsafe void CopyTo3()
{
const int bufferSize = 64;
byte* buffer = (byte*)Marshal.AllocHGlobal(bufferSize);
try
{
var s = new TestStream(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
InvalidateMemory(buffer, bufferSize);
s.CopyTo(buffer, 8);
Assert.Equal(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 }, ReadBuffer(buffer, bufferSize));
}
finally
{
Marshal.FreeHGlobal((IntPtr)buffer);
}
}
public bool PosTest6()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest6: Call Dispose twice with disposing set to true once and another time set to false");
try
{
TestStream ts = new TestStream();
ts.DisposeWrapper(true);
ts.DisposeWrapper(false);
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
public void TestThrowOnReadFromUnreadableStream() {
using(MemoryStream memoryStream = new MemoryStream()) {
TestStream testStream = new TestStream(memoryStream, false, true, true);
PartialStream partialStream = new PartialStream(testStream, 0, 0);
byte[] test = new byte[10];
Assert.Throws<NotSupportedException>(
delegate() { Console.WriteLine(partialStream.Read(test, 0, 10)); }
);
}
}
public void TestThrowOnSetPositionOnUnseekableStream() {
using(MemoryStream memoryStream = new MemoryStream()) {
TestStream testStream = new TestStream(memoryStream, true, true, false);
PartialStream partialStream = new PartialStream(testStream, 0, 0);
Assert.Throws<NotSupportedException>(
delegate() { partialStream.Position = 0; }
);
}
}
public void TestCanSeekProperty() {
using(MemoryStream memoryStream = new MemoryStream()) {
TestStream yesStream = new TestStream(memoryStream, true, true, true);
TestStream noStream = new TestStream(memoryStream, true, true, false);
Assert.IsTrue(new PartialStream(yesStream, 0, 0).CanSeek);
Assert.IsFalse(new PartialStream(noStream, 0, 0).CanSeek);
}
}
public void TestThrowOnUnseekableStreamWithOffsetInConstructor() {
using(MemoryStream memoryStream = new MemoryStream()) {
memoryStream.SetLength(123);
TestStream testStream = new TestStream(memoryStream, true, true, false);
Assert.Throws<ArgumentException>(
delegate() { Console.WriteLine(new PartialStream(testStream, 23, 100)); }
);
}
}
public async Task When_an_exception_is_thrown_during_reading()
{
var ms = new MemoryStream();
var stream = new TestStream(ms);
await stream.WriteAsync(Pdbs.SrcSrv, 0, Pdbs.SrcSrv.Length);
stream.Position = 0;
stream.ThrowAfter = 1024;
await Assert.ThrowsAsync<Pdb70LoadException>(async () =>
{
try
{
await Pdb70File.TryOpenAsync(stream);
}
catch (Pdb70LoadException e)
{
Assert.Equal(Pdb70LoadErrorCode.Unknown, e.ErrorCode);
Assert.NotNull(e.InnerException);
Assert.Equal(e.InnerException.Message, "Exception from the stream.");
throw;
}
});
}
public void File_ReadLine1() {
var stream = new TestStream(false, B(
"a\r\n\r\nbbbbbbbbbbbbbbbbbbbbb1bbbbbbbbbbbbb2bbbbbbbbbbbbbbbbbbbbb3bbbbbbbbbbbbb4\rc\nd\n\n\n\nef")
);
foreach (int bufferSize in new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100 }) {
stream.Seek(0, SeekOrigin.Begin);
var io = new RubyBufferedStream(stream, false, bufferSize);
TestReadLine(io, true, "a\r\n");
TestReadLine(io, true, "\r\n");
TestReadLine(io, true, "bbbbbbbbbbbbbbbbbbbbb1bbbbbbbbbbbbb2bbbbbbbbbbbbbbbbbbbbb3bbbbbbbbbbbbb4\rc\n");
TestReadLine(io, true, "d\n");
TestReadLine(io, true, "\n");
TestReadLine(io, true, "\n");
TestReadLine(io, true, "\n");
TestReadLine(io, true, "ef");
TestReadLine(io, true, null);
stream.Seek(0, SeekOrigin.Begin);
TestReadLine(io, false, "a\n");
TestReadLine(io, false, "\n");
TestReadLine(io, false, "bbbbbbbbbbbbbbbbbbbbb1bbbbbbbbbbbbb2bbbbbbbbbbbbbbbbbbbbb3bbbbbbbbbbbbb4\rc\n");
TestReadLine(io, false, "d\n");
TestReadLine(io, false, "\n");
TestReadLine(io, false, "\n");
TestReadLine(io, false, "\n");
TestReadLine(io, false, "ef");
TestReadLine(io, false, null);
}
}
public void TestOperations()
{
// invalid operations
using (var stack = new StreamStack())
{
AssertException(() => stack.Push(null));
Assert.IsNull(stack.GetStream<Stream>());
stack.Push(new MemoryStream());
AssertException(() => stack.Seek(0, SeekOrigin.Current));
}
// stream access
using (var stack = new StreamStack())
{
var buffer = new MemoryStream();
var test = new TestStream(buffer);
stack.Push(buffer);
Assert.AreEqual(stack.Top, buffer);
stack.Push(test);
Assert.AreEqual(stack.Top, test);
Assert.AreEqual(stack.GetStream<MemoryStream>(), buffer);
Assert.AreEqual(stack.GetStream<TestStream>(), test);
}
// stream flush
using (var stack = new StreamStack())
{
var stream1 = new TestStream(new MemoryStream());
var stream2 = new TestStream(stream1);
stack.Push(stream1);
stack.Push(stream2);
stack.Flush();
Assert.IsTrue(stream1.Flushed);
Assert.IsTrue(stream2.Flushed);
}
// stream read
using (var stack = new StreamStack())
{
var buffer = new MemoryStream();
StreamWrite(buffer, "test");
buffer.Position = 0;
stack.Push(buffer);
stack.Push(new TestStream(stack.Top));
Assert.AreEqual(StreamRead(stack), "test");
}
// stream write
using (var stack = new StreamStack())
{
var buffer = new MemoryStream();
stack.Push(buffer);
stack.Push(new TestStream(stack.Top));
StreamWrite(stack, "test");
buffer.Position = 0;
Assert.AreEqual(StreamRead(buffer), "test");
}
// stream disposal
using (var stack = new StreamStack())
{
var stream1 = new TestStream(new MemoryStream());
var stream2 = new TestStream(stream1);
stack.Push(stream1);
stack.Push(stream2);
stack.Dispose();
Assert.IsTrue(stream1.Disposed);
Assert.IsTrue(stream2.Disposed);
}
}
