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 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); } }