Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/aspnetwebstack/test/System.Web.WebPages.Test/Utils/CultureUtilTest.cs

@@ -0,0 +1,258 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using Moq;
+using Xunit;
+
+namespace System.Web.WebPages.Test
+{
+    public class CultureUtilTest
+    {
+        [Fact]
+        public void SetAutoCultureWithNoUserLanguagesDoesNothing()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(null);
+            Thread thread = GetThread();
+            CultureInfo culture = thread.CurrentCulture;
+
+            // Act
+            CultureUtil.SetCulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(culture, thread.CurrentCulture);
+        }
+
+        [Fact]
+        public void SetAutoUICultureWithNoUserLanguagesDoesNothing()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(null);
+            Thread thread = GetThread();
+            CultureInfo culture = thread.CurrentUICulture;
+
+            // Act
+            CultureUtil.SetUICulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(culture, thread.CurrentUICulture);
+        }
+
+        [Fact]
+        public void SetAutoCultureWithEmptyUserLanguagesDoesNothing()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(Enumerable.Empty<string>());
+            Thread thread = GetThread();
+            CultureInfo culture = thread.CurrentCulture;
+
+            // Act
+            CultureUtil.SetCulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(culture, thread.CurrentCulture);
+        }
+
+        [Fact]
+        public void SetAutoUICultureWithEmptyUserLanguagesDoesNothing()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(Enumerable.Empty<string>());
+            Thread thread = GetThread();
+            CultureInfo culture = thread.CurrentUICulture;
+
+            // Act
+            CultureUtil.SetUICulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(culture, thread.CurrentUICulture);
+        }
+
+        [Fact]
+        public void SetAutoCultureWithBlankUserLanguagesDoesNothing()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(new[] { " " });
+            Thread thread = GetThread();
+            CultureInfo culture = thread.CurrentCulture;
+
+            // Act
+            CultureUtil.SetCulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(culture, thread.CurrentCulture);
+        }
+
+        [Fact]
+        public void SetAutoUICultureWithBlankUserLanguagesDoesNothing()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(new[] { " " });
+            Thread thread = GetThread();
+            CultureInfo culture = thread.CurrentUICulture;
+
+            // Act
+            CultureUtil.SetUICulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(culture, thread.CurrentUICulture);
+        }
+
+        [Fact]
+        public void SetAutoCultureWithInvalidLanguageDoesNothing()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(new[] { "aa-AA", "bb-BB", "cc-CC" });
+            Thread thread = GetThread();
+            CultureInfo culture = thread.CurrentCulture;
+
+            // Act
+            CultureUtil.SetCulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(culture, thread.CurrentCulture);
+        }
+
+        [Fact]
+        public void SetAutoUICultureWithInvalidLanguageDoesNothing()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(new[] { "aa-AA", "bb-BB", "cc-CC" });
+            Thread thread = GetThread();
+            CultureInfo culture = thread.CurrentUICulture;
+
+            // Act
+            CultureUtil.SetUICulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(culture, thread.CurrentUICulture);
+        }
+
+        [Fact]
+        public void SetAutoCultureDetectsUserLanguageCulture()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(new[] { "en-GB", "en-US", "ar-eg" });
+            Thread thread = GetThread();
+
+            // Act
+            CultureUtil.SetCulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentCulture);
+            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentCulture));
+        }
+
+        [Fact]
+        public void SetAutoUICultureDetectsUserLanguageCulture()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(new[] { "en-GB", "en-US", "ar-eg" });
+            Thread thread = GetThread();
+
+            // Act
+            CultureUtil.SetUICulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentUICulture);
+            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentUICulture));
+        }
+
+        [Fact]
+        public void SetAutoCultureUserLanguageWithQParameterCulture()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(new[] { "en-GB;q=0.3", "en-US", "ar-eg;q=0.5" });
+            Thread thread = GetThread();
+
+            // Act
+            CultureUtil.SetCulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentCulture);
+            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentCulture));
+        }
+
+        [Fact]
+        public void SetAutoUICultureDetectsUserLanguageWithQParameterCulture()
+        {
+            // Arrange
+            var context = GetContextForSetCulture(new[] { "en-GB;q=0.3", "en-US", "ar-eg;q=0.5" });
+            Thread thread = GetThread();
+
+            // Act
+            CultureUtil.SetUICulture(thread, context, "auto");
+
+            // Assert
+            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentUICulture);
+            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentUICulture));
+        }
+
+        [Fact]
+        public void SetCultureWithInvalidCultureThrows()
+        {
+            // Arrange
+            var context = GetContextForSetCulture();
+            Thread thread = GetThread();
+
+            // Act and Assert
+            Assert.Throws<CultureNotFoundException>(() => CultureUtil.SetCulture(thread, context, "sans-culture"));
+        }
+
+        [Fact]
+        public void SetUICultureWithInvalidCultureThrows()
+        {
+            // Arrange
+            var context = GetContextForSetCulture();
+            Thread thread = GetThread();
+
+            // Act and Assert
+            Assert.Throws<CultureNotFoundException>(() => CultureUtil.SetUICulture(thread, context, "sans-culture"));
+        }
+
+        [Fact]
+        public void SetCultureWithValidCulture()
+        {
+            // Arrange
+            var context = GetContextForSetCulture();
+            Thread thread = GetThread();
+
+            // Act
+            CultureUtil.SetCulture(thread, context, "en-GB");
+
+            // Assert
+            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentCulture);
+            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentCulture));
+        }
+
+        [Fact]
+        public void SetUICultureWithValidCulture()
+        {
+            // Arrange
+            var context = GetContextForSetCulture();
+            Thread thread = GetThread();
+
+            // Act
+            CultureUtil.SetUICulture(thread, context, "en-GB");
+
+            // Assert
+            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentUICulture);
+            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentUICulture));
+        }
+
+        private static Thread GetThread()
+        {
+            return new Thread(() => { });
+        }
+
+        private static HttpContextBase GetContextForSetCulture(IEnumerable<string> userLanguages = null)
+        {
+            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
+            contextMock.Setup(context => context.Request.UserLanguages).Returns(userLanguages == null ? null : userLanguages.ToArray());
+            return contextMock.Object;
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Utils/PathUtilTest.cs

@@ -0,0 +1,179 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Linq;
+using System.Web.WebPages.TestUtils;
+using Microsoft.Internal.Web.Utils;
+using Xunit;
+
+namespace System.Web.WebPages.Test
+{
+    public class PathUtilTest
+    {
+        [Fact]
+        public void IsSimpleNameTest()
+        {
+            Assert.True(PathUtil.IsSimpleName("Test.cshtml"));
+            Assert.True(PathUtil.IsSimpleName("Test.Hello.cshtml"));
+            Assert.False(PathUtil.IsSimpleName("~/myapp/Test/Hello.cshtml"));
+            Assert.False(PathUtil.IsSimpleName("../Test/Hello.cshtml"));
+            Assert.False(PathUtil.IsSimpleName("../../Test/Hello.cshtml"));
+            Assert.False(PathUtil.IsSimpleName("/Test/Hello.cshtml"));
+        }
+
+        [Fact]
+        public void GetExtensionForNullPathsReturnsNull()
+        {
+            // Arrange
+            string path = null;
+
+            // Act
+            string extension = PathUtil.GetExtension(path);
+
+            // Assert
+            Assert.Null(extension);
+        }
+
+        [Fact]
+        public void GetExtensionForEmptyPathsReturnsEmptyString()
+        {
+            // Arrange
+            string path = String.Empty;
+
+            // Act
+            string extension = PathUtil.GetExtension(path);
+
+            // Assert
+            Assert.Equal(0, extension.Length);
+        }
+
+        [Fact]
+        public void GetExtensionReturnsEmptyStringForPathsThatDoNotContainExtension()
+        {
+            // Arrange
+            string[] paths = new[] { "SomePath", "SomePath/", "SomePath/MorePath", "SomePath/MorePath/" };
+
+            // Act
+            var extensions = paths.Select(PathUtil.GetExtension);
+
+            // Assert
+            Assert.True(extensions.All(ext => ext.Length == 0));
+        }
+
+        [Fact]
+        public void GetExtensionReturnsEmptyStringForPathsContainingPathInfo()
+        {
+            // Arrange
+            string[] paths = new[] { "SomePath.cshtml/", "SomePath.html/path/info" };
+
+            // Act
+            var extensions = paths.Select(PathUtil.GetExtension);
+
+            // Assert
+            Assert.True(extensions.All(ext => ext.Length == 0));
+        }
+
+        [Fact]
+        public void GetExtensionReturnsEmptyStringForPathsTerminatingWithADot()
+        {
+            // Arrange
+            string[] paths = new[] { "SomePath.", "SomeDirectory/SomePath/SomePath.", "SomeDirectory/SomePath.foo." };
+
+            // Act
+            var extensions = paths.Select(PathUtil.GetExtension);
+
+            // Assert
+            Assert.True(extensions.All(ext => ext.Length == 0));
+        }
+
+        [Fact]
+        public void GetExtensionReturnsExtensionsForPathsTerminatingInExtension()
+        {
+            // Arrange
+            string path1 = "SomePath.cshtml";
+            string path2 = "SomeDir/SomePath.txt";
+
+            // Act
+            string ext1 = PathUtil.GetExtension(path1);
+            string ext2 = PathUtil.GetExtension(path2);
+
+            // Assert
+            Assert.Equal(ext1, ".cshtml");
+            Assert.Equal(ext2, ".txt");
+        }
+
+        [Fact]
+        public void GetExtensionDoesNotThrowForPathsWithInvalidCharacters()
+        {
+            // Arrange
+            // Repro from test case in Bug 93828
+            string path = "Insights/110786998958803%7C2.d24wA6Y3MiT2w8p3OT4yTw__.3600.1289415600-708897727%7CRLN-t1w9bXtKWZ_11osz15Rk_jY";
+
+            // Act
+            string extension = PathUtil.GetExtension(path);
+
+            // Assert
+            Assert.Equal(".1289415600-708897727%7CRLN-t1w9bXtKWZ_11osz15Rk_jY", extension);
+        }
+
+        [Fact]
+        public void IsWithinAppRootNestedTest()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                var root = "/subfolder1/website1";
+                using (Utils.CreateHttpRuntime(root))
+                {
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/default.cshtml"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/test/default.cshtml"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "/subfolder1/website1"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "/subfolder1/website1/"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "/subfolder1/website1/default.cshtml"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "/subfolder1/website1/test/default.cshtml"));
+
+                    Assert.False(PathUtil.IsWithinAppRoot(root, "/"));
+                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder1"));
+                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder1/"));
+                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder1/website2"));
+                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder2"));
+                }
+            });
+        }
+
+        [Fact]
+        public void IsWithinAppRootTest()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                var root = "/website1";
+                using (Utils.CreateHttpRuntime(root))
+                {
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/default.cshtml"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/test/default.cshtml"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "/website1"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "/website1/"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "/website1/default.cshtml"));
+                    Assert.True(PathUtil.IsWithinAppRoot(root, "/website1/test/default.cshtml"));
+
+                    Assert.False(PathUtil.IsWithinAppRoot(root, "/"));
+                    Assert.False(PathUtil.IsWithinAppRoot(root, "/website2"));
+                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder1/"));
+                }
+            });
+        }
+
+        private class TestVirtualPathUtility : IVirtualPathUtility
+        {
+            public string Combine(string basePath, string relativePath)
+            {
+                return basePath + "/" + relativePath;
+            }
+
+            public string ToAbsolute(string virtualPath)
+            {
+                return virtualPath;
+            }
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Utils/SessionStateUtilTest.cs

@@ -0,0 +1,185 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Concurrent;
+using System.Web.Razor;
+using System.Web.SessionState;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Web.WebPages.Test
+{
+    public class SessionStateUtilTest
+    {
+        [Fact]
+        public void SetUpSessionStateDoesNotInvokeSessionStateBehaviorIfNoPageHasDirective()
+        {
+            // Arrange
+            var page = new Mock<WebPage>(MockBehavior.Strict);
+            var startPage = new Mock<StartPage>(MockBehavior.Strict);
+            var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage.Object));
+            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
+
+            // Act
+            SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());
+
+            // Assert
+            context.Verify(c => c.SetSessionStateBehavior(It.IsAny<SessionStateBehavior>()), Times.Never());
+        }
+
+        [Fact]
+        public void SetUpSessionStateUsesSessionStateValueFromRequestingPageIfAvailable()
+        {
+            // Arrange
+            var page = new DisabledSessionWebPage();
+            var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
+            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
+            context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.Disabled)).Verifiable();
+
+            // Act
+            SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());
+
+            // Assert
+            context.Verify();
+        }
+
+        [Fact]
+        public void SetUpSessionStateUsesSessionStateValueFromStartPageHierarchy()
+        {
+            // Arrange
+            var page = new Mock<WebPage>(MockBehavior.Strict);
+            var startPage = new DefaultSessionWebPage
+            {
+                ChildPage = new ReadOnlySessionWebPage()
+            };
+            var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage));
+            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
+            context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.ReadOnly)).Verifiable();
+
+            // Act
+            SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());
+
+            // Assert
+            context.Verify();
+        }
+
+        [Fact]
+        public void SetUpSessionStateThrowsIfSessionStateValueIsInvalid()
+        {
+            // Arrange
+            var page = new Mock<WebPage>(MockBehavior.Strict);
+            var startPage = new InvalidSessionState();
+            var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage));
+            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
+
+            // Act
+            Assert.Throws<ArgumentException>(() => SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>()),
+                "Value \"jabberwocky\" specified in \"~/_Invalid.cshtml\" is an invalid value for the SessionState directive. Possible values are: \"Default, Required, ReadOnly, Disabled\".");
+        }
+
+        [Fact]
+        public void SetUpSessionStateThrowsIfMultipleSessionStateValueIsInvalid()
+        {
+            // Arrange
+            var page = new PageWithMultipleSesionStateAttributes();
+            var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
+            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
+
+            // Act
+            Assert.Throws<InvalidOperationException>(() => SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>()),
+                "At most one SessionState value can be declared per page.");
+        }
+
+        [Fact]
+        public void SetUpSessionStateUsesCache()
+        {
+            // Arrange
+            var page = new PageWithBadAttribute();
+            var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
+            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
+            var dictionary = new ConcurrentDictionary<Type, SessionStateBehavior?>();
+            dictionary.TryAdd(webPageHttpHandler.GetType(), SessionStateBehavior.Default);
+            context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.Default)).Verifiable();
+
+            // Act
+            SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, dictionary);
+
+            // Assert
+            context.Verify();
+            Assert.Throws<Exception>(() => page.GetType().GetCustomAttributes(inherit: false), "Can't call me!");
+        }
+
+        [RazorDirective("sessionstate", "disabled")]
+        private sealed class DisabledSessionWebPage : WebPage
+        {
+            public override void Execute()
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        [RazorDirective("sessionstate", "ReadOnly")]
+        private sealed class ReadOnlySessionWebPage : StartPage
+        {
+            public override void Execute()
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        [RazorDirective("SessionState", "Default")]
+        private sealed class DefaultSessionWebPage : StartPage
+        {
+            public override void Execute()
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        [RazorDirective("SessionState", "jabberwocky")]
+        private sealed class InvalidSessionState : StartPage
+        {
+            public override string VirtualPath
+            {
+                get
+                {
+                    return "~/_Invalid.cshtml";
+                }
+                set
+                {
+                    VirtualPath = value;
+                }
+            }
+            public override void Execute()
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        private sealed class BadAttribute : Attribute
+        {
+            public BadAttribute()
+            {
+                throw new Exception("Can't call me!");
+            }
+        }
+
+        [RazorDirective("SessionState", "Default"), Bad]
+        private sealed class PageWithBadAttribute : WebPage
+        {
+            public override void Execute()
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        [RazorDirective("SessionState", "Disabled"), RazorDirective("SessionState", "ReadOnly")]
+        private sealed class PageWithMultipleSesionStateAttributes : WebPage
+        {
+            public override void Execute()
+            {
+                throw new NotSupportedException();
+            }
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Utils/TestObjectFactory.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Linq;
+
+namespace System.Web.WebPages.Test
+{
+    public class HashVirtualPathFactory : IVirtualPathFactory
+    {
+        private IDictionary<string, object> _pages;
+
+        public HashVirtualPathFactory(params WebPageExecutingBase[] pages)
+        {
+            _pages = pages.ToDictionary(p => p.VirtualPath, p => (object)p, StringComparer.OrdinalIgnoreCase);
+        }
+
+        public bool Exists(string virtualPath)
+        {
+            return _pages.ContainsKey(virtualPath);
+        }
+
+        public object CreateInstance(string virtualPath)
+        {
+            object value;
+            if (_pages.TryGetValue(virtualPath, out value))
+            {
+                return value;
+            }
+            return null;
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Utils/TypeHelperTest.cs

@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Web.WebPages.Test
+{
+    public class TypeHelperTest
+    {
+        [Fact]
+        public void ObjectToDictionaryWithNullObjectReturnsEmptyDictionary()
+        {
+            // Arrange
+            object dict = null;
+
+            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);
+
+            Assert.NotNull(dictValues);
+            Assert.Equal(0, dictValues.Count);
+        }
+
+        [Fact]
+        public void ObjectToDictionaryWithPlainObjectTypeReturnsEmptyDictionary()
+        {
+            // Arrange
+            object dict = new object();
+
+            // Act
+            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);
+
+            // Assert
+            Assert.NotNull(dictValues);
+            Assert.Equal(0, dictValues.Count);
+        }
+
+        [Fact]
+        public void ObjectToDictionaryWithPrimitiveTypeLooksUpPublicProperties()
+        {
+            // Arrange
+            object dict = "test";
+
+            // Act
+            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);
+
+            // Assert
+            Assert.NotNull(dictValues);
+            Assert.Equal(1, dictValues.Count);
+            Assert.Equal(4, dictValues["Length"]);
+        }
+
+        [Fact]
+        public void ObjectToDictionaryWithAnonymousTypeLooksUpProperties()
+        {
+            // Arrange
+            object dict = new { test = "value", other = 1 };
+
+            // Act
+            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);
+
+            // Assert
+            Assert.NotNull(dictValues);
+            Assert.Equal(2, dictValues.Count);
+            Assert.Equal("value", dictValues["test"]);
+            Assert.Equal(1, dictValues["other"]);
+        }
+
+        [Fact]
+        public void ObjectToDictionaryReturnsCaseInsensitiveDictionary()
+        {
+            // Arrange
+            object dict = new { TEST = "value", oThEr = 1 };
+
+            // Act
+            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);
+
+            // Assert
+            Assert.NotNull(dictValues);
+            Assert.Equal(2, dictValues.Count);
+            Assert.Equal("value", dictValues["test"]);
+            Assert.Equal(1, dictValues["other"]);
+        }
+
+        [Fact]
+        public void AddAnonymousTypeObjectToDictionaryTest()
+        {
+            IDictionary<string, object> d = new Dictionary<string, object>();
+            d.Add("X", "Xvalue");
+            TypeHelper.AddAnonymousObjectToDictionary(d, new { A = "a", B = "b" });
+            Assert.Equal("Xvalue", d["X"]);
+            Assert.Equal("a", d["A"]);
+            Assert.Equal("b", d["B"]);
+        }
+
+        [Fact]
+        public void IsAnonymousTypeTest()
+        {
+            Assert.False(TypeHelper.IsAnonymousType(typeof(object)));
+            Assert.False(TypeHelper.IsAnonymousType(typeof(string)));
+            Assert.False(TypeHelper.IsAnonymousType(typeof(IDictionary<object, object>)));
+            Assert.True(TypeHelper.IsAnonymousType((new { A = "a", B = "b" }.GetType())));
+            var x = "x";
+            var y = "y";
+            Assert.True(TypeHelper.IsAnonymousType((new { x, y }.GetType())));
+        }
+
+        [Fact]
+        public void IsAnonymousTypeNullTest()
+        {
+            Assert.ThrowsArgumentNull(() => TypeHelper.IsAnonymousType(null), "type");
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Utils/UrlUtilTest.cs

@@ -0,0 +1,209 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Web.WebPages.TestUtils;
+using Xunit;
+
+namespace System.Web.WebPages.Test
+{
+    public class UrlUtilTest
+    {
+        [Fact]
+        public void UrlTest()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/WebSite1/subfolder1/default.aspx"),
+                                   __ = Utils.CreateHttpRuntime("/WebSite1/"))
+                {
+                    var vpath = "~/subfolder1/default.aspx";
+                    var href = "~/world/test.aspx";
+                    var expected = "/WebSite1/world/test.aspx";
+                    Assert.Equal(expected, UrlUtil.Url(vpath, href));
+                    Assert.Equal(expected, new MockPage() { VirtualPath = vpath }.Href(href));
+                }
+            });
+        }
+
+        [Fact]
+        public void UrlTest2()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/WebSite1/default.aspx"),
+                                   __ = Utils.CreateHttpRuntime("/WebSite1/"))
+                {
+                    var vpath = "~/default.aspx";
+                    var href = "~/world/test.aspx";
+                    var expected = "/WebSite1/world/test.aspx";
+                    Assert.Equal(expected, UrlUtil.Url(vpath, href));
+                    Assert.Equal(expected, new MockPage() { VirtualPath = vpath }.Href(href));
+                }
+            });
+        }
+
+        [Fact]
+        public void UrlTest3()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/WebSite1/subfolder1/default.aspx"),
+                                   __ = Utils.CreateHttpRuntime("/WebSite1/"))
+                {
+                    var vpath = "~/subfolder1/default.aspx";
+                    var href = "world/test.aspx";
+                    var expected = "/WebSite1/subfolder1/world/test.aspx";
+                    Assert.Equal(expected, UrlUtil.Url(vpath, href));
+                    Assert.Equal(expected, new MockPage() { VirtualPath = vpath }.Href(href));
+                }
+            });
+        }
+
+        [Fact]
+        public void UrlTest4()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/WebSite1/subfolder1/default.aspx"),
+                                   __ = Utils.CreateHttpRuntime("/WebSite1/"))
+                {
+                    var vpath = "~/subfolder2/default.aspx";
+                    var href = "world/test.aspx";
+                    var expected = "/WebSite1/subfolder2/world/test.aspx";
+                    Assert.Equal(expected, UrlUtil.Url(vpath, href));
+                    Assert.Equal(expected, new MockPage() { VirtualPath = vpath }.Href(href));
+                }
+            });
+        }
+
+        [Fact]
+        public void BuildUrlEncodesPagePart()
+        {
+            // Arrange
+            var page = "This is a really bad name for a page";
+            var expected = "This%20is%20a%20really%20bad%20name%20for%20a%20page";
+
+            // Act
+            var actual = UrlUtil.BuildUrl(page);
+
+            // Assert
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void BuildUrlAppendsNonAnonymousTypesToPathPortion()
+        {
+            // Arrange
+            object[] pathParts = new object[] { "part", Decimal.One, 1.25f };
+            var page = "home";
+
+            // Act
+            var actual = UrlUtil.BuildUrl(page, pathParts);
+
+            // Assert
+            Assert.Equal(actual, page + "/part/1/1.25");
+        }
+
+        [Fact]
+        public void BuildUrlEncodesAppendedPathPortion()
+        {
+            // Arrange
+            object[] pathParts = new object[] { "path portion", "ζ" };
+            var page = "home";
+
+            // Act
+            var actual = UrlUtil.BuildUrl(page, pathParts);
+
+            // Assert
+            Assert.Equal(actual, page + "/path%20portion/%ce%b6");
+        }
+
+        [Fact]
+        public void BuildUrlAppendsAnonymousObjectsToQueryString()
+        {
+            // Arrange
+            var page = "home";
+            var queryString = new { sort = "FName", dir = "desc" };
+
+            // Act
+            var actual = UrlUtil.BuildUrl(page, queryString);
+
+            // Assert
+            Assert.Equal(actual, page + "?sort=FName&dir=desc");
+        }
+
+        [Fact]
+        public void BuildUrlAppendsMultipleAnonymousObjectsToQueryString()
+        {
+            // Arrange
+            var page = "home";
+            var queryString1 = new { sort = "FName", dir = "desc" };
+            var queryString2 = new { view = "Activities", page = 7 };
+
+            // Act
+            var actual = UrlUtil.BuildUrl(page, queryString1, queryString2);
+
+            // Assert
+            Assert.Equal(actual, page + "?sort=FName&dir=desc&view=Activities&page=7");
+        }
+
+        [Fact]
+        public void BuildUrlEncodesQueryStringKeysAndValues()
+        {
+            // Arrange
+            var page = "home";
+            var queryString = new { ζ = "my=value&", mykey = "<π" };
+
+            // Act
+            var actual = UrlUtil.BuildUrl(page, queryString);
+
+            // Assert
+            Assert.Equal(actual, page + "?%ce%b6=my%3dvalue%26&mykey=%3c%cf%80");
+        }
+
+        [Fact]
+        public void BuildUrlGeneratesPathPartsAndQueryString()
+        {
+            // Arrange
+            var page = "home";
+
+            // Act
+            var actual = UrlUtil.BuildUrl(page, "products", new { cat = 37 }, "furniture", new { sort = "name", dir = "desc" });
+
+            // Assert
+            Assert.Equal(actual, page + "/products/furniture?cat=37&sort=name&dir=desc");
+        }
+
+        [Fact]
+        public void UrlAppRootTest()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/"),
+                                   __ = Utils.CreateHttpRuntime("/"))
+                {
+                    var vpath = "~/";
+                    var href = "~/world/test.aspx";
+                    var expected = "/world/test.aspx";
+                    Assert.Equal(expected, UrlUtil.Url(vpath, href));
+                    Assert.Equal(expected, new MockPage() { VirtualPath = vpath }.Href(href));
+                }
+            });
+        }
+
+        [Fact]
+        public void UrlAnonymousObjectTest()
+        {
+            AppDomainUtils.RunInSeparateAppDomain(() =>
+            {
+                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/"),
+                                   __ = Utils.CreateHttpRuntime("/"))
+                {
+                    Assert.Equal("/world/test.cshtml?Prop1=value1",
+                                 UrlUtil.Url("~/world/page.cshtml", "test.cshtml", new { Prop1 = "value1" }));
+                    Assert.Equal("/world/test.cshtml?Prop1=value1&Prop2=value2",
+                                 UrlUtil.Url("~/world/page.cshtml", "test.cshtml", new { Prop1 = "value1", Prop2 = "value2" }));
+                }
+            });
+        }
+    }
+}