public void TestHtmlImplicitClosing()
{
var parser = new TestXmlParser(CreateRootState());
parser.Parse(@"
<html>
<body>
<li><li>$
<dt><img><dd>$</dd>
<tr><tr>$</tr></li>
<p>
<table>$</table>
<td><th><td>$
</body>
</html>
",
delegate {
parser.AssertPath("//html/body/li");
},
delegate {
parser.AssertPath("//html/body/li/dd");
},
delegate {
parser.AssertPath("//html/body/li/tr");
},
delegate {
parser.AssertPath("//html/body/table");
},
delegate {
parser.AssertPath("//html/body/td");
}
);
parser.AssertEmpty();
parser.AssertErrorCount(1);
}
public void TestAutoClosing ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"
<html>
<body>
<p><img>$
<p><div> $ </div>
<p>
<p><a href =""http://mono-project.com/"" ><b>foo $ </a>
<p>
<p>$
<div><div>$</div></div>
</body>
</html>
",
delegate {
parser.AssertPath ("//html/body/p");
},
delegate {
parser.AssertPath ("//html/body/div");
},
delegate {
parser.AssertPath ("//html/body/p/a/b");
},
delegate {
parser.AssertPath ("//html/body/p");
},
delegate {
parser.AssertPath ("//html/body/div/div");
}
);
parser.AssertEmpty ();
parser.AssertErrorCount (1);
}
public void TestHtmlImplicitClosing ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse(@"
<html>
<body>
<li><li>$
<dt><img><dd>$</dd>
<tr><tr>$</tr></li>
<p>
<table>$</table>
<td><th><td>$
</body>
</html>
",
delegate {
parser.AssertPath ("//html/body/li");
},
delegate {
parser.AssertPath ("//html/body/li/dd");
},
delegate {
parser.AssertPath ("//html/body/li/tr");
},
delegate {
parser.AssertPath ("//html/body/table");
},
delegate {
parser.AssertPath ("//html/body/td");
}
);
parser.AssertEmpty ();
parser.AssertErrorCount (1);
}
public void ValidateAndReturnXmlDocument_ExpectedXml_ShouldReturnXmlDocument(TestXmlParser service)
{
var validateAndReturnXmlDocument = service.ValidateAndReturnXmlDocument("<image/>");
validateAndReturnXmlDocument.Should().NotBeNull();
validateAndReturnXmlDocument.DocumentElement.Name.Should().Be("image");
}
public void GetAttributeShould_ValidAttribute_ReturnValue(TestXmlParser service)
{
var doc = new XmlDocument();
doc.LoadXml("<data expectedAttr='expectedValue'/>");
var attribute = service.GetAttribute(doc.DocumentElement, "expectedAttr");
attribute.Should().Be("expectedValue");
}
public void GetAttributeShouldReturn_NotExistentAttribute_EmptyString(TestXmlParser service)
{
var doc = new XmlDocument();
doc.LoadXml("<data/>");
var attribute = service.GetAttribute(doc.DocumentElement, "someRandomAttribute");
attribute.Should().BeNullOrEmpty();
}
public void GetAttributeShouldReturn_NotExistentAttribute_EmptyString(TestXmlParser service)
{
var doc = new XmlDocument();
doc.LoadXml("<data/>");
var attribute = service.GetAttribute(doc.DocumentElement, "someRandomAttribute");
attribute.Should().BeNullOrEmpty();
}
public void GetAttributeShould_ValidAttribute_ReturnValue(TestXmlParser service)
{
var doc = new XmlDocument();
doc.LoadXml("<data expectedAttr='expectedValue'/>");
var attribute = service.GetAttribute(doc.DocumentElement, "expectedAttr");
attribute.Should().Be("expectedValue");
}
public void Attributes ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"
<doc>
<tag.a name=""foo"" arg=5 wibble = 6 bar.baz = 'y.ff7]' $ />
</doc>
",
delegate {
parser.AssertStateIs<XmlTagState> ();
parser.AssertAttributes ("name", "foo", "arg", "5", "wibble", "6", "bar.baz", "y.ff7]");
}
);
parser.AssertEmpty ();
parser.AssertErrorCount (0);
}
public void Directives ()
{
var parser = new TestXmlParser (CreateRootState (), true);
parser.Parse (@"<%@ Page Language=""C#"" Inherits=""SomeGenericType<int>"" %>");
parser.AssertNoErrors ();
var doc = (XDocument) parser.Nodes.Peek ();
var directive = doc.Nodes.First () as WebFormsDirective;
Assert.NotNull (directive);
Assert.AreEqual ("Page", directive.Name.FullName);
Assert.AreEqual (2, directive.Attributes.Count ());
var att = directive.Attributes[0];
Assert.AreEqual ("Language", att.Name.FullName);
Assert.AreEqual ("C#", att.Value);
att = directive.Attributes[1];
Assert.AreEqual ("Inherits", att.Name.FullName);
Assert.AreEqual ("SomeGenericType<int>", att.Value);
}
public void AttributeName ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"
<doc>
<tag.a>
<tag.b id=""$foo"" />
</tag.a>
</doc>
",
delegate {
parser.AssertStateIs<XmlAttributeValueState> ();
parser.AssertPath ("//doc/tag.a/tag.b/@id");
}
);
parser.AssertEmpty ();
parser.AssertErrorCount (0);
}
public void Directives()
{
var parser = new TestXmlParser(CreateRootState(), true);
parser.Parse(@"<%@ Page Language=""C#"" Inherits=""SomeGenericType<int>"" %>");
parser.AssertNoErrors();
var doc = (XDocument)parser.Nodes.Peek();
var directive = doc.Nodes.First() as WebFormsDirective;
Assert.NotNull(directive);
Assert.AreEqual("Page", directive.Name.FullName);
Assert.AreEqual(2, directive.Attributes.Count());
var att = directive.Attributes[0];
Assert.AreEqual("Language", att.Name.FullName);
Assert.AreEqual("C#", att.Value);
att = directive.Attributes[1];
Assert.AreEqual("Inherits", att.Name.FullName);
Assert.AreEqual("SomeGenericType<int>", att.Value);
}
public void AttributeWithExpression ()
{
var parser = new TestXmlParser (CreateRootState (), true);
parser.Parse (@"<tag
foo='<%=5$%>'
bar=""<%$$5$%><%--$--%>""
baz='<%#5$%>=<%:fhfjhf %0 $%>'
quux = <% 5 $%> />", delegate {
parser.AssertNodeIs<WebFormsRenderExpression> ();
}, delegate {
parser.AssertNodeIs<WebFormsResourceExpression> ();
}, delegate {
parser.AssertNodeIs<WebFormsServerComment> ();
}, delegate {
parser.AssertNodeIs<WebFormsBindingExpression> ();
}, delegate {
parser.AssertNodeIs<WebFormsHtmlEncodedExpression> ();
}, delegate {
parser.AssertNodeIs<WebFormsRenderBlock> ();
});
parser.AssertNoErrors ();
}
public void AttributeWithExpression()
{
var parser = new TestXmlParser(CreateRootState(), true);
parser.Parse(@"<tag
foo='<%=5$%>'
bar=""<%$$5$%><%--$--%>""
baz='<%#5$%>=<%:fhfjhf %0 $%>'
quux = <% 5 $%> />", delegate {
parser.AssertNodeIs <WebFormsRenderExpression> ();
}, delegate {
parser.AssertNodeIs <WebFormsResourceExpression> ();
}, delegate {
parser.AssertNodeIs <WebFormsServerComment> ();
}, delegate {
parser.AssertNodeIs <WebFormsBindingExpression> ();
}, delegate {
parser.AssertNodeIs <WebFormsHtmlEncodedExpression> ();
}, delegate {
parser.AssertNodeIs <WebFormsRenderBlock> ();
});
parser.AssertNoErrors();
}
public void TestAutoClosing()
{
var parser = new TestXmlParser(CreateRootState());
parser.Parse(@"
<html>
<body>
<p><img>$
<p><div> $ </div>
<p>
<p><a href =""http://mono-project.com/"" ><b>foo $ </a>
<p>
<p>$
<div><div>$</div></div>
</body>
</html>
",
delegate {
parser.AssertPath("//html/body/p");
},
delegate {
parser.AssertPath("//html/body/div");
},
delegate {
parser.AssertPath("//html/body/p/a/b");
},
delegate {
parser.AssertPath("//html/body/p");
},
delegate {
parser.AssertPath("//html/body/div/div");
}
);
parser.AssertEmpty();
parser.AssertErrorCount(1);
}
public void IncompleteTags ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"
<doc>
<tag.a att1 >
<tag.b att2="" >
<tag.c att3 = '
<tag.d att4 = >
<tag.e att5='' att6=' att7 = >
<tag.f id='$foo' />
</tag.e>
</tag.d>
</tag.c>
</tag.b>
</tag.a>
</doc>
",
delegate {
parser.AssertStateIs<XmlAttributeValueState> ();
parser.AssertNodeDepth (9);
parser.AssertPath ("//doc/tag.a/tag.b/tag.c/tag.d/tag.e/tag.f/@id");
}
);
parser.AssertEmpty ();
parser.AssertErrorCount (5, x => x.ErrorType == ErrorType.Error);
}
public void ValidateAndReturnXmlDocument_EmptyString_ShouldReturnNull(TestXmlParser service)
{
service.ValidateAndReturnXmlDocument(string.Empty).Should().BeNull();
}
public void ValidateAndReturnXmlDocument_NotExpectedXml_ShouldThrowException(TestXmlParser service)
{
Action a = () => service.ValidateAndReturnXmlDocument("<data/>");
a.ShouldThrow <ArgumentException>().WithMessage("Xml is not a valid image");
}
public void Init ()
{
parser = new TestXmlParser (new RazorTestFreeState ());
}
public void Misc ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"
<doc>
<!DOCTYPE $ >
<![CDATA[ ] $ ] ]]>
<!-- <foo> <bar arg=""> $ -->
</doc>
",
delegate {
parser.AssertStateIs<XmlDocTypeState> ();
parser.AssertNodeDepth (3);
parser.AssertPath ("//doc/<!DOCTYPE>");
},
delegate {
parser.AssertStateIs<XmlCDataState> ();
parser.AssertNodeDepth (3);
parser.AssertPath ("//doc/<![CDATA[ ]]>");
},
delegate {
parser.AssertStateIs<XmlCommentState> ();
parser.AssertNodeDepth (3);
parser.AssertPath ("//doc/<!-- -->");
}
);
parser.AssertEmpty ();
parser.AssertErrorCount (0);
}
public void ValidateAndReturnXmlDocument_NotExpectedXml_ShouldThrowException(TestXmlParser service)
{
Action a = () => service.ValidateAndReturnXmlDocument("<data/>");
a.ShouldThrow<ArgumentException>().WithMessage("Xml is not a valid image");
}
public void ValidateAndReturnXmlDocument_ExpectedXml_ShouldReturnXmlDocument(TestXmlParser service)
{
var validateAndReturnXmlDocument = service.ValidateAndReturnXmlDocument("<image/>");
validateAndReturnXmlDocument.Should().NotBeNull();
validateAndReturnXmlDocument.DocumentElement.Name.Should().Be("image");
}
public void BadClosingTag ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"<doc><x><abc></ab c><cd></cd></x></doc>");
parser.AssertEmpty ();
parser.AssertErrorCount (2);
}
public void ValidateAndReturnXmlDocument_EmptyString_ShouldReturnNull(TestXmlParser service)
{
service.ValidateAndReturnXmlDocument(string.Empty).Should().BeNull();
}
public void Init()
{
parser = new TestXmlParser(new RazorTestFreeState());
}
public void AttributeRecovery ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"
<doc>
<tag.a>
<tag.b arg='fff' sdd = sdsds= 'foo' ff = 5 $ />
</tag.a>
<a><b valid/></a>
</doc>
",
delegate {
parser.AssertStateIs<XmlTagState> ();
parser.AssertAttributes ("arg", "fff", "sdd", "sdsds", "ff", "5");
parser.AssertErrorCount (3);
}
);
parser.AssertEmpty ();
parser.AssertErrorCount (4);
}
public void Unclosed ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"
<doc>
<tag.a>
<tag.b><tag.b>$
</tag.a>$
</doc>
",
delegate {
parser.AssertStateIs<XmlRootState> ();
parser.AssertNodeDepth (5);
parser.AssertPath ("//doc/tag.a/tag.b/tag.b");
},
delegate {
parser.AssertStateIs<XmlRootState> ();
parser.AssertNodeDepth (2);
parser.AssertPath ("//doc");
}
);
parser.AssertEmpty ();
parser.AssertErrorCount (2);
}
public void DocTypeCapture ()
{
var parser = new TestXmlParser (CreateRootState (), true);
parser.Parse (@"
<!DOCTYPE html PUBLIC ""-//W3C//DTD XHTML 1.0 Strict//EN""
""DTD/xhtml1-strict.dtd""
[
<!-- foo -->
<!bar #baz>
]>
<doc><foo/></doc>");
parser.AssertEmpty ();
XDocument doc = (XDocument)parser.Nodes.Peek ();
Assert.IsTrue (doc.FirstChild is XDocType);
XDocType dt = (XDocType) doc.FirstChild;
Assert.AreEqual ("html", dt.RootElement.FullName);
Assert.AreEqual ("-//W3C//DTD XHTML 1.0 Strict//EN", dt.PublicFpi);
Assert.AreEqual ("DTD/xhtml1-strict.dtd", dt.Uri);
Assert.AreEqual (dt.InternalDeclarationRegion.Begin.Line, 4);
Assert.AreEqual (dt.InternalDeclarationRegion.End.Line, 7);
parser.AssertNoErrors ();
}
public void NamespacedAttributes ()
{
var parser = new TestXmlParser (CreateRootState (), true);
parser.Parse (@"<tag foo:bar='1' foo:bar:baz='2' foo='3' />");
parser.AssertEmpty ();
var doc = (XDocument) parser.Nodes.Peek ();
var el = (XElement) doc.FirstChild;
Assert.AreEqual (3, el.Attributes.Count ());
Assert.AreEqual ("foo", el.Attributes.ElementAt (0).Name.Prefix);
Assert.AreEqual ("bar", el.Attributes.ElementAt (0).Name.Name);
Assert.AreEqual ("foo", el.Attributes.ElementAt (1).Name.Prefix);
Assert.AreEqual ("bar:baz", el.Attributes.ElementAt (1).Name.Name);
Assert.IsNull (el.Attributes.ElementAt (2).Name.Prefix);
Assert.AreEqual ("foo", el.Attributes.ElementAt (2).Name.Name);
Assert.AreEqual (3, el.Attributes.Count ());
parser.AssertErrorCount (1);
Assert.AreEqual (1, parser.Errors [0].Region.Begin.Line);
Assert.AreEqual (26, parser.Errors [0].Region.Begin.Column);
}
public void SimpleTree ()
{
var parser = new TestXmlParser (CreateRootState (), true);
parser.Parse (@"
<doc>
<a>
<b>
<c/>
<d>
<e/>
</d>
<f>
<g/>
</f>
</b>
</a>
</doc>");
parser.AssertErrorCount (0);
var doc = ((XDocument)parser.Nodes.Peek ()).RootElement;
Assert.NotNull (doc);
Assert.AreEqual ("doc", doc.Name.Name);
Assert.True (doc.IsEnded);
var a = (XElement)doc.FirstChild;
Assert.NotNull (a);
Assert.AreEqual ("a", a.Name.Name);
Assert.True (a.IsEnded);
Assert.False (a.IsSelfClosing);
Assert.IsNull (a.NextSibling);
var b = (XElement)a.FirstChild;
Assert.NotNull (b);
Assert.AreEqual ("b", b.Name.Name);
Assert.True (b.IsEnded);
Assert.False (b.IsSelfClosing);
Assert.IsNull (b.NextSibling);
var c = (XElement) b.FirstChild;
Assert.NotNull (c);
Assert.AreEqual ("c", c.Name.Name);
Assert.True (c.IsEnded);
Assert.True (c.IsSelfClosing);
Assert.IsNull (c.FirstChild);
var d = (XElement) c.NextSibling;
Assert.True (d.IsEnded);
Assert.False (d.IsSelfClosing);
Assert.AreEqual ("d", d.Name.Name);
var e = (XElement) d.FirstChild;
Assert.NotNull (e);
Assert.True (e.IsEnded);
Assert.True (e.IsSelfClosing);
Assert.AreEqual ("e", e.Name.Name);
var f = (XElement) d.NextSibling;
Assert.AreEqual (f, b.LastChild);
Assert.True (f.IsEnded);
Assert.False (f.IsSelfClosing);
Assert.AreEqual ("f", f.Name.Name);
var g = (XElement) f.FirstChild;
Assert.NotNull (g);
Assert.True (g.IsEnded);
Assert.True (g.IsSelfClosing);
Assert.AreEqual ("g", g.Name.Name);
}
public void ClosingTagWithWhitespace ()
{
var parser = new TestXmlParser (CreateRootState ());
parser.Parse (@"<doc><a></ a></doc >");
parser.AssertEmpty ();
parser.AssertErrorCount (0);
}
