public void Add_ParamsHtmlObject_Empty()
 {
     HtmlElement element = new HtmlElement("parent");
     element.Add(new HtmlObject[0]);
     Assert.Empty(element.Elements());
     Assert.Empty(element.Attributes());
 }

        public IHtmlNode Create(GridPagerData section)
        {
            var span = new HtmlElement("span")
                .AddClass("k-pager-sizes", "k-label");

            var select = new HtmlElement("select")
                .AppendTo(span);

            foreach (var pageSize in section.PageSizes)
            {
                var pageSizeText = pageSize.ToString().ToLowerInvariant();
                var pageSizeValue = pageSizeText;

                if (pageSizeText == "all")
                {
                    pageSizeText = section.Messages.AllPages;
                }

                new HtmlElement("option").Attribute("value", pageSizeValue).Text(pageSizeText).AppendTo(select);
            }

            new LiteralNode(section.Messages.ItemsPerPage).AppendTo(span);

            return span;
        }

        public void Add_HtmlObject(bool isVoid)
        {
            HtmlElement parent = new HtmlElement("parent", isVoid);

            // Atribute
            HtmlAttribute attribute = new HtmlAttribute("attribute");
            parent.Add(attribute);
            Assert.Equal(parent, attribute.Parent);
            Assert.Equal(new HtmlAttribute[] { attribute }, parent.Attributes());

            if (!isVoid)
            {
                // Element
                HtmlElement element = new HtmlElement("element");
                parent.Add(element);
                Assert.Equal(parent, element.Parent);
                Assert.Equal(new HtmlElement[] { element }, parent.Elements());

                // Nodes
                HtmlComment comment = new HtmlComment("comment");
                parent.Add(comment);
                Assert.Equal(parent, comment.Parent);
                Assert.Equal(new HtmlObject[] { element, comment }, parent.Nodes());
            }
        }

        public TabStripRenderingTests()
        {
            Mock<TextWriter> textWriter = new Mock<TextWriter>();
            Mock<HtmlTextWriter> writer = new Mock<HtmlTextWriter>(textWriter.Object);

            builder = new Mock<ITabStripHtmlBuilder>();
            builder.Setup(r => r.TabStripTag()).Returns(() =>
            {
                IHtmlNode result = new HtmlElement("div");

                new HtmlElement("ul").AppendTo(result);

                return result;
            });
            builder.Setup(r => r.ItemTag(It.IsAny<TabStripItem>())).Returns(() => new HtmlElement("li"));
            builder.Setup(r => r.ItemContentTag(It.IsAny<TabStripItem>())).Returns(() => new HtmlElement("div"));
            builder.Setup(r => r.ItemInnerTag(It.IsAny<TabStripItem>())).Returns(() => new HtmlElement("a"));

            tabStrip = TabStripTestHelper.CreateTabStrip(writer.Object, builder.Object);
            tabStrip.Name = "TabStrip1";

            tabStrip.Items.Add(new TabStripItem { Text = "TabStripItem1", RouteName = "ProductList" });
            tabStrip.Items.Add(new TabStripItem { Text = "TabStripItem2", RouteName = "ProductList" });
            tabStrip.Items.Add(new TabStripItem { Text = "TabStripItem3", RouteName = "ProductList" });
        }

        public static UserErrorTypes Parse(HtmlElement root)
        {
            var content = root.FindFirst("div", (e) => e.Attributes["class"] == "tip-content");
            
            if (content == null)
                throw new InvalidDataException();
            else
            {
                var divs = content.Descendants("div");
                string msg = null;
                var errType = UserErrorTypes.ErrorWithMsg;
                int count = divs.Count();
                if (count == 1)
                {
                    var span = divs.First().Element();
                    if (span != null)
                        msg = span.InnerHtml;
                }
                else if (count >1)
                {
                    msg = divs.ElementAt(1).PlainText();
                }

                if (msg.Contains("您没有权限"))
                    errType = UserErrorTypes.NotAuthorized;
                else if (msg.Contains("网站已经关闭"))
                    errType = UserErrorTypes.SiteClosed;
                if (msg != null)
                    throw new S1UserException(msg, errType);
            }
            return UserErrorTypes.Unknown;
        }

        public IHtmlNode Create(GridPagerData section)
        {
            var div = new HtmlElement("div")
                .AddClass("t-page-size");

            var dropDown = new HtmlElement("div")
                .AddClass("t-dropdown", "t-header")
                .Css("width","50px")
                .AppendTo(div);

            var wrapper = new HtmlElement("div")
                .AddClass("t-dropdown-wrap", "t-state-default")
                .AppendTo(dropDown);

            new HtmlElement("span")
                .AddClass("t-input")
                .Text(section.PageSize.ToString())
                .AppendTo(wrapper);

            var select = new HtmlElement("span")
                .AddClass("t-select").AppendTo(wrapper);

            new HtmlElement("span")
                .AddClass("t-icon", "t-arrow-down")
                .Text("select")
                .AppendTo(select);

            return div;
        }

        public void NonVoidElement_InnerText_NoChildren()
        {
            HtmlElement expected = new HtmlElement("div")
                .WithInnerText("InnerText");

            Parse(expected, "<div>InnerText</div>");
        }

        public void ReplaceAll_NullContent_ThrowsArgumentNullException()
        {
            HtmlElement parent = new HtmlElement("parent");

            Assert.Throws<ArgumentNullException>("content", () => parent.ReplaceAll(null));
            Assert.Throws<ArgumentNullException>("content", () => parent.ReplaceAll((IEnumerable<HtmlObject>)null));
        }

        public void NonVoidElement_NoInnerText_OneNonVoidChild()
        {
            HtmlElement expected = new HtmlElement("div")
                .WithChild(new HtmlElement("p"));

            Parse(expected, "<div><p></p></div>");
        }

 public static void SerializeIgnoringFormatting(HtmlElement element, string expected)
 {
     expected = expected.Replace("\r\n", "\n").Replace("\n", Environment.NewLine);
     Assert.Equal(expected, element.ToString());
     Assert.Equal(expected, element.Serialize());
     Assert.Equal(expected.Replace(Environment.NewLine, ""), element.Serialize(HtmlSerializeOptions.NoFormatting));
 }

        public IHtmlNode CreateTextbox()
        {
            var content = new HtmlElement("input")
                .Attribute("id", textbox.Id);

            return content;
        }

        protected override IHtmlNode BuildCore()
        {
            var root = CreateEditor();

            var toolbarRow = new HtmlElement("tr").AppendTo(root);

            if (editor.DefaultToolGroup.Tools.Any())
            {
                CreateToolBar().AppendTo(new HtmlElement("td").AddClass("t-editor-toolbar-wrap").AppendTo(toolbarRow));
            }

            var editableCell = new HtmlElement("td")
                .AddClass("t-editable-area")
                .ToggleClass("input-validation-error", !editor.IsValid())
                .AppendTo(new HtmlElement("tr").AppendTo(root));

            var textarea = CreateTextArea();
            textarea.AppendTo(editableCell);

            var script = new HtmlElement("script")
                            .Attribute("type", "text/javascript")
                            .Html("document.getElementById('" + textarea.Attribute("id") + "').style.display='none'");

            script.AppendTo(editableCell);

            return root;
        }

        public IHtmlNode CellTag(DateTime currentDay, DateTime? selectedDate, string urlFormat, bool isOtherMonth)
        {
            IHtmlNode cell = new HtmlElement("td");

            if (isOtherMonth)
            {
                cell.AddClass("t-other-month");
            }
            else if (selectedDate.HasValue && IsInRange(selectedDate.Value) && currentDay.Day == selectedDate.Value.Day)
            {
                cell.AddClass(UIPrimitives.SelectedState);
            }

            if (IsInRange(currentDay))
            {
                var href = GetUrl(currentDay, urlFormat);

                IHtmlNode link = new HtmlElement("a")
                                 .AddClass(UIPrimitives.Link + (href != "#" ? " t-action-link" : string.Empty))
                                 .Attribute("href", href)
                                 .Attribute("title", currentDay.ToLongDateString())
                                 .Text(currentDay.Day.ToString());

                cell.Children.Add(link);
            }
            else
            {
                cell.Html(" ");
            }

            return cell;
        }

 public void ReplaceAll_ContentNotNodeOrAttribute_ThrowsArgumentException()
 {
     HtmlElement parent = new HtmlElement("parent");
     
     Assert.Throws<ArgumentException>("content", () => parent.ReplaceAll(new HtmlObject[] { new CustomHtmlObject() }));
     Assert.Throws<ArgumentException>("content", () => parent.ReplaceAll((IEnumerable<HtmlObject>)new HtmlObject[] { new CustomHtmlObject() }));
 }

        public void ReplaceAll_SameElementInContent_ThrowsInvalidOperationException()
        {
            HtmlElement parent = new HtmlElement("parent");

            Assert.Throws<InvalidOperationException>(() => parent.ReplaceAll(new HtmlObject[] { parent }));
            Assert.Throws<InvalidOperationException>(() => parent.ReplaceAll((IEnumerable<HtmlObject>)new HtmlObject[] { parent }));
        }

        public IHtmlNode CreateTextArea()
        {
            var content = new HtmlElement("textarea")
                            .Attributes(new
                            {
                                cols = "20",
                                rows = "5",
                                name = editor.Name,
                                id = editor.Id + "-value"
                            })
                            .Attributes(editor.GetUnobtrusiveValidationAttributes())
                            .PrependClass(UIPrimitives.Content, UIPrimitives.Editor.RawContent);

            var value = editor.GetValue<string>(editor.Value);

            if (!string.IsNullOrEmpty(value))
            {
                content.Text(value);
            }
            else if (editor.Content != null)
            {
                editor.Template.Apply(content);
            }
            else if (editor.Template.InlineTemplate != null)
            {
                content.Text(editor.Template.InlineTemplate(null).ToString());
            }

            return content;
        }

 public void Applying_when_html_is_set_sets_html_of_the_node()
 {
     var template = new HtmlTemplate<object>();
     template.Html = "<strong>foo</strong>";
     var node = new HtmlElement("div");
     template.Apply(null, node);
     Assert.Equal(template.Html, node.InnerHtml);
 }

        public void Apply(IHtmlNode parent)
        {
            var span = new HtmlElement("span");

            span.Attributes(button.ImageHtmlAttributes).AddClass(UIPrimitives.Icon, button.SpriteCssClass);

            span.AppendTo(parent);
        }

        public IHtmlNode Create(IGridUrlBuilder urlBuilder, int currentPage, int pageCount)
        {
            var numericDiv = new HtmlElement("div").AddClass("t-numeric");

            AppendContent(urlBuilder, numericDiv, pageCount, currentPage);

            return numericDiv;
        }

 public void Applying_when_code_block_is_set_sets_template_of_the_node()
 {
     var template = new HtmlTemplate<object>();
     template.CodeBlockTemplate = delegate { };
     var node = new HtmlElement("div");
     template.Apply(null, node);
     Assert.NotNull(node.Template());
 }