public abstract class LoopbackServerFactory
{
- public abstract Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync);
+ public abstract Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync, int millisecondsTimeout = 30_000);
public abstract bool IsHttp11 { get; }
public abstract bool IsHttp2 { get; }
// Common helper methods
- public Task CreateClientAndServerAsync(Func<Uri, Task> clientFunc, Func<GenericLoopbackServer, Task> serverFunc)
+ public Task CreateClientAndServerAsync(Func<Uri, Task> clientFunc, Func<GenericLoopbackServer, Task> serverFunc, int millisecondsTimeout = 30_000)
{
return CreateServerAsync(async (server, uri) =>
{
Task serverTask = serverFunc(server);
await new Task[] { clientTask, serverTask }.WhenAllOrAnyFailed();
- });
+ }).TimeoutAfter(millisecondsTimeout);
}
}
{
public static readonly Http2LoopbackServerFactory Singleton = new Http2LoopbackServerFactory();
- public override async Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync)
+ public override async Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync, int millisecondsTimeout = 30_000)
{
using (var server = Http2LoopbackServer.CreateServer())
{
- await funcAsync(server, server.Address);
+ await funcAsync(server, server.Address).TimeoutAfter(millisecondsTimeout);
}
}
{
public static readonly Http11LoopbackServerFactory Singleton = new Http11LoopbackServerFactory();
- public override Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync)
+ public override Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync, int millisecondsTimeout = 30_000)
{
return LoopbackServer.CreateServerAsync((server, uri) => funcAsync(server, uri));
}
private static Uri s_authenticatedServer = DomainJoinedTestsEnabled ?
new Uri($"http://{Configuration.Http.DomainJoinedHttpHost}/test/auth/negotiate/showidentity.ashx") : null;
- private readonly ITestOutputHelper _output;
-
- public DefaultCredentialsTest(ITestOutputHelper output)
- {
- _output = output;
- }
+ public DefaultCredentialsTest(ITestOutputHelper output) : base(output) { }
[OuterLoop("Uses external server")]
[ConditionalTheory(nameof(ServerAuthenticationTestsEnabled))]
using System.Threading.Tasks;
using Microsoft.DotNet.RemoteExecutor;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
[SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "NetEventSource is only part of .NET Core.")]
public abstract class DiagnosticsTest : HttpClientHandlerTestBase
{
+ public DiagnosticsTest(ITestOutputHelper output) : base(output) { }
+
[Fact]
public static void EventSource_ExistsWithCorrectId()
{
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
public abstract class HttpClient_SelectedSites_Test : HttpClientHandlerTestBase
{
+ public HttpClient_SelectedSites_Test(ITestOutputHelper output) : base(output) { }
+
public static bool IsSelectedSitesTestEnabled()
{
string envVar = Environment.GetEnvironmentVariable("CORFX_NET_HTTP_SELECTED_SITES");
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
private VerboseTestLogging _log = VerboseTestLogging.GetInstance();
+ public HttpClientEKUTest(ITestOutputHelper output) : base(output) { }
+
[ConditionalFact(nameof(CanTestCertificates))]
public async Task HttpClient_NoEKUServerAuth_Ok()
{
using System.Security.Authentication;
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
{
private static bool ClientSupportsDHECipherSuites => (!PlatformDetection.IsWindows || PlatformDetection.IsWindows10Version1607OrGreater);
+ public HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
public void SingletonReturnsTrue()
{
using System.Threading.Tasks;
using System.Threading.Tests;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
public abstract class HttpClientHandler_Asynchrony_Test : HttpClientHandlerTestBase
{
+ public HttpClientHandler_Asynchrony_Test(ITestOutputHelper output) : base(output) { }
+
public static IEnumerable<object[]> ResponseHeadersRead_SynchronizationContextNotUsedByHandler_MemberData() =>
from responseHeadersRead in new[] { false, true }
from contentMode in Enum.GetValues(typeof(LoopbackServer.ContentMode)).Cast<LoopbackServer.ContentMode>()
[SkipOnTargetFramework(TargetFrameworkMonikers.Uap, "Tests would need to be rewritten due to behavior differences with WinRT")]
public abstract class HttpClientHandler_Authentication_Test : HttpClientHandlerTestBase
{
- private readonly ITestOutputHelper _output;
-
private const string Username = "testusername";
private const string Password = "testpassword";
private const string Domain = "testdomain";
}
};
- public HttpClientHandler_Authentication_Test(ITestOutputHelper output)
- {
- _output = output;
- }
+ public HttpClientHandler_Authentication_Test(ITestOutputHelper output) : base(output) { }
[Theory]
[MemberData(nameof(Authentication_TestData))]
public abstract class HttpClientHandlerTest_AutoRedirect : HttpClientHandlerTestBase
{
- readonly ITestOutputHelper _output;
private const string ExpectedContent = "Test content";
private const string Username = "testuser";
private const string Password = "password";
new object[] { 308, "HEAD", "HEAD" },
};
- public HttpClientHandlerTest_AutoRedirect(ITestOutputHelper output)
- {
- _output = output;
- }
+ public HttpClientHandlerTest_AutoRedirect(ITestOutputHelper output) : base(output) { }
[OuterLoop("Uses external server")]
[Theory, MemberData(nameof(RedirectStatusCodes))]
using System.Threading;
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
public abstract class HttpClientHandler_Cancellation_Test : HttpClientHandlerTestBase
{
+ public HttpClientHandler_Cancellation_Test(ITestOutputHelper output) : base(output) { }
+
[Theory]
[InlineData(false, CancellationMode.Token)]
[InlineData(true, CancellationMode.Token)]
public bool CanTestClientCertificates =>
CanTestCertificates && BackendSupportsCustomCertificateHandling;
- public HttpClientHandler_ClientCertificates_Test(ITestOutputHelper output)
- {
- _output = output;
- }
+ public HttpClientHandler_ClientCertificates_Test(ITestOutputHelper output) : base(output) { }
- private readonly ITestOutputHelper _output;
[Fact]
public void ClientCertificateOptions_Default()
{
using System.Threading.Tasks;
using Microsoft.DotNet.XUnitExtensions;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
private const string s_simpleContent = "Hello world!";
+ public HttpClientHandlerTest_Cookies(ITestOutputHelper output) : base(output) { }
+
//
// Send cookie tests
//
public abstract class HttpClientHandlerTest_Cookies_Http11 : HttpClientHandlerTestBase
{
+ public HttpClientHandlerTest_Cookies_Http11(ITestOutputHelper output) : base(output) { }
+
[Fact]
public async Task GetAsync_ReceiveMultipleSetCookieHeaders_CookieAdded()
{
{
public abstract class HttpClientHandler_Decompression_Test : HttpClientHandlerTestBase
{
- private readonly ITestOutputHelper _output;
-
public static readonly object[][] CompressedServers = System.Net.Test.Common.Configuration.Http.CompressedServers;
- public HttpClientHandler_Decompression_Test(ITestOutputHelper output)
- {
- _output = output;
- }
+ public HttpClientHandler_Decompression_Test(ITestOutputHelper output) : base(output) { }
public static IEnumerable<object[]> DecompressedResponse_MethodSpecified_DecompressedContentReturned_MemberData()
{
using System.Threading.Tasks;
using Microsoft.DotNet.RemoteExecutor;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
public abstract class HttpClientHandler_DefaultProxyCredentials_Test : HttpClientHandlerTestBase
{
+ public HttpClientHandler_DefaultProxyCredentials_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
public void Default_Get_Null()
{
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Test.Common;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Xunit;
+using Xunit.Abstractions;
+
+namespace System.Net.Http.Functional.Tests
+{
+ using Configuration = System.Net.Test.Common.Configuration;
+
+ public abstract class HttpClientHandlerTest_Headers : HttpClientHandlerTestBase
+ {
+ public HttpClientHandlerTest_Headers(ITestOutputHelper output) : base(output) { }
+
+ [Fact]
+ public async Task SendAsync_UserAgent_CorrectlyWritten()
+ {
+ string userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.18 Safari/537.36";
+
+ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
+ {
+ using (var client = CreateHttpClient())
+ {
+ var message = new HttpRequestMessage(HttpMethod.Get, uri);
+ message.Headers.TryAddWithoutValidation("User-Agent", userAgent);
+ (await client.SendAsync(message).ConfigureAwait(false)).Dispose();
+ }
+ },
+ async server =>
+ {
+ HttpRequestData requestData = await server.HandleRequestAsync(HttpStatusCode.OK);
+
+ string agent = requestData.GetSingleHeaderValue("User-Agent");
+ Assert.Equal(userAgent, agent);
+ });
+ }
+
+ [Fact]
+ public async Task SendAsync_SpecialCharacterHeader_Success()
+ {
+ string headerValue = "header name with underscore";
+ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
+ {
+ using (var client = CreateHttpClient())
+ {
+ var message = new HttpRequestMessage(HttpMethod.Get, uri);
+ message.Headers.TryAddWithoutValidation("x-Special_name", "header name with underscore");
+ (await client.SendAsync(message).ConfigureAwait(false)).Dispose();
+ }
+ },
+ async server =>
+ {
+ HttpRequestData requestData = await server.HandleRequestAsync(HttpStatusCode.OK);
+
+ string header = requestData.GetSingleHeaderValue("x-Special_name");
+ Assert.Equal(header, headerValue);
+ });
+ }
+
+ [OuterLoop("Uses external server")]
+ [Theory]
+ [InlineData(false)]
+ [InlineData(true)]
+ public async Task SendAsync_GetWithValidHostHeader_Success(bool withPort)
+ {
+ var m = new HttpRequestMessage(HttpMethod.Get, Configuration.Http.SecureRemoteEchoServer);
+ m.Headers.Host = withPort ? Configuration.Http.SecureHost + ":443" : Configuration.Http.SecureHost;
+
+ using (HttpClient client = CreateHttpClient())
+ using (HttpResponseMessage response = await client.SendAsync(m))
+ {
+ string responseContent = await response.Content.ReadAsStringAsync();
+ _output.WriteLine(responseContent);
+ TestHelper.VerifyResponseBody(
+ responseContent,
+ response.Content.Headers.ContentMD5,
+ false,
+ null);
+ }
+ }
+
+ [OuterLoop("Uses external server")]
+ [Fact]
+ public async Task SendAsync_GetWithInvalidHostHeader_ThrowsException()
+ {
+ if (PlatformDetection.IsNetCore && (!UseSocketsHttpHandler || LoopbackServerFactory.IsHttp2))
+ {
+ // Only .NET Framework and SocketsHttpHandler with HTTP/1.x use the Host header to influence the SSL auth.
+ // Host header is not used for HTTP2
+ return;
+ }
+
+ var m = new HttpRequestMessage(HttpMethod.Get, Configuration.Http.SecureRemoteEchoServer);
+ m.Headers.Host = "hostheaderthatdoesnotmatch";
+
+ using (HttpClient client = CreateHttpClient())
+ {
+ await Assert.ThrowsAsync<HttpRequestException>(() => client.SendAsync(m));
+ }
+ }
+ }
+}
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
public static bool SupportsAlpn => PlatformDetection.SupportsAlpn;
+ public HttpClientHandlerTest_Http2(ITestOutputHelper output) : base(output) { }
+
[ConditionalFact(nameof(SupportsAlpn))]
public async Task Http2_ClientPreface_Sent()
{
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
[SkipOnTargetFramework(TargetFrameworkMonikers.Uap, "UAP connection management behavior is different due to WinRT")]
public abstract class HttpClientHandler_MaxConnectionsPerServer_Test : HttpClientHandlerTestBase
{
+ public HttpClientHandler_MaxConnectionsPerServer_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
[SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "MaxConnectionsPerServer either returns two or int.MaxValue depending if ctor of HttpClientHandlerTest executed first. Disabling cause of random xunit execution order.")]
public void Default_ExpectedValue()
using System.Threading;
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
public abstract class HttpClientHandler_MaxResponseHeadersLength_Test : HttpClientHandlerTestBase
{
+ public HttpClientHandler_MaxResponseHeadersLength_Test(ITestOutputHelper output) : base(output) { }
+
[SkipOnTargetFramework(TargetFrameworkMonikers.Uap, "Not currently supported on UAP")]
[Theory]
[InlineData(0)]
[SkipOnTargetFramework(TargetFrameworkMonikers.Uap, "UAP HTTP stack doesn't support .Proxy property")]
public abstract class HttpClientHandler_Proxy_Test : HttpClientHandlerTestBase
{
- private readonly ITestOutputHelper _output;
-
- public HttpClientHandler_Proxy_Test(ITestOutputHelper output)
- {
- _output = output;
- }
+ public HttpClientHandler_Proxy_Test(ITestOutputHelper output) : base(output) { }
[ActiveIssue(32809)]
[OuterLoop("Uses external server")]
using System.Threading;
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
public abstract class HttpClientHandler_ResponseDrain_Test : HttpClientHandlerTestBase
{
+ public HttpClientHandler_ResponseDrain_Test(ITestOutputHelper output) : base(output) { }
+
protected virtual void SetResponseDrainTimeout(HttpClientHandler handler, TimeSpan time) { }
[OuterLoop]
using System.Threading.Tasks;
using Microsoft.DotNet.RemoteExecutor;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
private bool BackendSupportsCustomCertificateHandlingAndClientSupportsDHECipherSuites =>
(BackendSupportsCustomCertificateHandling && ClientSupportsDHECipherSuites);
+ public HttpClientHandler_ServerCertificates_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
[SkipOnTargetFramework(~TargetFrameworkMonikers.Uap)]
public void Ctor_ExpectedDefaultPropertyValues_UapPlatform()
using System.Threading.Tasks;
using Microsoft.DotNet.XUnitExtensions;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
[SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "SslProtocols property requires .NET 4.7.2")]
public abstract partial class HttpClientHandler_SslProtocols_Test : HttpClientHandlerTestBase
{
+ public HttpClientHandler_SslProtocols_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
public void DefaultProtocols_MatchesExpected()
{
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
private static Frame MakeDataFrame(int streamId, byte[] data, bool endStream = false) =>
new DataFrame(data, (endStream ? FrameFlags.EndStream : FrameFlags.None), 0, streamId);
+ public HttpClientHandlerTest_TrailingHeaders_Test (ITestOutputHelper output) : base(output) { }
+
[Theory]
[InlineData(false)]
[InlineData(true)]
// to separately Dispose (or have a 'using' statement) for the handler.
public abstract class HttpClientHandlerTest : HttpClientHandlerTestBase
{
- readonly ITestOutputHelper _output;
private const string ExpectedContent = "Test content";
private const string Username = "testuser";
private const string Password = "password";
}
}
- public HttpClientHandlerTest(ITestOutputHelper output)
+ public HttpClientHandlerTest(ITestOutputHelper output) : base(output)
{
- _output = output;
if (PlatformDetection.IsFullFramework)
{
- // On .NET Framework, the default limit for connections/server is very low (2).
+ // On .NET Framework, the default limit for connections/server is very low (2).
// On .NET Core, the default limit is higher. Since these tests run in parallel,
// the limit needs to be increased to avoid timeouts when running the tests.
System.Net.ServicePointManager.DefaultConnectionLimit = int.MaxValue;
}
}
- [OuterLoop("Uses external server")]
- [Theory]
- [InlineData(false)]
- [InlineData(true)]
- public async Task SendAsync_GetWithValidHostHeader_Success(bool withPort)
- {
- var m = new HttpRequestMessage(HttpMethod.Get, Configuration.Http.SecureRemoteEchoServer);
- m.Headers.Host = withPort ? Configuration.Http.SecureHost + ":123" : Configuration.Http.SecureHost;
-
- using (HttpClient client = CreateHttpClient())
- using (HttpResponseMessage response = await client.SendAsync(m))
- {
- string responseContent = await response.Content.ReadAsStringAsync();
- _output.WriteLine(responseContent);
- TestHelper.VerifyResponseBody(
- responseContent,
- response.Content.Headers.ContentMD5,
- false,
- null);
- }
- }
-
- [OuterLoop("Uses external server")]
- [Fact]
- public async Task SendAsync_GetWithInvalidHostHeader_ThrowsException()
- {
- if (PlatformDetection.IsNetCore && (!UseSocketsHttpHandler || LoopbackServerFactory.IsHttp2))
- {
- // Only .NET Framework and SocketsHttpHandler with HTTP/1.x use the Host header to influence the SSL auth.
- // Host header is not used for HTTP2
- return;
- }
-
- var m = new HttpRequestMessage(HttpMethod.Get, Configuration.Http.SecureRemoteEchoServer);
- m.Headers.Host = "hostheaderthatdoesnotmatch";
-
- using (HttpClient client = CreateHttpClient())
- {
- await Assert.ThrowsAsync<HttpRequestException>(() => client.SendAsync(m));
- }
- }
-
[ActiveIssue(22158, TargetFrameworkMonikers.Uap)]
[Fact]
public async Task GetAsync_IPv6LinkLocalAddressUri_Success()
}
#endregion
- [Fact]
- public async Task SendAsync_UserAgent_CorrectlyWritten()
- {
- string userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.18 Safari/537.36";
-
- await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
- {
- using (var client = CreateHttpClient())
- {
- var message = new HttpRequestMessage(HttpMethod.Get, uri);
- message.Headers.TryAddWithoutValidation("User-Agent", userAgent);
- (await client.SendAsync(message).ConfigureAwait(false)).Dispose();
- }
- },
- async server =>
- {
- HttpRequestData requestData = await server.HandleRequestAsync(HttpStatusCode.OK);
-
- string agent = requestData.GetSingleHeaderValue("User-Agent");
- Assert.Equal(userAgent, agent);
- });
- }
-
[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindowsSubsystemForLinux))] // [ActiveIssue(11057)]
public async Task GetAsync_InvalidUrl_ExpectedExceptionThrown()
{
using System.Reflection;
using System.Net.Test.Common;
+using Xunit.Abstractions;
+
namespace System.Net.Http.Functional.Tests
{
public abstract class HttpClientHandlerTestBase : FileCleanupTestBase
{
+ public readonly ITestOutputHelper _output;
+
protected virtual bool UseSocketsHttpHandler => true;
protected virtual bool UseHttp2LoopbackServer => false;
protected bool IsNetfxHandler => PlatformDetection.IsWindows && PlatformDetection.IsFullFramework;
protected bool IsUapHandler => PlatformDetection.IsWindows && PlatformDetection.IsUap;
+ public HttpClientHandlerTestBase(ITestOutputHelper output)
+ {
+ _output = output;
+ }
+
protected HttpClient CreateHttpClient() => new HttpClient(CreateHttpClientHandler());
protected HttpClientHandler CreateHttpClientHandler() => CreateHttpClientHandler(UseSocketsHttpHandler, UseHttp2LoopbackServer);
using System.Threading;
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
public abstract class HttpClientMiniStress : HttpClientHandlerTestBase
{
+ public HttpClientMiniStress(ITestOutputHelper output) : base(output) { }
+
[ConditionalTheory(typeof(TestEnvironment), nameof(TestEnvironment.IsStressModeEnabled))]
[MemberData(nameof(GetStressOptions))]
public void SingleClient_ManyGets_Sync(int numRequests, int dop, HttpCompletionOption completionOption)
using System.Threading;
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
protected virtual Stream GetStream(Stream s) => s;
protected virtual Stream GetStream_ClientDisconnectOk(Stream s) => s;
+ public HttpProtocolTests(ITestOutputHelper output) : base(output) { }
+
[SkipOnTargetFramework(TargetFrameworkMonikers.Uap, "Uap does not support 1.0")]
[Fact]
public async Task GetAsync_RequestVersion10_Success()
public abstract class HttpProtocolTests_Dribble : HttpProtocolTests
{
+ public HttpProtocolTests_Dribble(ITestOutputHelper output) : base(output) { }
+
protected override Stream GetStream(Stream s) => new DribbleStream(s);
protected override Stream GetStream_ClientDisconnectOk(Stream s) => new DribbleStream(s, true);
}
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
{
Version _expectedRequestMessageVersion = !PlatformDetection.IsFullFramework ? new Version(2,0) : new Version(1, 1);
+ public HttpRequestMessageTest(ITestOutputHelper output) : base(output) { }
+
[Fact]
public void Ctor_Default_CorrectDefaults()
{
using System.Text;
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
// Retry logic is supported by SocketsHttpHandler, CurlHandler, uap, and netfx. Only WinHttp does not support.
private bool IsRetrySupported => !IsWinHttpHandler;
+ public HttpRetryProtocolTests(ITestOutputHelper output) : base(output) { }
+
[Fact]
[ActiveIssue(26770, TargetFrameworkMonikers.NetFramework)]
public async Task GetAsync_RetryOnConnectionClosed_Success()
using System.Net.Test.Common;
using System.Threading.Tasks;
using Xunit;
+using Xunit.Abstractions;
namespace System.Net.Http.Functional.Tests
{
{
protected abstract bool SupportsIdna { get; }
+ public IdnaProtocolTests(ITestOutputHelper output) : base(output) { }
+
[SkipOnTargetFramework(TargetFrameworkMonikers.Uap, "UAP does not support custom proxies.")]
[Theory]
[MemberData(nameof(InternationalHostNames))]
public class PlatformHandler_HttpClientHandler : HttpClientHandlerTestBase
{
+ public PlatformHandler_HttpClientHandler(ITestOutputHelper output) : base(output) { }
+
[Theory]
[InlineData(false)]
[InlineData(true)]
public sealed class PlatformHandler_HttpClientHandler_Asynchrony_Test : HttpClientHandler_Asynchrony_Test
{
+ public PlatformHandler_HttpClientHandler_Asynchrony_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpProtocolTests : HttpProtocolTests
{
+ public PlatformHandler_HttpProtocolTests(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpProtocolTests_Dribble : HttpProtocolTests_Dribble
{
+ public PlatformHandler_HttpProtocolTests_Dribble(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_DiagnosticsTest : DiagnosticsTest
{
+ public PlatformHandler_DiagnosticsTest(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClient_SelectedSites_Test : HttpClient_SelectedSites_Test
{
+ public PlatformHandler_HttpClient_SelectedSites_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClientEKUTest : HttpClientEKUTest
{
+ public PlatformHandler_HttpClientEKUTest(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test : HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test
{
+ public PlatformHandler_HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
#endif
public sealed class PlatformHandler_HttpClientHandler_DefaultProxyCredentials_Test : HttpClientHandler_DefaultProxyCredentials_Test
{
+ public PlatformHandler_HttpClientHandler_DefaultProxyCredentials_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClientHandler_MaxConnectionsPerServer_Test : HttpClientHandler_MaxConnectionsPerServer_Test
{
+ public PlatformHandler_HttpClientHandler_MaxConnectionsPerServer_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClientHandler_ServerCertificates_Test : HttpClientHandler_ServerCertificates_Test
{
+ public PlatformHandler_HttpClientHandler_ServerCertificates_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClientHandler_SslProtocols_Test : HttpClientHandler_SslProtocols_Test
{
+ public PlatformHandler_HttpClientHandler_SslProtocols_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClientMiniStress : HttpClientMiniStress
{
+ public PlatformHandler_HttpClientMiniStress(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_IdnaProtocolTests : IdnaProtocolTests
{
+ public PlatformHandler_IdnaProtocolTests(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
// WinHttp on Win7 does not support IDNA
protected override bool SupportsIdna => !PlatformDetection.IsWindows7 && !PlatformDetection.IsFullFramework;
public sealed class PlatformHandler_HttpRetryProtocolTests : HttpRetryProtocolTests
{
+ public PlatformHandler_HttpRetryProtocolTests(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandlerTest_Cookies : HttpClientHandlerTest_Cookies
{
+ public PlatformHandlerTest_Cookies(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandlerTest_Cookies_Http11 : HttpClientHandlerTest_Cookies_Http11
{
+ public PlatformHandlerTest_Cookies_Http11(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClientHandler_MaxResponseHeadersLength_Test : HttpClientHandler_MaxResponseHeadersLength_Test
{
+ public PlatformHandler_HttpClientHandler_MaxResponseHeadersLength_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
public sealed class PlatformHandler_HttpClientHandler_Cancellation_Test : HttpClientHandler_Cancellation_Test
{
+ public PlatformHandler_HttpClientHandler_Cancellation_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => false;
}
private static readonly Uri SecureBasicAuthServerUri =
Configuration.Http.BasicAuthUriForCreds(true, UserName, Password);
- private readonly ITestOutputHelper _output;
-
public static readonly object[][] EchoServers = Configuration.Http.EchoServers;
public static readonly object[][] VerifyUploadServers = Configuration.Http.VerifyUploadServers;
new object[] { SecureBasicAuthServerUri }
};
- public PostScenarioTest(ITestOutputHelper output)
- {
- _output = output;
- }
+ public PostScenarioTest(ITestOutputHelper output) : base(output) { }
[ActiveIssue(30057, TargetFrameworkMonikers.Uap)]
[SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, ".NET Framework disposes request content after send")]
public abstract class PostScenarioUWPTest : HttpClientHandlerTestBase
{
- private readonly ITestOutputHelper _output;
-
- public PostScenarioUWPTest(ITestOutputHelper output)
- {
- _output = output;
- }
+ public PostScenarioUWPTest(ITestOutputHelper output) : base(output) { }
[Fact]
public void Authentication_UseStreamContent_Throws()
public abstract class ResponseStreamTest : HttpClientHandlerTestBase
{
- private readonly ITestOutputHelper _output;
-
- public ResponseStreamTest(ITestOutputHelper output)
- {
- _output = output;
- }
+ public ResponseStreamTest(ITestOutputHelper output) : base(output) { }
[OuterLoop("Uses external server")]
[Theory]
[SkipOnTargetFramework(TargetFrameworkMonikers.Uap, "HttpsTestServer not compatible on UAP")]
public abstract class SchSendAuxRecordHttpTest : HttpClientHandlerTestBase
{
- readonly ITestOutputHelper _output;
-
- public SchSendAuxRecordHttpTest(ITestOutputHelper output)
- {
- _output = output;
- }
+ public SchSendAuxRecordHttpTest(ITestOutputHelper output) : base(output) { }
[Fact]
[PlatformSpecific(TestPlatforms.Windows)]
{
protected override bool UseSocketsHttpHandler => true;
+ public SocketsHttpHandler_HttpClientHandler_Asynchrony_Test(ITestOutputHelper output) : base(output) { }
+
[OuterLoop("Relies on finalization")]
[Fact]
public async Task ExecutionContext_HttpConnectionLifetimeDoesntKeepContextAlive()
{
protected override bool UseSocketsHttpHandler => true;
+ public SocketsHttpHandler_HttpProtocolTests(ITestOutputHelper output) : base(output) { }
+
[Theory]
[InlineData("delete", "DELETE")]
[InlineData("options", "OPTIONS")]
public sealed class SocketsHttpHandler_HttpProtocolTests_Dribble : HttpProtocolTests_Dribble
{
+ public SocketsHttpHandler_HttpProtocolTests_Dribble(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_DiagnosticsTest : DiagnosticsTest
{
+ public SocketsHttpHandler_DiagnosticsTest(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_HttpClient_SelectedSites_Test : HttpClient_SelectedSites_Test
{
+ public SocketsHttpHandler_HttpClient_SelectedSites_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_HttpClientEKUTest : HttpClientEKUTest
{
+ public SocketsHttpHandler_HttpClientEKUTest(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test : HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test
{
+ public SocketsHttpHandler_HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_HttpClientHandler_DefaultProxyCredentials_Test : HttpClientHandler_DefaultProxyCredentials_Test
{
+ public SocketsHttpHandler_HttpClientHandler_DefaultProxyCredentials_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
{
protected override bool UseSocketsHttpHandler => true;
+ public SocketsHttpHandler_HttpClientHandler_MaxConnectionsPerServer_Test(ITestOutputHelper output) : base(output) { }
+
[OuterLoop("Incurs a small delay")]
[Theory]
[InlineData(0)]
public sealed class SocketsHttpHandler_HttpClientHandler_ServerCertificates_Test : HttpClientHandler_ServerCertificates_Test
{
+ public SocketsHttpHandler_HttpClientHandler_ServerCertificates_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
s.ResponseDrainTimeout = time;
}
+ public SocketsHttpHandler_HttpClientHandler_ResponseDrain_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
public void MaxResponseDrainSize_Roundtrips()
{
public sealed class SocketsHttpHandler_HttpClientHandler_SslProtocols_Test : HttpClientHandler_SslProtocols_Test
{
+ public SocketsHttpHandler_HttpClientHandler_SslProtocols_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_HttpClientHandler_TrailingHeaders_Test : HttpClientHandlerTest_TrailingHeaders_Test
{
+ public SocketsHttpHandler_HttpClientHandler_TrailingHeaders_Test(ITestOutputHelper output) : base(output) { }
// PlatformHandlers don't support trailers.
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_HttpClientMiniStress : HttpClientMiniStress
{
+ public SocketsHttpHandler_HttpClientMiniStress(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_IdnaProtocolTests : IdnaProtocolTests
{
+ public SocketsHttpHandler_IdnaProtocolTests(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
protected override bool SupportsIdna => true;
}
public sealed class SocketsHttpHandler_HttpRetryProtocolTests : HttpRetryProtocolTests
{
+ public SocketsHttpHandler_HttpRetryProtocolTests(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandlerTest_Cookies : HttpClientHandlerTest_Cookies
{
+ public SocketsHttpHandlerTest_Cookies(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandlerTest_Cookies_Http11 : HttpClientHandlerTest_Cookies_Http11
{
+ public SocketsHttpHandlerTest_Cookies_Http11(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test : HttpClientHandler_Cancellation_Test
{
+ public SocketsHttpHandler_HttpClientHandler_Cancellation_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
[Fact]
public sealed class SocketsHttpHandler_HttpClientHandler_MaxResponseHeadersLength_Test : HttpClientHandler_MaxResponseHeadersLength_Test
{
+ public SocketsHttpHandler_HttpClientHandler_MaxResponseHeadersLength_Test(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
{
protected override bool UseSocketsHttpHandler => true;
+ public SocketsHttpHandler_ConnectionUpgrade_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
public async Task UpgradeConnection_ReturnsReadableAndWritableStream()
{
{
protected override bool UseSocketsHttpHandler => true;
+ public SocketsHttpHandler_Connect_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
public async Task ConnectMethod_Success()
{
{
protected override bool UseSocketsHttpHandler => true;
+ public SocketsHttpHandler_HttpClientHandler_ConnectionPooling_Test(ITestOutputHelper output) : base(output) { }
+
[Fact]
public async Task MultipleIterativeRequests_SameConnectionReused()
{
public sealed class SocketsHttpHandler_ExternalConfiguration_Test : HttpClientHandlerTestBase
{
+ public SocketsHttpHandler_ExternalConfiguration_Test(ITestOutputHelper output) : base(output) { }
+
private const string EnvironmentVariableSettingName = "DOTNET_SYSTEM_NET_HTTP_USESOCKETSHTTPHANDLER";
private const string AppContextSettingName = "System.Net.Http.UseSocketsHttpHandler";
public sealed class SocketsHttpHandlerTest_Http2 : HttpClientHandlerTest_Http2
{
+ public SocketsHttpHandlerTest_Http2(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
}
[ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.SupportsAlpn))]
public sealed class SocketsHttpHandlerTest_Cookies_Http2 : HttpClientHandlerTest_Cookies
{
+ public SocketsHttpHandlerTest_Cookies_Http2(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
protected override bool UseHttp2LoopbackServer => true;
}
public sealed class SocketsHttpHandlerTest_HttpClientHandlerTest_Http2 : HttpClientHandlerTest
{
public SocketsHttpHandlerTest_HttpClientHandlerTest_Http2(ITestOutputHelper output) : base(output) { }
+ protected override bool UseSocketsHttpHandler => true;
+ protected override bool UseHttp2LoopbackServer => true;
+ }
+
+ public sealed class SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http11 : HttpClientHandlerTest_Headers
+ {
+ public SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http11(ITestOutputHelper output) : base(output) { }
+ protected override bool UseSocketsHttpHandler => true;
+ }
+ [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.SupportsAlpn))]
+ public sealed class SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http2 : HttpClientHandlerTest_Headers
+ {
+ public SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http2(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
protected override bool UseHttp2LoopbackServer => true;
}
[ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.SupportsAlpn))]
public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http2 : HttpClientHandler_Cancellation_Test
{
+ public SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http2(ITestOutputHelper output) : base(output) { }
protected override bool UseSocketsHttpHandler => true;
protected override bool UseHttp2LoopbackServer => true;
}
<Compile Include="HttpMessageInvokerTest.cs" />
<Compile Include="HttpMethodTest.cs" />
<Compile Include="HttpClientHandlerTest.Cookies.cs" />
+ <Compile Include="HttpClientHandlerTest.Headers.cs" />
<Compile Include="HttpRetryProtocolTests.cs" />
<Compile Include="IdnaProtocolTests.cs" />
<Compile Include="HttpProtocolTests.cs" />
projects / platform / upstream / dotnet / runtime.git / commitdiff