Revert "Disable frequently failing tests (dotnet#101439)"

liveans · liveans · commit 5fec6dc41edd · 2024-06-03T16:58:36.000+02:00
This reverts commit e01db17.
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cookies.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cookies.cs
@@ -216,15 +216,10 @@ private string GetCookieValue(HttpRequestData request)
             return cookieHeaderValue;
         }
 
-        [ConditionalFact]
+        [Fact]
         [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_SetCookieContainerAndCookieHeader_BothCookiesSent()
         {
-            if (UseVersion == HttpVersion30)
-            {
-                throw new SkipTestException("https://github.com/dotnet/runtime/issues/101377");
-            }
-
             await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
             {
                 HttpClientHandler handler = CreateHttpClientHandler();
@@ -318,7 +313,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async url =>
                 using (HttpClient client = CreateHttpClient(handler))
                 {
                     client.DefaultRequestHeaders.ConnectionClose = true; // to avoid issues with connection pooling
-                    await client.GetAsync(url1);
+                        await client.GetAsync(url1);
                 }
             },
             async server =>
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs
@@ -269,7 +269,7 @@ await LoopbackServer.CreateClientAndServerAsync(async proxyUri =>
         public static IEnumerable<object[]> SecureAndNonSecure_IPBasedUri_MemberData() =>
             from address in new[] { IPAddress.Loopback, IPAddress.IPv6Loopback }
             from useSsl in BoolValues
-                // we could not create SslStream in browser, [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+            // we could not create SslStream in browser, [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
             where PlatformDetection.IsNotBrowser || !useSsl
             select new object[] { address, useSsl };
 
@@ -882,8 +882,8 @@ await LoopbackServer.CreateClientAndServerAsync(async url =>
                 "\r\n" +
                 "5\r\n" +
                 "hello" + // missing \r\n terminator
-                          //"5\r\n" +
-                          //"world" + // missing \r\n terminator
+                            //"5\r\n" +
+                            //"world" + // missing \r\n terminator
                 "0\r\n" +
                 "\r\n"));
         }
@@ -988,7 +988,7 @@ await connection.WriteStringAsync(
             });
         }
 
-        [ConditionalTheory]
+        [Theory]
         [InlineData(true, true, true)]
         [InlineData(true, true, false)]
         [InlineData(true, false, false)]
@@ -998,11 +998,6 @@ await connection.WriteStringAsync(
         [ActiveIssue("https://github.com/dotnet/runtime/issues/65429", typeof(PlatformDetection), nameof(PlatformDetection.IsNodeJS))]
         public async Task ReadAsStreamAsync_HandlerProducesWellBehavedResponseStream(bool? chunked, bool enableWasmStreaming, bool slowChunks)
         {
-            if (UseVersion == HttpVersion30)
-            {
-                throw new SkipTestException("https://github.com/dotnet/runtime/issues/91757");
-            }
-
             if (IsWinHttpHandler && UseVersion >= HttpVersion20.Value)
             {
                 return;
@@ -1102,7 +1097,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                         if (PlatformDetection.IsBrowser)
                         {
 #if !NETFRAMEWORK
-                            if (slowChunks)
+                            if(slowChunks)
                             {
                                 Assert.Equal(1, await responseStream.ReadAsync(new Memory<byte>(buffer2)));
                                 Assert.Equal((byte)'h', buffer2[0]);
@@ -1212,7 +1207,7 @@ await server.AcceptConnectionAsync(async connection =>
                     {
                         case true:
                             await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] { new HttpHeaderData("Transfer-Encoding", "chunked") }, isFinal: false);
-                            if (PlatformDetection.IsBrowser && slowChunks)
+                            if(PlatformDetection.IsBrowser && slowChunks)
                             {
                                 await connection.SendResponseBodyAsync("1\r\nh\r\n", false);
                                 await tcs.Task;
@@ -1227,12 +1222,12 @@ await server.AcceptConnectionAsync(async connection =>
                             break;
 
                         case false:
-                            await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] { new HttpHeaderData("Content-Length", "11") }, content: "hello world");
+                            await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] { new HttpHeaderData("Content-Length", "11")}, content: "hello world");
                             break;
 
                         case null:
                             // This inject Content-Length header with null value to hint Loopback code to not include one automatically.
-                            await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] { new HttpHeaderData("Content-Length", null) }, isFinal: false);
+                            await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] { new HttpHeaderData("Content-Length", null)}, isFinal: false);
                             await connection.SendResponseBodyAsync("hello world");
                             break;
                     }
