Theory test for urls

Basic Theories

public static IEnumerable<object[]> ValidHttpUrlsToTest
            {
                get
                {
                    yield return new object[] { "HTTP, Closing no slash", "http://foo" };
                    yield return new object[] { "HTTP, Closing slash", "http://foo.com/" };
                    yield return new object[] { "HTTP, Closing", "http://foo.com/" };
                    yield return new object[] { "HTTP, no domain no slash", "http://foo" };
                    yield return new object[] { "HTTP, no domain no slash", "http://foo/" };
                    yield return new object[] { "HTTP, More than one parens", "http://foo.com/more_(than)_one_(parens)" };
                    yield return new object[] { "HTTP, hash after parens", "http://foo.com/blah_(wikipedia)#cite-1" };
                    yield return new object[] { "HTTP, something after parets", "http://foo.com/blah_(wikipedia)_blah#cite-1" };
                    yield return new object[] { "HTTP, unicode in parens", "http://foo.com/unicode_(✪)_in_parens" };
                    yield return new object[] { "HTTP, something after parens", "http://foo.com/(something)?after=parens" };
                    yield return new object[] { "HTTP, with elipsis", "http://github.com/NuGet/NuGetGallery/compare/345ea25491...90a05bc3e0" };
                    yield return new object[] { "HTTP, with query string", "http://foo.com/q?value=1&other=2" };
                    //yield return new object[] { "HTTP, with encoded characters", "http://foo.com/q?=&lt;a&gt" }; //Doesn't like this 
                }
            }

            public static IEnumerable<object[]> ValidSecureUrlsToTest
            {
                get
                {
                    foreach (var httpUrl in ValidHttpUrlsToTest)
                    {
                        yield return new object[] { httpUrl[0].ToString().Replace("HTTP", "HTTPS"), httpUrl[1].ToString().Replace("http://", "https://") };
                    }
                }
            }

            [Theory]
            [PropertyData("ValidHttpUrlsToTest")]
            [PropertyData("ValidSecureUrlsToTest")]
            public void ValidUrlIsOnlyMessageConntent(string scenario, string testUrl)
            {
                //arrange
                HashSet<string> extractedUrls;

                //act
                var result = TextTransform.TransformAndExtractUrls(testUrl, out extractedUrls);
                var expectedFormatedAnchor = string.Format(TextTransform.EXTRACTED_URL_FORMAT_STRING, testUrl, HttpUtility.HtmlDecode(testUrl));

                //assert
                Assert.Contains(expectedFormatedAnchor, result);
            }

            [Theory]
            [PropertyData("ValidHttpUrlsToTest")]
            [PropertyData("ValidSecureUrlsToTest")]
            public void ValidUrlIsEnclosedInQuotes(string scenario, string testUrl)
            {
                //arrange
                HashSet<string> extractedUrls;
                string message;

                //act
                message = '"' + testUrl + '"';
                var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
                var expectedFormatedAnchor = string.Format(TextTransform.EXTRACTED_URL_FORMAT_STRING, testUrl, HttpUtility.HtmlDecode(testUrl));

                //assert
                Assert.Contains(expectedFormatedAnchor, result);
            }

            [Theory]
            [PropertyData("ValidHttpUrlsToTest")]
            [PropertyData("ValidSecureUrlsToTest")]
            public void ValidUrlIsTrailingQuote(string scenario, string testUrl)
            {
                //arrange
                HashSet<string> extractedUrls;
                string message;

                //act
                message = testUrl + '"';
                var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
                var expectedFormatedAnchor = string.Format(TextTransform.EXTRACTED_URL_FORMAT_STRING, testUrl, HttpUtility.HtmlDecode(testUrl));

                //assert
                Assert.Contains(expectedFormatedAnchor, result);
            }

            [Theory]
            [PropertyData("ValidHttpUrlsToTest")]
            [PropertyData("ValidSecureUrlsToTest")]
            public void ValidUrlIsStartingQuote(string scenario, string testUrl)
            {
                //arrange
                HashSet<string> extractedUrls;
                string message;

                //act
                message = '"' + testUrl;
                var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
                var expectedFormatedAnchor = string.Format(TextTransform.EXTRACTED_URL_FORMAT_STRING, testUrl, HttpUtility.HtmlDecode(testUrl));

                //assert
                Assert.Contains(expectedFormatedAnchor, result);
            }

            [Theory]
            [PropertyData("ValidHttpUrlsToTest")]
            [PropertyData("ValidSecureUrlsToTest")]
            public void ValidUrlIsEnclosedInParens(string scenario, string testUrl)
            {
                //arrange
                HashSet<string> extractedUrls;
                string message;

                //act
                message = "(" + testUrl + ")";
                var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
                var expectedFormatedAnchor = string.Format(TextTransform.EXTRACTED_URL_FORMAT_STRING, testUrl, HttpUtility.HtmlDecode(testUrl));

                //assert
                Assert.Contains(expectedFormatedAnchor, result);
            }

            [Theory]
            [PropertyData("ValidHttpUrlsToTest")]
            [PropertyData("ValidSecureUrlsToTest")]
            public void ValidUrlIsStartingParens(string scenario, string testUrl)
            {
                //arrange
                HashSet<string> extractedUrls;
                string message;

                //act
                message = "(" + testUrl;
                var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
                var expectedFormatedAnchor = string.Format(TextTransform.EXTRACTED_URL_FORMAT_STRING, testUrl, HttpUtility.HtmlDecode(testUrl));

                //assert
                Assert.Contains(expectedFormatedAnchor, result);
            }

            [Theory]
            [PropertyData("ValidHttpUrlsToTest")]
            [PropertyData("ValidSecureUrlsToTest")]
            public void ValidUrlIsTrailingParens(string scenario, string testUrl)
            {
                //arrange
                HashSet<string> extractedUrls;
                string message;

                //act
                message = testUrl + ")";
                var result = TextTransform.TransformAndExtractUrls(message, out extractedUrls);
                var expectedFormatedAnchor = string.Format(TextTransform.EXTRACTED_URL_FORMAT_STRING, testUrl, HttpUtility.HtmlDecode(testUrl));

                //assert
                Assert.Contains(expectedFormatedAnchor, result);
            }

Simple URL Regex

public const string REGEX_URL_HTTP_AND_HTTPS_ONLY = @"(?i)\b((?:https?://|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'"".,<>?«»“”‘’]))";