public async Task Connection_Dispose_ClosesSocket(bool disposeAsync, bool usePipe) { using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.Loopback); using SocketsConnectionFactory factory = new SocketsConnectionFactory(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Connection connection = await factory.ConnectAsync(server.EndPoint); Stream stream = usePipe ? null : connection.Stream; if (usePipe) { _ = connection.Pipe; } connection.ConnectionProperties.TryGet(out Socket socket); if (disposeAsync) { await connection.DisposeAsync(); } else { connection.Dispose(); } Assert.False(socket.Connected); if (!usePipe) { // In this case we can also verify if the stream is disposed Assert.Throws <ObjectDisposedException>(() => stream.Write(new byte[1])); } }
public async Task Connection_CloseAsync_ClosesSocket(bool usePipe, ConnectionCloseMethod method) { using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.Loopback); using SocketsConnectionFactory factory = new SocketsConnectionFactory(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Connection connection = await factory.ConnectAsync(server.EndPoint); Stream stream = null; if (usePipe) { _ = connection.Pipe; } else { stream = connection.Stream; } connection.ConnectionProperties.TryGet(out Socket socket); await connection.CloseAsync(method); Assert.Throws <ObjectDisposedException>(() => socket.Send(new byte[1])); if (!usePipe) // No way to observe the stream if we work with the pipe { Assert.Throws <ObjectDisposedException>(() => stream.Write(new byte[1])); } }
public async Task ConnectAsync_Success_SocketNoDelayIsTrue() { using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.Loopback); using SocketsConnectionFactory factory = new SocketsConnectionFactory(SocketType.Stream, ProtocolType.Tcp); using Connection connection = await factory.ConnectAsync(server.EndPoint); connection.ConnectionProperties.TryGet(out Socket socket); Assert.True(socket.NoDelay); }
public async Task ConnectAsync_TimedOut_ThrowsNetworkException() { using SocketsConnectionFactory factory = new SocketsConnectionFactory(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPEndPoint doesNotExist = new IPEndPoint(IPAddress.Parse("1.2.3.4"), 23); // SocketError.TimedOut currently maps to SocketError.Unknown, so no asserion await Assert.ThrowsAsync <NetworkException>(() => factory.ConnectAsync(doesNotExist).AsTask()); }
public async Task Constructor3_ConnectAsync_Success_PropagatesConstructorArgumentsToSocket(EndPoint endPoint, SocketType socketType, ProtocolType protocolType) { endPoint = RecreateUdsEndpoint(endPoint); using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, endPoint, protocolType); using SocketsConnectionFactory factory = new SocketsConnectionFactory(endPoint.AddressFamily, socketType, protocolType); using Connection connection = await factory.ConnectAsync(server.EndPoint); ValidateSocket(connection, socketType, protocolType, endPoint.AddressFamily); }
public async Task Constructor2_ConnectAsync_Success_CreatesIPv6DualModeSocket() { using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.IPv6Loopback); using SocketsConnectionFactory factory = new SocketsConnectionFactory(SocketType.Stream, ProtocolType.Tcp); using Connection connection = await factory.ConnectAsync(server.EndPoint); Socket socket = ValidateSocket(connection, SocketType.Stream, ProtocolType.Tcp, AddressFamily.InterNetworkV6); Assert.True(socket.DualMode); }
public async Task ConnectAsync_TimedOut_ThrowsNetworkException() { using SocketsConnectionFactory factory = new SocketsConnectionFactory(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPEndPoint doesNotExist = new IPEndPoint(IPAddress.Parse("1.2.3.4"), 23); NetworkException ex = await Assert.ThrowsAsync <NetworkException>(() => factory.ConnectAsync(doesNotExist).AsTask()); Assert.Equal(NetworkError.TimedOut, ex.NetworkError); }
public async Task Connection_EndpointsAreCorrect(EndPoint endPoint, SocketType socketType, ProtocolType protocolType) { endPoint = RecreateUdsEndpoint(endPoint); using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, endPoint, protocolType); using SocketsConnectionFactory factory = new SocketsConnectionFactory(endPoint.AddressFamily, socketType, protocolType); using Connection connection = await factory.ConnectAsync(server.EndPoint); // Checking for .ToString() result, because UnixDomainSocketEndPoint equality doesn't seem to be implemented Assert.Equal(server.EndPoint.ToString(), connection.RemoteEndPoint.ToString()); Assert.IsType(endPoint.GetType(), connection.LocalEndPoint); }
public async Task ConnectAsync_WhenCancelledBeforeInvocation_ThrowsTaskCancelledException() { using SocketsConnectionFactory factory = new SocketsConnectionFactory(SocketType.Stream, ProtocolType.Tcp); IPEndPoint doesNotExist = new IPEndPoint(IPAddress.Parse("1.2.3.4"), 23); CancellationToken cancellationToken = new CancellationToken(true); OperationCanceledException ex = await Assert.ThrowsAsync <OperationCanceledException>(() => factory.ConnectAsync(doesNotExist, cancellationToken : cancellationToken).AsTask()); Assert.Equal(cancellationToken, ex.CancellationToken); }
public async Task ConnectAsync_WhenHostNotFound_ThrowsNetworkException() { using SocketsConnectionFactory factory = new SocketsConnectionFactory(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // Unassigned as per https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.txt int unusedPort = 8; DnsEndPoint endPoint = new DnsEndPoint(System.Net.Test.Common.Configuration.Sockets.InvalidHost, unusedPort); NetworkException ex = await Assert.ThrowsAsync <NetworkException>(() => factory.ConnectAsync(endPoint).AsTask()); Assert.Equal(NetworkError.HostNotFound, ex.NetworkError); }
public async Task ConnectAsync_WhenRefused_ThrowsNetworkException() { using Socket notListening = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); int port = notListening.BindToAnonymousPort(IPAddress.Loopback); var endPoint = new IPEndPoint(IPAddress.Loopback, port); using SocketsConnectionFactory factory = new SocketsConnectionFactory(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); NetworkException ex = await Assert.ThrowsAsync <NetworkException>(() => factory.ConnectAsync(endPoint).AsTask()); Assert.Equal(NetworkError.ConnectionRefused, ex.NetworkError); }
public async Task Connection_Stream_FailingOperation_ThowsNetworkException() { using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.Loopback); using SocketsConnectionFactory factory = new SocketsConnectionFactory(SocketType.Stream, ProtocolType.Tcp); using Connection connection = await factory.ConnectAsync(server.EndPoint); connection.ConnectionProperties.TryGet(out Socket socket); Stream stream = connection.Stream; socket.Dispose(); Assert.Throws <NetworkException>(() => stream.Read(new byte[1], 0, 1)); Assert.Throws <NetworkException>(() => stream.Write(new byte[1], 0, 1)); }
public async Task Connection_Pipe_FailingOperation_ThowsNetworkException() { using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.Loopback); using SocketsConnectionFactory factory = new SocketsConnectionFactory(SocketType.Stream, ProtocolType.Tcp); using Connection connection = await factory.ConnectAsync(server.EndPoint); connection.ConnectionProperties.TryGet(out Socket socket); IDuplexPipe pipe = connection.Pipe; socket.Dispose(); await Assert.ThrowsAsync <NetworkException>(() => pipe.Input.ReadAsync().AsTask()); await Assert.ThrowsAsync <NetworkException>(() => pipe.Output.WriteAsync(new byte[1]).AsTask()); }
public async Task Connection_Pipe_ReadWrite_Success(EndPoint endPoint, SocketType socketType, ProtocolType protocolType) { endPoint = RecreateUdsEndpoint(endPoint); using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, endPoint, protocolType); using SocketsConnectionFactory factory = new SocketsConnectionFactory(endPoint.AddressFamily, socketType, protocolType); using Connection connection = await factory.ConnectAsync(server.EndPoint); IDuplexPipe pipe = connection.Pipe; byte[] sendData = { 1, 2, 3 }; using MemoryStream receiveTempStream = new MemoryStream(); await pipe.Output.WriteAsync(sendData); ReadResult rr = await pipe.Input.ReadAsync(); // The test server should echo the data: Assert.True(rr.Buffer.FirstSpan.SequenceEqual(sendData)); }
public async Task Connection_Stream_ReadWrite_Success(EndPoint endPoint, SocketType socketType, ProtocolType protocolType) { endPoint = RecreateUdsEndpoint(endPoint); using var server = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, endPoint, protocolType); using SocketsConnectionFactory factory = new SocketsConnectionFactory(endPoint.AddressFamily, socketType, protocolType); using Connection connection = await factory.ConnectAsync(server.EndPoint); Stream stream = connection.Stream; byte[] sendData = { 1, 2, 3 }; byte[] receiveData = new byte[sendData.Length]; await stream.WriteAsync(sendData); await stream.FlushAsync(); await stream.ReadAsync(receiveData); // The test server should echo the data: Assert.Equal(sendData, receiveData); }
public async Task Connection_Pipe_ReadWrite_Integration(int totalLines) { using SocketsConnectionFactory factory = new SocketsConnectionFactory(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); using SocketTestServer echoServer = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.Loopback); Socket serverSocket = null; echoServer.Accepted += s => serverSocket = s; using Connection connection = await factory.ConnectAsync(echoServer.EndPoint); IDuplexPipe pipe = connection.Pipe; ConcurrentQueue <string> linesSent = new ConcurrentQueue <string>(); Task writerTask = Task.Factory.StartNew(async() => { byte[] endl = Encoding.ASCII.GetBytes("\n"); StringBuilder expectedLine = new StringBuilder(); for (int i = 0; i < totalLines; i++) { int words = i % 10 + 1; for (int j = 0; j < words; j++) { string word = Guid.NewGuid() + " "; Encoding.ASCII.GetBytes(word, pipe.Output); expectedLine.Append(word); } linesSent.Enqueue(expectedLine.ToString()); await pipe.Output.WriteAsync(endl); expectedLine.Clear(); } await pipe.Output.FlushAsync(); // This will also trigger completion on the reader. TODO: Fix // await pipe.Output.CompleteAsync(); }, TaskCreationOptions.LongRunning); // The test server should echo the data sent to it PipeReader reader = pipe.Input; int lineIndex = 0; void ProcessLine(ReadOnlySequence <byte> lineBuffer) { string line = Encoding.ASCII.GetString(lineBuffer); Assert.True(linesSent.TryDequeue(out string expectedLine)); Assert.Equal(expectedLine, line); lineIndex++; // Received everything, shut down the server, so next read will complete: if (lineIndex == totalLines) { serverSocket.Shutdown(SocketShutdown.Both); } } while (true) { try { ReadResult result = await reader.ReadAsync(); ReadOnlySequence <byte> buffer = result.Buffer; SequencePosition? position = null; // Stop reading if there's no more data coming if (result.IsCompleted) { break; } do { // Look for a EOL in the buffer position = buffer.PositionOf((byte)'\n'); if (position != null) { // Process the line ProcessLine(buffer.Slice(0, position.Value)); // Skip the line + the \n character (basically position) buffer = buffer.Slice(buffer.GetPosition(1, position.Value)); } }while (position != null); // Tell the PipeReader how much of the buffer we have consumed reader.AdvanceTo(buffer.Start, buffer.End); } catch (SocketException) { // terminate } } // Mark the PipeReader as complete await reader.CompleteAsync(); await writerTask; // TODO: If this is done in the end of writerTask the socket stops working Assert.Equal(totalLines, lineIndex); }
public void ConnectAsync_NullEndpoint_ThrowsArgumentNullException() { using SocketsConnectionFactory factory = new SocketsConnectionFactory(SocketType.Stream, ProtocolType.Tcp); Assert.ThrowsAsync <ArgumentNullException>(() => factory.ConnectAsync(null).AsTask()); }