@@ -1468,10 +1463,10 @@ await LoopbackServerFactory.CreateServerAsync(async (server3, url3) =>
                         Task serverTask3 = server3.AcceptConnectionAsync(async connection3 =>
                         {
                             await connection3.ReadRequestDataAsync();
-                            await connection3.SendResponseAsync(HttpStatusCode.OK, new HttpHeaderData[] { new HttpHeaderData("Content-Length", "20") }, isFinal: false);
-                            await connection3.SendResponseBodyAsync("1234567890", isFinal: false);
+                            await connection3.SendResponseAsync(HttpStatusCode.OK, new HttpHeaderData[] { new HttpHeaderData("Content-Length", "20") }, isFinal : false);
+                            await connection3.SendResponseBodyAsync("1234567890", isFinal : false);
                             await unblockServers.Task;
-                            await connection3.SendResponseBodyAsync("1234567890", isFinal: true);
+                            await connection3.SendResponseBodyAsync("1234567890", isFinal : true);
                         });
 
                         // Make three requests
@@ -1545,7 +1540,7 @@ public async Task GetAsync_UnicodeHostName_SuccessStatusCodeInResponse()
             }
         }
 
-        #region Post Methods Tests
+#region Post Methods Tests
 
         [Fact]
         [SkipOnPlatform(TestPlatforms.Browser, "ExpectContinue not supported on Browser")]
@@ -1589,13 +1584,13 @@ await server.AcceptConnectionAsync(async connection =>
 
         public static IEnumerable<object[]> Interim1xxStatusCode()
         {
-            yield return new object[] { (HttpStatusCode)100 }; // 100 Continue.
+            yield return new object[] { (HttpStatusCode) 100 }; // 100 Continue.
             // 101 SwitchingProtocols will be treated as a final status code.
-            yield return new object[] { (HttpStatusCode)102 }; // 102 Processing.
-            yield return new object[] { (HttpStatusCode)103 }; // 103 EarlyHints.
-            yield return new object[] { (HttpStatusCode)150 };
-            yield return new object[] { (HttpStatusCode)180 };
-            yield return new object[] { (HttpStatusCode)199 };
+            yield return new object[] { (HttpStatusCode) 102 }; // 102 Processing.
+            yield return new object[] { (HttpStatusCode) 103 }; // 103 EarlyHints.
+            yield return new object[] { (HttpStatusCode) 150 };
+            yield return new object[] { (HttpStatusCode) 180 };
+            yield return new object[] { (HttpStatusCode) 199 };
         }
 
         [Theory]
@@ -1656,7 +1651,7 @@ await server.AcceptConnectionAsync(async connection =>
                             new HttpHeaderData("Content-type", "text/xml"),
                             new HttpHeaderData("Set-Cookie", SetCookieIgnored1)}, isFinal: false);
 
-                    await connection.SendResponseAsync(responseStatusCode, headers: new HttpHeaderData[] {
+                    await connection.SendResponseAsync(responseStatusCode, headers:  new HttpHeaderData[] {
                         new HttpHeaderData("Cookie", "ignore_cookie=choco2"),
                         new HttpHeaderData("Content-type", "text/plain"),
                         new HttpHeaderData("Set-Cookie", SetCookieIgnored2)}, isFinal: false);
@@ -1760,7 +1755,7 @@ await server.AcceptConnectionAsync(async connection =>
                 {
                     await connection.ReadRequestDataAsync(readBody: false);
                     // Send multiple 100-Continue responses.
-                    for (int count = 0; count < 4; count++)
+                    for (int count = 0 ; count < 4; count++)
                     {
                         await connection.SendResponseAsync(HttpStatusCode.Continue, isFinal: false);
                     }
@@ -1864,7 +1859,7 @@ await server.AcceptConnectionAsync(async connection =>
                 {
                     await connection.ReadRequestDataAsync(readBody: false);
 
-                    await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] { new HttpHeaderData("Content-Length", $"{ResponseString.Length}") }, isFinal: false);
+                    await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] {new HttpHeaderData("Content-Length", $"{ResponseString.Length}")}, isFinal : false);
 
                     byte[] body = await connection.ReadRequestBodyAsync();
                     Assert.Equal(RequestString, Encoding.ASCII.GetString(body));
@@ -2129,7 +2124,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, rootUrl) =>
                 }
             });
         }
