Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/aspnetwebstack/test/System.Web.WebPages.Test/Html/CheckBoxTest.cs

@@ -0,0 +1,273 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Web.WebPages.Html;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Web.WebPages.Test
+{
+    public class CheckBoxTest
+    {
+        [Fact]
+        public void CheckboxWithEmptyNameThrows()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act and assert
+            Assert.ThrowsArgumentNullOrEmptyString(() => helper.CheckBox(null), "name");
+            Assert.ThrowsArgumentNullOrEmptyString(() => helper.CheckBox(String.Empty), "name");
+        }
+
+        [Fact]
+        public void CheckboxWithDefaultArguments()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.CheckBox("foo");
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckboxWithObjectAttributes()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.CheckBox("foo", new { attr = "attr-value" });
+
+            // Assert
+            Assert.Equal(@"<input attr=""attr-value"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckboxWithDictionaryAttributes()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.CheckBox("foo", new Dictionary<string, object> { { "attr", "attr-value" } });
+
+            // Assert
+            Assert.Equal(@"<input attr=""attr-value"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckboxWithExplicitChecked()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.CheckBox("foo", true);
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckboxWithModelValue()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", true);
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.CheckBox("foo");
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckboxWithNonBooleanModelValue()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", Boolean.TrueString);
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.CheckBox("foo");
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+
+            modelState.SetModelValue("foo", new object());
+            helper = HtmlHelperFactory.Create(modelState);
+
+            // Act and Assert
+            Assert.Throws<InvalidOperationException>(() => helper.CheckBox("foo"),
+                                                              "The parameter conversion from type \"System.Object\" to type \"System.Boolean\" failed because no " +
+                                                              "type converter can convert between these types.");
+        }
+
+        [Fact]
+        public void CheckboxWithModelAndExplictValue()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", false);
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.CheckBox("foo", true);
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+
+            modelState.SetModelValue("foo", true);
+
+            // Act
+            html = helper.CheckBox("foo", false);
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckBoxWithCheckedHtmlAttribute()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.CheckBox("foo", new { @checked = "checked" });
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckBoxWithExplicitCheckedOverwritesHtmlAttribute()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.CheckBox("foo", false, new { @checked = "checked" });
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckBoxWithModelStateCheckedOverwritesHtmlAttribute()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", false);
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.CheckBox("foo", false, new { @checked = "checked" });
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckBoxWithError()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", false);
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.CheckBox("foo", true);
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckBoxWithErrorAndCustomCss()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.AddError("foo", "error");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.CheckBox("foo", true, new { @class = "my-class" });
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" class=""input-validation-error my-class"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        //[Fact]
+        // Can't test as it sets a static property
+        // Review: Need to redo test once we fix set once property
+        public void CheckBoxUsesCustomErrorClass()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.AddError("foo", "error");
+            HtmlHelper.ValidationInputCssClassName = "my-error-class";
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.CheckBox("foo", true, new { @class = "my-class" });
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" class=""my-error-class my-class"" id=""foo"" name=""foo"" type=""checkbox"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckBoxOverwritesImplicitAttributes()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.CheckBox("foo", true, new { type = "fooType", name = "bar" });
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""fooType"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void CheckboxAddsUnobtrusiveValidationAttributes()
+        {
+            // Arrange
+            const string fieldName = "name";
+            var modelStateDictionary = new ModelStateDictionary();
+            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
+            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);
+
+            // Act
+            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
+            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
+            var html = helper.CheckBox(fieldName, new Dictionary<string, object> { { "data-some-val", "5" } });
+
+            // Assert
+            Assert.Equal(@"<input data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" type=""checkbox"" />",
+                         html.ToString());
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Html/HtmlHelperFactory.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Web.WebPages.Html;
+using Moq;
+
+namespace System.Web.WebPages.Test
+{
+    public static class HtmlHelperFactory
+    {
+        internal static HtmlHelper Create(ModelStateDictionary modelStateDictionary = null, ValidationHelper validationHelper = null)
+        {
+            modelStateDictionary = modelStateDictionary ?? new ModelStateDictionary();
+            var httpContext = new Mock<HttpContextBase>();
+            validationHelper = validationHelper ?? new ValidationHelper(httpContext.Object, modelStateDictionary);
+            return new HtmlHelper(modelStateDictionary, validationHelper);
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Html/HtmlHelperTest.cs

@@ -0,0 +1,161 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Web.WebPages.Html;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Web.WebPages.Test
+{
+    public class HtmlHelperTest
+    {
+        [Fact]
+        public void ValidationInputCssClassNameThrowsWhenAssignedNull()
+        {
+            // Act and Assert
+            Assert.ThrowsArgumentNull(() => HtmlHelper.ValidationInputCssClassName = null, "value");
+        }
+
+        [Fact]
+        public void ValidationSummaryClassNameThrowsWhenAssignedNull()
+        {
+            // Act and Assert
+            Assert.ThrowsArgumentNull(() => HtmlHelper.ValidationSummaryClass = null, "value");
+        }
+
+        [Fact]
+        public void EncodeObject()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+            object text = "<br />" as object;
+
+            // Act
+            string encodedHtml = htmlHelper.Encode(text);
+
+            // Assert
+            Assert.Equal(encodedHtml, "&lt;br /&gt;");
+        }
+
+        [Fact]
+        public void EncodeObjectNull()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+            object text = null;
+
+            // Act
+            string encodedHtml = htmlHelper.Encode(text);
+
+            // Assert
+            Assert.Equal(String.Empty, encodedHtml);
+        }
+
+        [Fact]
+        public void EncodeString()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+            var text = "<br />";
+
+            // Act
+            string encodedHtml = htmlHelper.Encode(text);
+
+            // Assert
+            Assert.Equal(encodedHtml, "&lt;br /&gt;");
+        }
+
+        [Fact]
+        public void EncodeStringNull()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+            string text = null;
+
+            // Act
+            string encodedHtml = htmlHelper.Encode(text);
+
+            // Assert
+            Assert.Equal("", encodedHtml);
+        }
+
+        [Fact]
+        public void RawAllowsNullValue()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+
+            // Act
+            IHtmlString markupHtml = htmlHelper.Raw(null);
+
+            // Assert
+            Assert.Equal(null, markupHtml.ToString());
+            Assert.Equal(null, markupHtml.ToHtmlString());
+        }
+
+        [Fact]
+        public void RawAllowsNullObjectValue()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+
+            // Act
+            IHtmlString markupHtml = htmlHelper.Raw((object)null);
+
+            // Assert
+            Assert.Equal(null, markupHtml.ToString());
+            Assert.Equal(null, markupHtml.ToHtmlString());
+        }
+
+        [Fact]
+        public void RawAllowsEmptyValue()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+
+            // Act
+            IHtmlString markupHtml = htmlHelper.Raw("");
+
+            // Assert
+            Assert.Equal("", markupHtml.ToString());
+            Assert.Equal("", markupHtml.ToHtmlString());
+        }
+
+        [Fact]
+        public void RawReturnsWrapperMarkup()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+            string markup = "<b>bold</b>";
+
+            // Act
+            IHtmlString markupHtml = htmlHelper.Raw(markup);
+
+            // Assert
+            Assert.Equal("<b>bold</b>", markupHtml.ToString());
+            Assert.Equal("<b>bold</b>", markupHtml.ToHtmlString());
+        }
+
+        [Fact]
+        public void RawReturnsWrapperMarkupOfObject()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+            ObjectWithWrapperMarkup obj = new ObjectWithWrapperMarkup();
+
+            // Act
+            IHtmlString markupHtml = htmlHelper.Raw(obj);
+
+            // Assert
+            Assert.Equal("<b>boldFromObject</b>", markupHtml.ToString());
+            Assert.Equal("<b>boldFromObject</b>", markupHtml.ToHtmlString());
+        }
+
+        private class ObjectWithWrapperMarkup
+        {
+            public override string ToString()
+            {
+                return "<b>boldFromObject</b>";
+            }
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Html/RadioButtonTest.cs

@@ -0,0 +1,199 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Web.WebPages.Html;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Web.WebPages.Test
+{
+    public class RadioButtonTest
+    {
+        [Fact]
+        public void RadioButtonWithEmptyNameThrows()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act and assert
+            Assert.ThrowsArgumentNullOrEmptyString(() => helper.RadioButton(null, null), "name");
+            Assert.ThrowsArgumentNullOrEmptyString(() => helper.RadioButton(String.Empty, null), "name");
+        }
+
+        [Fact]
+        public void RadioButtonWithDefaultArguments()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.RadioButton("foo", "bar", true);
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
+                         html.ToHtmlString());
+
+            html = helper.RadioButton("foo", "bar", false);
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonWithObjectAttributes()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.RadioButton("foo", "bar", new { attr = "attr-value" });
+
+            // Assert
+            Assert.Equal(@"<input attr=""attr-value"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonWithDictionaryAttributes()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.RadioButton("foo", "bar", new Dictionary<string, object> { { "attr", "attr-value" } });
+
+            // Assert
+            Assert.Equal(@"<input attr=""attr-value"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonUsesModelStateToAssignChecked()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", "bar");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.RadioButton("foo", "bar");
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonUsesModelStateToRemoveChecked()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", "not-a-bar");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.RadioButton("foo", "bar", new { @checked = "checked" });
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonWithoutModelStateDoesNotAffectChecked()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.RadioButton("foo", "bar", new { @checked = "checked" });
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonWithNonStringModelValue()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", new List<double>());
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.RadioButton("foo", "bar");
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonWithNonStringValue()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", "bar");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.RadioButton("foo", 2.53);
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""2.53"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonWithExplicitChecked()
+        {
+            // Arrange
+            var modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", "bar");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.RadioButton("foo", "not-bar", true);
+
+            // Assert
+            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""not-bar"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonOverwritesImplicitAttributes()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.RadioButton("foo", "foo-value", new { value = "bazValue", type = "fooType", name = "bar" });
+
+            // Assert
+            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""fooType"" value=""foo-value"" />",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void RadioButtonAddsUnobtrusiveValidationAttributes()
+        {
+            // Arrange
+            const string fieldName = "name";
+            var modelStateDictionary = new ModelStateDictionary();
+            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
+            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);
+
+            // Act
+            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
+            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
+            var html = helper.RadioButton(fieldName, value: 8, htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });
+
+            // Assert
+            Assert.Equal(@"<input data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" type=""radio"" value=""8"" />",
+                         html.ToString());
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Html/TextAreaHelperTest.cs

@@ -0,0 +1,211 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Web.WebPages.Html;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Web.WebPages.Test
+{
+    public class TextAreaExtensionsTest
+    {
+        [Fact]
+        public void TextAreaWithEmptyNameThrows()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act and assert
+            Assert.ThrowsArgument(() => helper.TextArea(null), "name", "Value cannot be null or an empty string.");
+
+            // Act and assert
+            Assert.ThrowsArgument(() => helper.TextArea(String.Empty), "name", "Value cannot be null or an empty string.");
+        }
+
+        [Fact]
+        public void TextAreaWithDefaultRowsAndCols()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.TextArea("foo");
+
+            // Assert
+            Assert.Equal(@"<textarea cols=""20"" id=""foo"" name=""foo"" rows=""2""></textarea>", html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithZeroRowsAndColumns()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.TextArea("foo", null, 0, 0, null);
+
+            // Assert
+            Assert.Equal(@"<textarea id=""foo"" name=""foo""></textarea>", html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithNonZeroRowsAndColumns()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = helper.TextArea("foo", null, 4, 10, null);
+
+            // Assert
+            Assert.Equal(@"<textarea cols=""10"" id=""foo"" name=""foo"" rows=""4""></textarea>", html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithObjectAttributes()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", "foo-value");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.TextArea("foo", new { attr = "value", cols = 6 });
+
+            // Assert
+            Assert.Equal(@"<textarea attr=""value"" cols=""6"" id=""foo"" name=""foo"" rows=""2"">foo-value</textarea>", html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithExplicitValue()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", "explicit-foo-value");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.TextArea("foo", "explicit-foo-value", new { attr = "attr-value", cols = 6 });
+
+            // Assert
+            Assert.Equal(@"<textarea attr=""attr-value"" cols=""6"" id=""foo"" name=""foo"" rows=""2"">explicit-foo-value</textarea>",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithDictionaryAttributes()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", "explicit-foo-value");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+            var attributes = new Dictionary<string, object>() { { "attr", "attr-val" }, { "rows", 15 }, { "cols", 12 } };
+            // Act
+            var html = helper.TextArea("foo", attributes);
+
+            // Assert
+            Assert.Equal(@"<textarea attr=""attr-val"" cols=""12"" id=""foo"" name=""foo"" rows=""15"">explicit-foo-value</textarea>",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithNoValueAndObjectAttributes()
+        {
+            // Arrange
+            HtmlHelper helper = HtmlHelperFactory.Create();
+            var attributes = new Dictionary<string, object>() { { "attr", "attr-val" }, { "rows", 15 }, { "cols", 12 } };
+            // Act
+            var html = helper.TextArea("foo", attributes);
+
+            // Assert
+            Assert.Equal(@"<textarea attr=""attr-val"" cols=""12"" id=""foo"" name=""foo"" rows=""15""></textarea>",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithNullValue()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.SetModelValue("foo", "explicit-foo-value");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+            var attributes = new Dictionary<string, object>() { { "attr", "attr-val" }, { "rows", 15 }, { "cols", 12 } };
+            // Act
+            var html = helper.TextArea("foo", null, attributes);
+
+            // Assert
+            Assert.Equal(@"<textarea attr=""attr-val"" cols=""12"" id=""foo"" name=""foo"" rows=""15"">explicit-foo-value</textarea>",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithError()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.AddError("foo", "some error");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.TextArea("foo", String.Empty);
+
+            // Assert
+            Assert.Equal(@"<textarea class=""input-validation-error"" cols=""20"" id=""foo"" name=""foo"" rows=""2""></textarea>",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaWithErrorAndCustomCssClass()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.AddError("foo", "some error");
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.TextArea("foo", String.Empty, new { @class = "my-css" });
+
+            // Assert
+            Assert.Equal(@"<textarea class=""input-validation-error my-css"" cols=""20"" id=""foo"" name=""foo"" rows=""2""></textarea>",
+                         html.ToHtmlString());
+        }
+
+        // [Fact]
+        // Cant test this in multi-threaded
+        public void TextAreaWithCustomErrorClass()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.AddError("foo", "some error");
+            HtmlHelper.ValidationInputCssClassName = "custom-input-validation-error";
+            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = helper.TextArea("foo", String.Empty, new { @class = "my-css" });
+
+            // Assert
+            Assert.Equal(@"<textarea class=""custom-input-validation-error my-css"" cols=""20"" id=""foo"" name=""foo"" rows=""2""></textarea>",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void TextAreaAddsUnobtrusiveValidationAttributes()
+        {
+            // Arrange
+            const string fieldName = "name";
+            var modelStateDictionary = new ModelStateDictionary();
+            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
+            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);
+
+            // Act
+            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
+            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
+            var html = helper.TextArea(fieldName, htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });
+
+            // Assert
+            Assert.Equal(@"<textarea cols=""20"" data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" rows=""2""></textarea>",
+                         html.ToString());
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.WebPages.Test/Html/ValidationHelperTest.cs

@@ -0,0 +1,344 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Web.WebPages.Html;
+using Xunit;
+
+namespace System.Web.WebPages.Test
+{
+    public class ValidationHelperTest
+    {
+        [Fact]
+        public void ValidationMessageAllowsEmptyModelName()
+        {
+            // Arrange
+            ModelStateDictionary dictionary = new ModelStateDictionary();
+            dictionary.AddError("test", "some error text");
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(dictionary);
+
+            // Act 
+            var html = htmlHelper.ValidationMessage("test");
+
+            // Assert
+            Assert.Equal(@"<span class=""field-validation-error"" data-valmsg-for=""test"" data-valmsg-replace=""true"">some error text</span>", html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationMessageReturnsFirstError()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act 
+            var html = htmlHelper.ValidationMessage("foo");
+
+            // Assert
+            Assert.Equal(@"<span class=""field-validation-error"" data-valmsg-for=""foo"" data-valmsg-replace=""true"">foo error &lt;1&gt;</span>", html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationMessageUsesValidCssClassIfFieldDoesNotHaveErrors()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationMessage("baz");
+
+            // Assert
+            Assert.Equal(@"<span class=""field-validation-valid"" data-valmsg-for=""baz"" data-valmsg-replace=""true""></span>", html.ToString());
+        }
+
+        [Fact]
+        public void ValidationMessageReturnsWithObjectAttributes()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationMessage("foo", new { attr = "attr-value" });
+
+            // Assert
+            Assert.Equal(@"<span attr=""attr-value"" class=""field-validation-error"" data-valmsg-for=""foo"" data-valmsg-replace=""true"">foo error &lt;1&gt;</span>",
+                         html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationMessageReturnsWithCustomMessage()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Atc
+            var html = htmlHelper.ValidationMessage("foo", "bar error");
+
+            // Assert
+            Assert.Equal(@"<span class=""field-validation-error"" data-valmsg-for=""foo"" data-valmsg-replace=""false"">bar error</span>", html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationMessageReturnsWithCustomMessageAndObjectAttributes()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationMessage("foo", "bar error", new { baz = "baz" });
+
+            // Assert
+            Assert.Equal(@"<span baz=""baz"" class=""field-validation-error"" data-valmsg-for=""foo"" data-valmsg-replace=""false"">bar error</span>", html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationMessageWithModelStateAndNoErrors()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationMessage("baz");
+
+            // Assert
+            Assert.Equal(@"<span class=""field-validation-valid"" data-valmsg-for=""baz"" data-valmsg-replace=""true""></span>", html.ToString());
+        }
+
+        [Fact]
+        public void ValidationSummary()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationSummary();
+
+            // Assert
+            Assert.Equal(@"<div class=""validation-summary-errors"" data-valmsg-summary=""true""><ul>
+<li>foo error &lt;1&gt;</li>
+<li>foo error &lt;2&gt;</li>
+<li>bar error &lt;1&gt;</li>
+<li>bar error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationSummaryWithMessage()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationSummary("test message");
+
+            // Assert
+            Assert.Equal(@"<div class=""validation-summary-errors"" data-valmsg-summary=""true""><span>test message</span>
+<ul>
+<li>foo error &lt;1&gt;</li>
+<li>foo error &lt;2&gt;</li>
+<li>bar error &lt;1&gt;</li>
+<li>bar error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationSummaryWithFormErrors()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithFormErrors());
+
+            // Act
+            var html = htmlHelper.ValidationSummary();
+
+            // Assert
+            Assert.Equal(@"<div class=""validation-summary-errors"" data-valmsg-summary=""true""><ul>
+<li>foo error &lt;1&gt;</li>
+<li>foo error &lt;2&gt;</li>
+<li>bar error &lt;1&gt;</li>
+<li>bar error &lt;2&gt;</li>
+<li>some form error &lt;1&gt;</li>
+<li>some form error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationSummaryWithFormErrorsAndExcludeFieldErrors()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithFormErrors());
+
+            // Act
+            var html = htmlHelper.ValidationSummary(excludeFieldErrors: true);
+
+            // Assert
+            Assert.Equal(@"<div class=""validation-summary-errors""><ul>
+<li>some form error &lt;1&gt;</li>
+<li>some form error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationSummaryWithObjectProperties()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationSummary(new { attr = "attr-value", @class = "my-class" });
+
+            // Assert
+            Assert.Equal(@"<div attr=""attr-value"" class=""validation-summary-errors my-class"" data-valmsg-summary=""true""><ul>
+<li>foo error &lt;1&gt;</li>
+<li>foo error &lt;2&gt;</li>
+<li>bar error &lt;1&gt;</li>
+<li>bar error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationSummaryWithDictionary()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationSummary(new Dictionary<string, object> { { "attr", "attr-value" }, { "class", "my-class" } });
+
+            // Assert
+            Assert.Equal(@"<div attr=""attr-value"" class=""validation-summary-errors my-class"" data-valmsg-summary=""true""><ul>
+<li>foo error &lt;1&gt;</li>
+<li>foo error &lt;2&gt;</li>
+<li>bar error &lt;1&gt;</li>
+<li>bar error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationSummaryWithDictionaryAndMessage()
+        {
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationSummary("This is a message.", new Dictionary<string, object> { { "attr", "attr-value" }, { "class", "my-class" } });
+
+            // Assert
+            Assert.Equal(@"<div attr=""attr-value"" class=""validation-summary-errors my-class"" data-valmsg-summary=""true""><span>This is a message.</span>
+<ul>
+<li>foo error &lt;1&gt;</li>
+<li>foo error &lt;2&gt;</li>
+<li>bar error &lt;1&gt;</li>
+<li>bar error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        //[Fact]
+        // Cant test this, as it sets a static property 
+        public void ValidationSummaryWithCustomValidationSummaryClass()
+        {
+            // Arrange
+            HtmlHelper.ValidationSummaryClass = "my-val-class";
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());
+
+            // Act
+            var html = htmlHelper.ValidationSummary("This is a message.", new Dictionary<string, object> { { "attr", "attr-value" }, { "class", "my-class" } });
+
+            // Assert
+            Assert.Equal(@"<div attr=""attr-value"" class=""my-val-class my-class""><span>This is a message.</span>
+<ul>
+<li>foo error &lt;1&gt;</li>
+<li>foo error &lt;2&gt;</li>
+<li>bar error &lt;1&gt;</li>
+<li>bar error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        [Fact]
+        public void ValidationSummaryWithNoErrorReturnsNullIfExcludeFieldErrorsIsSetToFalse()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = htmlHelper.ValidationSummary(excludeFieldErrors: false);
+
+            // Assert
+            Assert.Equal(@"<div class=""validation-summary-valid"" data-valmsg-summary=""true""><ul>
+</ul></div>", html.ToString());
+        }
+
+        [Fact]
+        public void ValidationSummaryWithNoErrorReturnsNull()
+        {
+            // Arrange
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
+
+            // Act
+            var html = htmlHelper.ValidationSummary(excludeFieldErrors: true);
+
+            // Assert
+            Assert.Null(html);
+        }
+
+        [Fact]
+        public void ValidationSummaryWithNoFormErrorsAndExcludedFieldErrorsReturnsNull()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.AddError("foo", "error");
+            modelState.AddError("bar", "error");
+
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = htmlHelper.ValidationSummary(excludeFieldErrors: true);
+
+            // Assert
+            Assert.Null(html);
+        }
+
+        [Fact]
+        public void ValidationSummaryWithMultipleFormErrorsAndExcludedFieldErrors()
+        {
+            // Arrange
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.AddFormError("error <1>");
+            modelState.AddFormError("error <2>");
+
+            HtmlHelper htmlHelper = HtmlHelperFactory.Create(modelState);
+
+            // Act
+            var html = htmlHelper.ValidationSummary(excludeFieldErrors: true);
+
+            // Assert
+            Assert.Equal(@"<div class=""validation-summary-errors""><ul>
+<li>error &lt;1&gt;</li>
+<li>error &lt;2&gt;</li>
+</ul></div>"
+                         , html.ToHtmlString());
+        }
+
+        private static ModelStateDictionary GetModelStateWithErrors()
+        {
+            ModelStateDictionary modelState = new ModelStateDictionary();
+            modelState.AddError("foo", "foo error <1>");
+            modelState.AddError("foo", "foo error <2>");
+            modelState.AddError("bar", "bar error <1>");
+            modelState.AddError("bar", "bar error <2>");
+            return modelState;
+        }
+
+        private static ModelStateDictionary GetModelStateWithFormErrors()
+        {
+            ModelStateDictionary modelState = GetModelStateWithErrors();
+            modelState.AddFormError("some form error <1>");
+            modelState.AddFormError("some form error <2>");
+            return modelState;
+        }
+    }
+}