From c36edbe72254afb1264a0d6dbed2edcfe2a9fc4e Mon Sep 17 00:00:00 2001 From: Radek Zikmund Date: Tue, 12 Sep 2023 17:49:31 +0200 Subject: [PATCH] Fix compilation of unit tests. --- .../Managed/ManagedQuicConnection.cs | 4 +- .../tests/UnitTests/Frames/AckFrameTests.cs | 6 +- .../Frames/NewConnectionIdFrameTests.cs | 4 +- .../UnitTests/Frames/ResetStreamFrameTests.cs | 13 +- .../UnitTests/Frames/StopSendingFrameTests.cs | 13 +- .../tests/UnitTests/HandshakeTests.cs | 6 +- .../ManualTransmissionQuicTestBase.cs | 27 ++-- .../QuicImplementationProviders.Fake.cs | 15 --- .../tests/UnitTests/ReceiveStreamTest.cs | 6 +- .../tests/UnitTests/SendStreamTest.cs | 6 +- .../tests/UnitTests/StreamTests.cs | 119 +++++++++--------- .../UnitTests/Stubs/StubQuicConnection.cs | 5 + .../System.Net.Quic.Unit.Tests.csproj | 18 +-- .../tests/UnitTests/TestHelpers.cs | 21 +++- 14 files changed, 140 insertions(+), 123 deletions(-) delete mode 100644 src/libraries/System.Net.Quic/tests/UnitTests/QuicImplementationProviders.Fake.cs create mode 100644 src/libraries/System.Net.Quic/tests/UnitTests/Stubs/StubQuicConnection.cs diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Managed/ManagedQuicConnection.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Managed/ManagedQuicConnection.cs index 60dadcd2b403ea..0e13b026d0b334 100644 --- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Managed/ManagedQuicConnection.cs +++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Managed/ManagedQuicConnection.cs @@ -77,9 +77,9 @@ public static async ValueTask ConnectAsync(QuicClientConn /// If true, the connection is in closing or draining state and will be considered close at /// at the latest. /// - private bool IsClosing => _closingPeriodEndTimestamp != null; + internal bool IsClosing => _closingPeriodEndTimestamp != null; - private bool Connected => HandshakeConfirmed; + internal bool Connected => HandshakeConfirmed; /// /// Timestamp when the connection close will be initiated due to lack of packets from peer. diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/Frames/AckFrameTests.cs b/src/libraries/System.Net.Quic/tests/UnitTests/Frames/AckFrameTests.cs index e1ad1a1c28dcba..2ab6cb1a3e1b0e 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/Frames/AckFrameTests.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/Frames/AckFrameTests.cs @@ -38,7 +38,7 @@ public void ConnectionCloseWhenAckingFuturePacket() Send1Rtt(Server, Client) .ShouldHaveConnectionClose(TransportErrorCode.ProtocolViolation, - QuicError.InvalidAckRange, + QuicTransportError.InvalidAckRange, FrameType.Ack); } @@ -54,7 +54,7 @@ public void ConnectionCloseWhenAckingNegativePacket() Send1Rtt(Server, Client) .ShouldHaveConnectionClose(TransportErrorCode.ProtocolViolation, - QuicError.InvalidAckRange, + QuicTransportError.InvalidAckRange, FrameType.Ack); } @@ -91,7 +91,7 @@ public async Task TestAckNonContiguousRanges() // we enforce sending packets by writing one byte, coincidentally containing the value of expected packet // number for better testing - var clientStream = await Client.OpenUnidirectionalStreamAsync(); + var clientStream = await Client.OpenOutboundStreamAsync(QuicStreamType.Unidirectional); for (int i = 0; i <= last; i++) { diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/Frames/NewConnectionIdFrameTests.cs b/src/libraries/System.Net.Quic/tests/UnitTests/Frames/NewConnectionIdFrameTests.cs index 519f31cd1a87fc..3587609cca588d 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/Frames/NewConnectionIdFrameTests.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/Frames/NewConnectionIdFrameTests.cs @@ -53,7 +53,7 @@ public void ClosesConnectionWhenChangingSequenceNumber() // now we are in trouble Send1Rtt(Client, Server).ShouldHaveConnectionClose( TransportErrorCode.ProtocolViolation, - QuicError.InconsistentNewConnectionIdFrame, + QuicTransportError.InconsistentNewConnectionIdFrame, FrameType.NewConnectionId); } @@ -73,7 +73,7 @@ public void ClosesConnectionWhenChangingStatelessResetToken() // now we are in trouble Send1Rtt(Client, Server).ShouldHaveConnectionClose( TransportErrorCode.ProtocolViolation, - QuicError.InconsistentNewConnectionIdFrame, + QuicTransportError.InconsistentNewConnectionIdFrame, FrameType.NewConnectionId); } } diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/Frames/ResetStreamFrameTests.cs b/src/libraries/System.Net.Quic/tests/UnitTests/Frames/ResetStreamFrameTests.cs index f362899687bfea..33914d0e4a5809 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/Frames/ResetStreamFrameTests.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/Frames/ResetStreamFrameTests.cs @@ -31,13 +31,13 @@ public async Task CausesReadStreamOperationsToThrow() packet.Frames.Add(new ResetStreamFrame() { FinalSize = 0, - StreamId = stream.StreamId, + StreamId = stream.Id, ApplicationErrorCode = errorCode }); }); - var exception = Assert.Throws(() => stream.Read(Span.Empty)); - Assert.Equal(errorCode, exception.ErrorCode); + var exception = AssertThrowsQuicException(QuicError.StreamAborted, () => stream.Read(Span.Empty)); + Assert.Equal(errorCode, exception.ApplicationErrorCode); } private void CloseConnectionCommon(ResetStreamFrame frame, TransportErrorCode errorCode, string reason) @@ -59,7 +59,7 @@ public void ClosesConnection_WhenReceivedForNonReadableStream() StreamId = StreamHelpers.ComposeStreamId(StreamType.ClientInitiatedUnidirectional, 0), ApplicationErrorCode = 14 }, - TransportErrorCode.StreamStateError, QuicError.StreamNotReadable); + TransportErrorCode.StreamStateError, QuicTransportError.StreamNotReadable); } [Fact] @@ -67,10 +67,11 @@ public void ClosesConnection_WhenViolatingStreamLimit() { CloseConnectionCommon(new ResetStreamFrame() { - StreamId = StreamHelpers.ComposeStreamId(StreamType.ServerInitiatedUnidirectional, ListenerOptions.MaxBidirectionalStreams + 1), + // TODO: value of streamId based on listener options + StreamId = StreamHelpers.ComposeStreamId(StreamType.ServerInitiatedUnidirectional, int.MaxValue), ApplicationErrorCode = 14 }, - TransportErrorCode.StreamLimitError, QuicError.StreamsLimitViolated); + TransportErrorCode.StreamLimitError, QuicTransportError.StreamsLimitViolated); } [Fact] diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/Frames/StopSendingFrameTests.cs b/src/libraries/System.Net.Quic/tests/UnitTests/Frames/StopSendingFrameTests.cs index d89e8325d64ece..7a23ce1149c78e 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/Frames/StopSendingFrameTests.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/Frames/StopSendingFrameTests.cs @@ -31,7 +31,7 @@ public async Task ElicitsResetStream() var frame = Send1RttWithFrame(Server, Client); - Assert.Equal(stream.StreamId, frame.StreamId); + Assert.Equal(stream.Id, frame.StreamId); Assert.Equal(errorCode, frame.ApplicationErrorCode); Assert.Equal(0, frame.FinalSize); } @@ -54,10 +54,10 @@ public async Task ClosesConnection_WhenReceivedForNonWritableStream() CloseConnectionCommon(new StopSendingFrame() { - StreamId = stream.StreamId, + StreamId = stream.Id, ApplicationErrorCode = 14 }, - TransportErrorCode.StreamStateError, QuicError.StreamNotWritable); + TransportErrorCode.StreamStateError, QuicTransportError.StreamNotWritable); } [Fact] @@ -69,7 +69,7 @@ public void ClosesConnection_WhenReceivedForUncreatedLocallyInitiatedStream() StreamId = StreamHelpers.ComposeStreamId(StreamType.ServerInitiatedBidirectional, 0), ApplicationErrorCode = 14 }, - TransportErrorCode.StreamStateError, QuicError.StreamNotCreated); + TransportErrorCode.StreamStateError, QuicTransportError.StreamNotCreated); } [Fact] @@ -78,10 +78,11 @@ public void ClosesConnection_WhenViolatingStreamLimit() CloseConnectionCommon( new StopSendingFrame() { - StreamId = StreamHelpers.ComposeStreamId(StreamType.ClientInitiatedBidirectional, ListenerOptions.MaxBidirectionalStreams + 1), + // TODO: value of streamId based on listener options + StreamId = StreamHelpers.ComposeStreamId(StreamType.ClientInitiatedBidirectional, int.MaxValue), ApplicationErrorCode = 14 }, - TransportErrorCode.StreamLimitError, QuicError.StreamsLimitViolated); + TransportErrorCode.StreamLimitError, QuicTransportError.StreamsLimitViolated); } [Fact] diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/HandshakeTests.cs b/src/libraries/System.Net.Quic/tests/UnitTests/HandshakeTests.cs index 18e7ce004e050e..adbbddb5718185 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/HandshakeTests.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/HandshakeTests.cs @@ -39,7 +39,7 @@ public void SendsConnectionCloseOnSmallClientInitial() initial.ShouldHaveConnectionClose( TransportErrorCode.ProtocolViolation, - QuicError.InitialPacketTooShort); + QuicTransportError.InitialPacketTooShort); }); } @@ -184,7 +184,7 @@ public void SendsConnectionCloseWhenServerSendsToken() var packet = (CommonPacket)SendFlight(Client, Server).Packets[0]; packet.ShouldHaveConnectionClose( TransportErrorCode.ProtocolViolation, - QuicError.UnexpectedToken); + QuicTransportError.UnexpectedToken); } [Fact] @@ -198,7 +198,7 @@ public void SendsConnectionCloseWhenReservedBitsAreSet_LongHeader() InterceptInitial(Server, Client, initial => { initial.ShouldHaveConnectionClose(TransportErrorCode.ProtocolViolation, - QuicError.InvalidReservedBits); + QuicTransportError.InvalidReservedBits); }); } } diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/ManualTransmissionQuicTestBase.cs b/src/libraries/System.Net.Quic/tests/UnitTests/ManualTransmissionQuicTestBase.cs index 6564211d4ee6fe..3a9b5f9f3e2da3 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/ManualTransmissionQuicTestBase.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/ManualTransmissionQuicTestBase.cs @@ -13,6 +13,7 @@ using System.Net.Quic.Tests.Harness; using System.Net.Security; using System.Threading.Channels; +using System.Threading.Tasks; using Xunit; using Xunit.Abstractions; @@ -52,6 +53,7 @@ public class ManualTransmissionQuicTestBase private static readonly IPEndPoint _dummyListenEndpoint = new IPEndPoint(IPAddress.Any, 0); internal readonly QuicClientConnectionOptions ClientOptions; + internal readonly QuicServerConnectionOptions ServerOptions; internal readonly QuicListenerOptions ListenerOptions; internal readonly ManagedQuicConnection Client; @@ -75,11 +77,8 @@ public class ManualTransmissionQuicTestBase protected ManualTransmissionQuicTestBase(ITestOutputHelper output) { - ListenerOptions = new QuicListenerOptions + ServerOptions = new QuicServerConnectionOptions { - // TODO: - //CertificateFilePath = CertificateFilePath, - //PrivateKeyFilePath = PrivateKeyFilePath, ServerAuthenticationOptions = new SslServerAuthenticationOptions() { ApplicationProtocols = new List() @@ -87,9 +86,17 @@ protected ManualTransmissionQuicTestBase(ITestOutputHelper output) new SslApplicationProtocol("quictest") } }, + }; + ListenerOptions = new QuicListenerOptions + { + ApplicationProtocols = new List() + { + new SslApplicationProtocol("quictest") + }, + ConnectionOptionsCallback = delegate { return ValueTask.FromResult(ServerOptions); }, ListenEndPoint = new IPEndPoint(IPAddress.Loopback, 0) }; - Server = CreateServer(ListenerOptions); + Server = CreateServer(ServerOptions, ListenerOptions); ClientOptions = new QuicClientConnectionOptions() { @@ -124,10 +131,10 @@ private static ManagedQuicConnection CreateClient(QuicClientConnectionOptions op return new ManagedQuicConnection(options, MockTlsFactory.Instance); } - private static ManagedQuicConnection CreateServer(QuicListenerOptions options) + private static ManagedQuicConnection CreateServer(QuicServerConnectionOptions options, QuicListenerOptions listenerOptions) { var ctx = new QuicServerSocketContext(new IPEndPoint(IPAddress.Any, 0), - options, Channel.CreateUnbounded().Writer, MockTlsFactory.Instance); + listenerOptions, Channel.CreateUnbounded().Writer, MockTlsFactory.Instance); Span odcid = stackalloc byte[20]; return new ManagedQuicConnection(options, new QuicConnectionContext(ctx, _dummyListenEndpoint, odcid, MockTlsFactory.Instance), _dummyListenEndpoint, odcid, MockTlsFactory.Instance); } @@ -465,5 +472,11 @@ internal void LogFlightPackets(PacketBase packet, ManagedQuicConnection sender, { LogFlightPackets(new []{packet}, sender, lost); } + + internal QuicException AssertThrowsQuicException(QuicError expectedError, Action action) => + AssertHelpers.ThrowsQuicException(expectedError, action); + + internal Task AssertThrowsQuicExceptionAsync(QuicError expectedError, Func action) => + AssertHelpers.ThrowsQuicExceptionAsync(expectedError, action); } } diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/QuicImplementationProviders.Fake.cs b/src/libraries/System.Net.Quic/tests/UnitTests/QuicImplementationProviders.Fake.cs deleted file mode 100644 index 907a01df4515c7..00000000000000 --- a/src/libraries/System.Net.Quic/tests/UnitTests/QuicImplementationProviders.Fake.cs +++ /dev/null @@ -1,15 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Net.Quic.Implementations.Managed.Internal.Tls.OpenSsl; -using System.Net.Quic.Implementations.Managed.Internal.Tls; - -namespace System.Net.Quic -{ - public static class QuicImplementationProviders - { - public static Implementations.QuicImplementationProvider Managed { get; } = new Implementations.Managed.ManagedQuicImplementationProvider(OpenSslTlsFactory.Instance); - public static Implementations.QuicImplementationProvider ManagedMockTls { get; } = new Implementations.Managed.ManagedQuicImplementationProvider(MockTlsFactory.Instance); - public static Implementations.QuicImplementationProvider Default => ManagedMockTls; - } -} diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/ReceiveStreamTest.cs b/src/libraries/System.Net.Quic/tests/UnitTests/ReceiveStreamTest.cs index c4d058df56f22f..90f0d56a8ae4fe 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/ReceiveStreamTest.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/ReceiveStreamTest.cs @@ -156,13 +156,13 @@ public async Task RequestingAbortAbortsReaders() { var destination = new byte[100]; - var exnTask = Assert.ThrowsAsync( + var exnTask = AssertHelpers.ThrowsQuicExceptionAsync(QuicError.StreamAborted, () => stream.DeliverAsync(destination, CancellationToken.None).AsTask()); - stream.RequestAbort(10000); + stream.OnResetStream(10000); var exn = await exnTask.WaitAsync(TimeSpan.FromMilliseconds(5_000)); - Assert.Equal(10000, exn.ErrorCode); + Assert.Equal(10000, exn.ApplicationErrorCode); } } } diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/SendStreamTest.cs b/src/libraries/System.Net.Quic/tests/UnitTests/SendStreamTest.cs index c4482caa58e9bd..811bf9310965e8 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/SendStreamTest.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/SendStreamTest.cs @@ -144,7 +144,7 @@ public async Task RequestingAbortAbortsWriters() { var destination = new byte[100]; - var exnTask = Assert.ThrowsAsync( + var exnTask = AssertHelpers.ThrowsQuicExceptionAsync(QuicError.StreamAborted, async () => { while (true) @@ -154,10 +154,10 @@ public async Task RequestingAbortAbortsWriters() } }); - stream.RequestAbort(10000); + stream.RequestAbort(10000, false); var exn = await exnTask.WaitAsync(TimeSpan.FromMilliseconds(5_000)); - Assert.Equal(10000, exn.ErrorCode); + Assert.Equal(10000, exn.ApplicationErrorCode); } } } diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/StreamTests.cs b/src/libraries/System.Net.Quic/tests/UnitTests/StreamTests.cs index 393e35de4792de..3ae83cf183c389 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/StreamTests.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/StreamTests.cs @@ -42,7 +42,7 @@ public async Task SimpleStreamOpen(bool unidirectional) Intercept1RttFrame(Client, Server, frame => { - Assert.Equal(clientStream.StreamId, frame.StreamId); + Assert.Equal(clientStream.Id, frame.StreamId); Assert.Equal(0u, frame.Offset); Assert.Equal(data, frame.StreamData); Assert.False(frame.Fin); @@ -50,7 +50,7 @@ public async Task SimpleStreamOpen(bool unidirectional) var serverStream = Server.AcceptStream(); Assert.NotNull(serverStream); - Assert.Equal(clientStream.StreamId, serverStream!.StreamId); + Assert.Equal(clientStream.Id, serverStream!.Id); Assert.True(serverStream.CanRead); Assert.Equal(!unidirectional, serverStream.CanWrite); @@ -67,7 +67,7 @@ public async Task SendsFinWithLastFrame() var clientStream = await Client.OpenStream(true); clientStream.Write(data); clientStream.Flush(); - clientStream.Shutdown(); + clientStream.CompleteWrites(); Intercept1RttFrame(Client, Server, frame => { @@ -91,7 +91,7 @@ public async Task SendsEmptyStreamFrameWithFin() }); // no more data to send, just the fin bit - clientStream.Shutdown(); + clientStream.CompleteWrites(); Intercept1RttFrame(Client, Server, frame => { Assert.Empty(frame.StreamData); @@ -115,12 +115,12 @@ public async Task ClosesConnectionWhenStreamLimitIsExceeded() Intercept1RttFrame(Client, Server, frame => { // make sure the stream id is above bounds - frame.StreamId += ListenerOptions.MaxUnidirectionalStreams << 2 + 4; + frame.StreamId += ServerOptions.MaxInboundUnidirectionalStreams << 2 + 4; }); Send1Rtt(Server, Client).ShouldHaveConnectionClose( TransportErrorCode.StreamLimitError, - QuicError.StreamsLimitViolated, + QuicTransportError.StreamsLimitViolated, FrameType.Stream | FrameType.StreamLenBit); } @@ -136,7 +136,7 @@ public async Task ClosesConnectionWhenSendingPastMaxRepresentableOffset() Send1Rtt(Server, Client).ShouldHaveConnectionClose( TransportErrorCode.FrameEncodingError, - QuicError.UnableToDeserialize, + QuicTransportError.UnableToDeserialize, FrameType.Stream | FrameType.StreamLenBit | FrameType.StreamOffBit); } @@ -152,7 +152,7 @@ public async Task ClosesConnectionWhenSendingPastFin() Send1Rtt(Server, Client).ShouldHaveConnectionClose( TransportErrorCode.FrameEncodingError, - QuicError.UnableToDeserialize, + QuicTransportError.UnableToDeserialize, FrameType.Stream | FrameType.StreamLenBit | FrameType.StreamOffBit); } @@ -171,7 +171,7 @@ public async Task ClosesConnectionWhenSendingInNonReadableStream() Send1Rtt(Server, Client).ShouldHaveConnectionClose( TransportErrorCode.StreamStateError, - QuicError.StreamNotWritable, + QuicTransportError.StreamNotWritable, FrameType.Stream | FrameType.StreamLenBit); } @@ -187,7 +187,7 @@ public async Task ClosesConnectionWhenSendingPastStreamMaxData() Send1Rtt(Server, Client).ShouldHaveConnectionClose( TransportErrorCode.FlowControlError, - QuicError.StreamMaxDataViolated, + QuicTransportError.StreamMaxDataViolated, FrameType.Stream | FrameType.StreamLenBit | FrameType.StreamOffBit); } @@ -203,7 +203,7 @@ public async Task ClosesConnectionWhenSendingPastConnectionMaxData() Send1Rtt(Server, Client).ShouldHaveConnectionClose( TransportErrorCode.FlowControlError, - QuicError.MaxDataViolated, + QuicTransportError.MaxDataViolated, FrameType.Stream | FrameType.StreamLenBit | FrameType.StreamOffBit); } @@ -256,60 +256,61 @@ public async Task ClosesConnectionOnInvalidStreamId_StreamMaxDataFrame() // make sure the id above the client-specified limit packet.Frames.Add(new MaxStreamDataFrame() { - StreamId = ClientOptions.MaxUnidirectionalStreams * 4 + 1, + StreamId = ClientOptions.MaxInboundUnidirectionalStreams * 4 + 1, }); }); Send1Rtt(Client, Server) .ShouldHaveConnectionClose(TransportErrorCode.StreamLimitError, - QuicError.StreamsLimitViolated, FrameType.MaxStreamData); + QuicTransportError.StreamsLimitViolated, FrameType.MaxStreamData); } - [Fact] - public async Task ShutdownCompleted_Cancelled() - { - var stream = await Client.OpenStream(true); - var cts = new CancellationTokenSource(); - var testTask = Assert.ThrowsAsync( - () => stream.ShutdownCompleted(cts.Token).AsTask()); - - // signal the cancellation - cts.Cancel(); - - await testTask; - } - - [Fact] - public async Task ShutdownCompleted_CompletedOnConnectionClose() - { - var stream = await Client.OpenStream(true); - var shutdownWriteCompletedTask = stream.ShutdownCompleted(); - - // receiving connection close implicitly closes all streams - Server.Ping(); - Intercept1Rtt(Server, Client, packet => - { - packet.Frames.Add(new ConnectionCloseFrame() - { - ErrorCode = TransportErrorCode.InternalError, - ReasonPhrase = "Test Error", - }); - }); - - await shutdownWriteCompletedTask.AsTask().WaitAsync(TimeSpan.FromMilliseconds(500)); - } - - [Fact] - public async Task ShutdownCompleted_ExceptionWhenWriteAborted() - { - var stream = await Client.OpenStream(true); - var testTask = - Assert.ThrowsAsync(async () => await stream.ShutdownCompleted()); - - stream.AbortWrite(0); - - await testTask; - } + // TODO: reflect API changes + // [Fact] + // public async Task ShutdownCompleted_Cancelled() + // { + // var stream = await Client.OpenStream(true); + // var cts = new CancellationTokenSource(); + // var testTask = Assert.ThrowsAsync( + // () => stream.ShutdownCompleted(cts.Token).AsTask()); + + // // signal the cancellation + // cts.Cancel(); + + // await testTask; + // } + + // [Fact] + // public async Task ShutdownCompleted_CompletedOnConnectionClose() + // { + // var stream = await Client.OpenStream(true); + // var shutdownWriteCompletedTask = stream.ShutdownCompleted(); + + // // receiving connection close implicitly closes all streams + // Server.Ping(); + // Intercept1Rtt(Server, Client, packet => + // { + // packet.Frames.Add(new ConnectionCloseFrame() + // { + // ErrorCode = TransportErrorCode.InternalError, + // ReasonPhrase = "Test Error", + // }); + // }); + + // await shutdownWriteCompletedTask.AsTask().WaitAsync(TimeSpan.FromMilliseconds(500)); + // } + + // [Fact] + // public async Task ShutdownCompleted_ExceptionWhenWriteAborted() + // { + // var stream = await Client.OpenStream(true); + // var testTask = + // Assert.ThrowsAsync(async () => await stream.ShutdownCompleted()); + + // stream.AbortWrite(0); + + // await testTask; + // } [Fact] public async Task AbortRead_ShouldElicitStopSendingFrame() @@ -319,7 +320,7 @@ public async Task AbortRead_ShouldElicitStopSendingFrame() stream.AbortRead(errorCode); var frame = Send1RttWithFrame(Client, Server); - Assert.Equal(stream.StreamId, frame.StreamId); + Assert.Equal(stream.Id, frame.StreamId); Assert.Equal(errorCode, frame.ApplicationErrorCode); } } diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/Stubs/StubQuicConnection.cs b/src/libraries/System.Net.Quic/tests/UnitTests/Stubs/StubQuicConnection.cs new file mode 100644 index 00000000000000..18b37d14dc6cf3 --- /dev/null +++ b/src/libraries/System.Net.Quic/tests/UnitTests/Stubs/StubQuicConnection.cs @@ -0,0 +1,5 @@ +namespace System.Net.Quic; + +public class QuicConnection +{ +} \ No newline at end of file diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/System.Net.Quic.Unit.Tests.csproj b/src/libraries/System.Net.Quic/tests/UnitTests/System.Net.Quic.Unit.Tests.csproj index 7141239714b327..5912254c52d2e2 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/System.Net.Quic.Unit.Tests.csproj +++ b/src/libraries/System.Net.Quic/tests/UnitTests/System.Net.Quic.Unit.Tests.csproj @@ -14,24 +14,18 @@ - - + + - + + + - - - - - - - - - + diff --git a/src/libraries/System.Net.Quic/tests/UnitTests/TestHelpers.cs b/src/libraries/System.Net.Quic/tests/UnitTests/TestHelpers.cs index a167192a201487..a779502c97df9c 100644 --- a/src/libraries/System.Net.Quic/tests/UnitTests/TestHelpers.cs +++ b/src/libraries/System.Net.Quic/tests/UnitTests/TestHelpers.cs @@ -1,12 +1,11 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -#nullable enable - using System.Linq; using System.Net.Quic.Implementations.Managed.Internal; using System.Net.Quic.Implementations.Managed.Internal.Frames; using System.Net.Quic.Tests.Harness; +using System.Threading.Tasks; using Xunit; using ConnectionCloseFrame = System.Net.Quic.Tests.Harness.ConnectionCloseFrame; @@ -38,5 +37,23 @@ public static void ShouldHaveConnectionClose(this IFramePacket packet, Transport // if (frameType != FrameType.Padding) Assert.Equal(frameType, frame.ErrorFrameType); } + + } + + internal static class AssertHelpers + { + internal static async Task ThrowsQuicExceptionAsync(QuicError expectedError, Func action) + { + var ex = await Assert.ThrowsAsync(action); + Assert.Equal(expectedError, ex.QuicError); + return ex; + } + + internal static QuicException ThrowsQuicException(QuicError expectedError, Action action) + { + var ex = Assert.Throws(action); + Assert.Equal(expectedError, ex.QuicError); + return ex; + } } }