-        #endregion
+#endregion
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowserDomSupported))]
         public async Task GetAsync_InvalidUrl_ExpectedExceptionThrown()
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.AltSvc.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.AltSvc.cs
@@ -8,8 +8,6 @@
 using System.Net.Test.Common;
 using System.Net.Quic;
 
-using Microsoft.DotNet.XUnitExtensions;
-
 namespace System.Net.Http.Functional.Tests
 {
     public abstract class HttpClientHandler_AltSvc_Test : HttpClientHandlerTestBase
@@ -73,14 +71,9 @@ public async Task AltSvc_Header_Upgrade_Success(Version fromVersion, bool overri
                 { HttpVersion.Version20, false }
             };
 
-        [ConditionalFact]
+        [Fact]
         public async Task AltSvc_ConnectionFrame_UpgradeFrom20_Success()
         {
-            if (UseVersion == HttpVersion30)
-            {
-                throw new SkipTestException("https://github.com/dotnet/runtime/issues/101376");
-            }
-
             using Http2LoopbackServer firstServer = Http2LoopbackServer.CreateServer();
             using Http3LoopbackServer secondServer = CreateHttp3LoopbackServer();
             using HttpClient client = CreateHttpClient(HttpVersion.Version20);
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Headers.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Headers.cs
@@ -13,8 +13,6 @@
 using Xunit;
 using Xunit.Abstractions;
 
-using Microsoft.DotNet.XUnitExtensions;
-
 namespace System.Net.Http.Functional.Tests
 {
     using Configuration = System.Net.Test.Common.Configuration;
@@ -289,17 +287,12 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
            });
         }
 
-        [ConditionalTheory]
+        [Theory]
         [InlineData("Thu, 01 Dec 1994 16:00:00 GMT", true)]
         [InlineData("-1", false)]
         [InlineData("0", false)]
         public async Task SendAsync_Expires_Success(string value, bool isValid)
         {
-            if (UseVersion == HttpVersion30)
-            {
-                throw new SkipTestException("https://github.com/dotnet/runtime/issues/91757");
-            }
-
             await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
                 using (HttpClient client = CreateHttpClient())

Original file line number	Diff line number	Diff line change
`@@ -216,15 +216,10 @@ private string GetCookieValue(HttpRequestData request)`
`216`	`216`	`return cookieHeaderValue;`
`217`	`217`	`}`
`218`	`218`
`219`		`- [ConditionalFact]`
	`219`	`+ [Fact]`
`220`	`220`	`[SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]`
`221`	`221`	`public async Task GetAsync_SetCookieContainerAndCookieHeader_BothCookiesSent()`
`222`	`222`	`{`
`223`		`- if (UseVersion == HttpVersion30)`
`224`		`- {`
`225`		`- throw new SkipTestException("https://github.com/dotnet/runtime/issues/101377");`
`226`		`- }`
`227`		`-`
`228`	`223`	`await LoopbackServerFactory.CreateServerAsync(async (server, url) =>`
`229`	`224`	`{`
`230`	`225`	`HttpClientHandler handler = CreateHttpClientHandler();`
`@@ -318,7 +313,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async url =>`
`318`	`313`	`using (HttpClient client = CreateHttpClient(handler))`
`319`	`314`	`{`
`320`	`315`	`client.DefaultRequestHeaders.ConnectionClose = true; // to avoid issues with connection pooling`
`321`		`- await client.GetAsync(url1);`
	`316`	`+ await client.GetAsync(url1);`
`322`	`317`	`}`
`323`	`318`	`},`
`324`	`319`	`async server =>`