be more liberal on what exception type to get on handshake failure (#27352)

* be more liberal on what exception type to get on handshake failure
* refactor test code to address feedback from review
* move "catch XX" to separate line

Author: wfurt

src/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.SslProtocols.cs

@@ -240,19 +240,12 @@ await TestHelper.WhenAllCompletedOrAnyFailed(
 
         [OuterLoop] // TODO: Issue #11345
         [Theory]
-        [InlineData(SslProtocols.Tls11, SslProtocols.Tls, typeof(IOException))]
-        [InlineData(SslProtocols.Tls12, SslProtocols.Tls11, typeof(IOException))]
-        [InlineData(SslProtocols.Tls, SslProtocols.Tls12, typeof(AuthenticationException))]
+        [InlineData(SslProtocols.Tls11, SslProtocols.Tls)]
+        [InlineData(SslProtocols.Tls12, SslProtocols.Tls11)]
+        [InlineData(SslProtocols.Tls, SslProtocols.Tls12)]
         public async Task GetAsync_AllowedSSLVersionDiffersFromServer_ThrowsException(
-            SslProtocols allowedProtocol, SslProtocols acceptedProtocol, Type exceptedServerException)
+            SslProtocols allowedProtocol, SslProtocols acceptedProtocol)
         {
-
-            if (PlatformDetection.IsUbuntu1804)
-            {
-                //ActiveIssue #27023: [Ubuntu18.04] Tests failed:
-                return;
-            }
-
             if (!BackendSupportsSslConfiguration)
                 return;
             using (HttpClientHandler handler = CreateHttpClientHandler())
@@ -264,9 +257,20 @@ public async Task GetAsync_AllowedSSLVersionDiffersFromServer_ThrowsException(
                 var options = new LoopbackServer.Options { UseSsl = true, SslProtocols = acceptedProtocol };
                 await LoopbackServer.CreateServerAsync(async (server, url) =>
                 {
-                    await TestHelper.WhenAllCompletedOrAnyFailed(
-                        Assert.ThrowsAsync(exceptedServerException, () => server.AcceptConnectionSendResponseAndCloseAsync()),
-                        Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url)));
+                    Task serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
+                    await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url));
+                    try
+                    {
+                        await serverTask;
+                    }
+                    catch (Exception e) when (e is IOException || e is AuthenticationException)
+                    {
+                        // Some SSL implementations simply close or reset connection after protocol mismatch.
+                        // Newer OpenSSL sends Fatal Alert message before closing.
+                        return;
+                    }
+                    // We expect negotiation to fail so one or the other expected exception should be thrown.
+                    Assert.True(false, "Expected exception did not happen.");
                 }, options);
             }
         }
@@ -276,12 +280,6 @@ await TestHelper.WhenAllCompletedOrAnyFailed(
         [Fact]
         public async Task GetAsync_DisallowTls10_AllowTls11_AllowTls12()
         {
-            if (PlatformDetection.IsUbuntu1804)
-            {
-                //ActiveIssue #27023: [Ubuntu18.04] Tests failed:
-                return;
-            }
-
             using (HttpClientHandler handler = CreateHttpClientHandler())
             using (var client = new HttpClient(handler))
             {
@@ -295,9 +293,20 @@ public async Task GetAsync_DisallowTls10_AllowTls11_AllowTls12()
                     options.SslProtocols = SslProtocols.Tls;
                     await LoopbackServer.CreateServerAsync(async (server, url) =>
                     {
-                        await TestHelper.WhenAllCompletedOrAnyFailed(
-                            Assert.ThrowsAsync<IOException>(() => server.AcceptConnectionSendResponseAndCloseAsync()),
-                            Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url)));
+                        Task serverTask =  server.AcceptConnectionSendResponseAndCloseAsync();
+                        await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url));
+                        try
+                        {
+                            await serverTask;
+                        }
+                        catch (Exception e) when (e is IOException || e is AuthenticationException)
+                        {
+                            // Some SSL implementations simply close or reset connection after protocol mismatch.
+                            // Newer OpenSSL sends Fatal Alert message before closing.
+                            return;
+                        }
+                        // We expect negotiation to fail so one or the other expected exception should be thrown.
+                        Assert.True(false, "Expected exception did not happen.");
                     }, options);
 
                     foreach (var prot in new[] { SslProtocols.Tls11, SslProtocols.Tls12 })