public void TestHtmlImplicitClosing () { TestParser parser = new TestParser (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 static Tuple<Library, IEnumerable<ParseError>> Parse(XmlReader reader) { var parser = new TestParser(reader); var library = parser.Library(); return Tuple.Create(library, parser.Context.Errors.AsEnumerable()); }
public void TestAutoClosing () { TestParser parser = new TestParser (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 (8); }
public void TestBufferOverflowSingleRun() { TestParser parser = new TestParser(128); Assert.Throws<Exceptions.RequestEntityTooLargeException>( delegate() { parser.AddBytes(createWhiteSpaceArray(129), 0, 129); } ); }
private TestParser GetTestParser(string input) { var lexer = new TestLexer2(input); var tokens = lexer.Tokens().ToList(); var parser = new TestParser(); parser.Initialize(tokens, lexer); return parser; }
public void Attributes () { TestParser parser = new TestParser (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 TestParser (CreateRootState (), true); parser.Parse (@"<%@ Page Language=""C#"" Inherits=""SomeGenericType<int>"" %>"); parser.AssertNoErrors (); var doc = (XDocument) parser.Nodes.Peek (); var directive = doc.Nodes.First () as AspNetDirective; 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 OptionalElement_ParsesCorrectly() { string comment = "No book lending here!!!"; var xml = BuildValidXml(); xml.Add(new XElement("comment", comment)); var r = XmlReader.Create(new StringReader(xml.ToString())); var results = TestParser.Parse(r); AssertErrorCount(0, results.Item2); var library = results.Item1; Assert.AreEqual(comment, library.Comment); }
public void OptionalAttribute_ParsesCorrectly() { var lastUpdated = DateTime.Parse("01/28/2011"); var xml = BuildValidXml(); xml.Add(new XAttribute("lastUpdated", lastUpdated.ToString())); var r = XmlReader.Create(new StringReader(xml.ToString())); var results = TestParser.Parse(r); AssertErrorCount(0, results.Item2); var library = results.Item1; Assert.AreEqual(lastUpdated, library.LastUpdated.Value); }
public void ExtensionsOrderedListWithAlphaLetter_Example003() { // Example 3 // Section: Extensions / Ordered list with alpha letter // // The following Markdown: // b. First item // c. Second item // // Should be rendered as: // <ol type="a" start="2"> // <li>First item</li> // <li>Second item</li> // </ol> Console.WriteLine("Example 3\nSection Extensions / Ordered list with alpha letter\n"); TestParser.TestSpec("b. First item\nc. Second item", "<ol type=\"a\" start=\"2\">\n<li>First item</li>\n<li>Second item</li>\n</ol>", "listextras|advanced"); }
public void UnexpectedElement_CanBeIgnoredAndParsingContinues() { var ignoredElement = new XElement("misc", "Here lies misc extra stuff!"); var xml = BuildValidXml(); var firstBook = xml.Element("category") .Element("book"); firstBook.AddFirst(ignoredElement); var r = XmlReader.Create(new StringReader(xml.ToString())); var results = TestParser.Parse(r); var library = results.Item1; Assert.AreEqual(firstBook.Attribute("title").Value, library.Categories[0].Books[0].Title); AssertErrorCount(0, results.Item2); }
public void ExtensionsEmphasisOnHtmlEntities_Example006() { // Example 6 // Section: Extensions / Emphasis on Html Entities // // The following Markdown: // This is text MyBrand ^®^ and MyTrademark ^™^ // This is text MyBrand^®^ and MyTrademark^™^ // This is text MyBrand~®~ and MyCopyright^©^ // // Should be rendered as: // <p>This is text MyBrand <sup>®</sup> and MyTrademark <sup>TM</sup> // This is text MyBrand<sup>®</sup> and MyTrademark<sup>TM</sup> // This is text MyBrand<sub>®</sub> and MyCopyright<sup>©</sup></p> Console.WriteLine("Example 6\nSection Extensions / Emphasis on Html Entities\n"); TestParser.TestSpec("This is text MyBrand ^®^ and MyTrademark ^™^\nThis is text MyBrand^®^ and MyTrademark^™^\nThis is text MyBrand~®~ and MyCopyright^©^", "<p>This is text MyBrand <sup>®</sup> and MyTrademark <sup>TM</sup>\nThis is text MyBrand<sup>®</sup> and MyTrademark<sup>TM</sup>\nThis is text MyBrand<sub>®</sub> and MyCopyright<sup>©</sup></p>", "emphasisextras|advanced"); }
public void ExtensionsDefinitionLists_Example005() { // Example 5 // Section: Extensions / Definition lists // // The following Markdown: // Term 1 // // : Not valid // // Should be rendered as: // <p>Term 1</p> // <pre><code>: Not valid // </code></pre> Console.WriteLine("Example 5\nSection Extensions / Definition lists\n"); TestParser.TestSpec("Term 1\n\n : Not valid", "<p>Term 1</p>\n<pre><code>: Not valid\n</code></pre>", "definitionlists+attributes|advanced"); }
public void ExtensionsBootstrap_Example003() { // Example 3 // Section: Extensions / Bootstrap // // The following Markdown: // ^^^ // This is a text in a caption // ^^^ This is the caption // // Should be rendered as: // <figure class="figure"> // <p>This is a text in a caption</p> // <figcaption class="figure-caption">This is the caption</figcaption> // </figure> TestParser.TestSpec("^^^\nThis is a text in a caption\n^^^ This is the caption", "<figure class=\"figure\">\n<p>This is a text in a caption</p>\n<figcaption class=\"figure-caption\">This is the caption</figcaption>\n</figure>", "bootstrap+pipetables+figures+attributes", context: "Example 3\nSection Extensions / Bootstrap\n"); }
public void ExtensionsYAMLFrontmatterDiscard_Example004() { // Example 4 // Section: Extensions / YAML frontmatter discard // // The following Markdown: // --- // this: is a frontmatter // // ... // This is a text // // Should be rendered as: // <p>This is a text</p> Console.WriteLine("Example 4\nSection Extensions / YAML frontmatter discard\n"); TestParser.TestSpec("---\nthis: is a frontmatter\n\n...\nThis is a text", "<p>This is a text</p>", "yaml"); }
public void AttributeName () { TestParser parser = new TestParser (CreateRootState ()); parser.Parse (@" <doc> <tag.a> <tag.b id=""$foo"" /> </tag.a> </doc> ", delegate { parser.AssertStateIs<XmlDoubleQuotedAttributeValueState> (); parser.AssertPath ("//doc/tag.a/tag.b/@id"); } ); parser.AssertEmpty (); parser.AssertErrorCount (0); }
public void ExtensionsGenericAttributes_Example002() { // Example 2 // Section: Extensions / Generic Attributes // // The following Markdown: // {#fenced-id .fenced-class} // ~~~ // This is a fenced with attached attributes // ~~~ // // Should be rendered as: // <pre><code id="fenced-id" class="fenced-class">This is a fenced with attached attributes // </code></pre> Console.WriteLine("Example 2\nSection Extensions / Generic Attributes\n"); TestParser.TestSpec("{#fenced-id .fenced-class}\n~~~\nThis is a fenced with attached attributes\n~~~ ", "<pre><code id=\"fenced-id\" class=\"fenced-class\">This is a fenced with attached attributes\n</code></pre>", "attributes|advanced"); }
public void ExtensionsFigures_Example001() { // Example 1 // Section: Extensions / Figures // // The following Markdown: // ^^^ // This is a figure // ^^^ This is a *caption* // // Should be rendered as: // <figure> // <p>This is a figure</p> // <figcaption>This is a <em>caption</em></figcaption> // </figure> TestParser.TestSpec("^^^\nThis is a figure\n^^^ This is a *caption*", "<figure>\n<p>This is a figure</p>\n<figcaption>This is a <em>caption</em></figcaption>\n</figure>", "figures+footers+citations|advanced", context: "Example 1\nSection Extensions / Figures\n"); }
public void ExtensionsPipeTable_Example005() { // Example 5 // Section: Extensions / Pipe Table // // The following Markdown: // a b // c | d // e | f // // Should be rendered as: // <p>a b // c | d // e | f</p> Console.WriteLine("Example 5\nSection Extensions / Pipe Table\n"); TestParser.TestSpec("a b\nc | d\ne | f", "<p>a b\nc | d\ne | f</p>", "pipetables|advanced"); }
public void ExtensionsDefinitionLists_Example004() { // Example 4 // Section: Extensions / Definition lists // // The following Markdown: // Term 1 // : Valid even if `:` starts at most 3 spaces // // Should be rendered as: // <dl> // <dt>Term 1</dt> // <dd>Valid even if <code>:</code> starts at most 3 spaces</dd> // </dl> Console.WriteLine("Example 4\nSection Extensions / Definition lists\n"); TestParser.TestSpec("Term 1\n : Valid even if `:` starts at most 3 spaces", "<dl>\n<dt>Term 1</dt>\n<dd>Valid even if <code>:</code> starts at most 3 spaces</dd>\n</dl>", "definitionlists+attributes|advanced"); }
public void TestShouldNotRunOnBlacklistedPlatforms(string[] currentPlatforms, string[] platformBlacklist, bool expectedToRun) { TestParser parser = new TestParser(); SystemUnderTest system = new SystemUnderTest( runtimeVersion: Version.Parse("2.1"), sdkVersion: null, platformIds: currentPlatforms.ToList()); TestDescriptor test = new TestDescriptor() { Enabled = true, Version = "2.1", PlatformBlacklist = platformBlacklist.ToList(), }; var shouldRun = parser.ShouldRunTest(system, test); Assert.Equal(expectedToRun, shouldRun); }
public void ExtensionsNoHTML_Example002() { // Example 2 // Section: Extensions / NoHTML // // The following Markdown: // <div> // this is some text // </div> // // Should be rendered as: // <p><div> // this is some text // </div></p> Console.WriteLine("Example 2\nSection Extensions / NoHTML\n"); TestParser.TestSpec("<div>\nthis is some text\n</div>", "<p><div>\nthis is some text\n</div></p>", "nohtml"); }
public void VersionSpecificTestShouldBeRunForSameMajorMinorVersion(string version, bool expectedToRun) { TestParser parser = new TestParser(); SystemUnderTest system = new SystemUnderTest( runtimeVersion: Version.Parse(version), sdkVersion: null, platformIds: new List <string>()); TestDescriptor test = new TestDescriptor() { Enabled = true, VersionSpecific = true, Version = "2.1", }; var shouldRun = parser.ShouldRunTest(system, test); Assert.Equal(expectedToRun, shouldRun); }
public void ExtensionsAbbreviation_Example005() { // Example 5 // Section: Extensions / Abbreviation // // The following Markdown: // *[1A]: First // *[1A1]: Second // *[1A2]: Third // // We can abbreviate 1A, 1A1 and 1A2! // // Should be rendered as: // <p>We can abbreviate <abbr title="First">1A</abbr>, <abbr title="Second">1A1</abbr> and <abbr title="Third">1A2</abbr>!</p> Console.WriteLine("Example 5\nSection Extensions / Abbreviation\n"); TestParser.TestSpec("*[1A]: First\n*[1A1]: Second\n*[1A2]: Third\n\nWe can abbreviate 1A, 1A1 and 1A2!", "<p>We can abbreviate <abbr title=\"First\">1A</abbr>, <abbr title=\"Second\">1A1</abbr> and <abbr title=\"Third\">1A2</abbr>!</p>", "abbreviations|advanced"); }
public void ExtensionsOrderedListWithRomanLetter_Example007() { // Example 7 // Section: Extensions / Ordered list with roman letter // // The following Markdown: // ii. First item // iii. Second item // // Should be rendered as: // <ol type="i" start="2"> // <li>First item</li> // <li>Second item</li> // </ol> Console.WriteLine("Example 7\nSection Extensions / Ordered list with roman letter\n"); TestParser.TestSpec("ii. First item\niii. Second item", "<ol type=\"i\" start=\"2\">\n<li>First item</li>\n<li>Second item</li>\n</ol>", "listextras|advanced"); }
public void ExtraElement_GeneratesErrorWhilePreservingFirstComment() { string comment = "No book lending here!!!"; var xml = BuildValidXml(); xml.Add(new XElement("comment", comment)); xml.Add(new XElement("comment", "This should cause an error!!!")); var r = XmlReader.Create(new StringReader(xml.ToString())); var results = TestParser.Parse(r); var library = results.Item1; Assert.AreEqual(comment, library.Comment); AssertErrorCount(1, results.Item2); }
public void ExtensionsYAMLFrontmatterDiscard_Example003() { // Example 3 // Section: Extensions / YAML frontmatter discard // // The following Markdown: // ---- // this: is a frontmatter // ---- // This is a text // // Should be rendered as: // <hr /> // <h2>this: is a frontmatter</h2> // <p>This is a text</p> TestParser.TestSpec("----\nthis: is a frontmatter\n----\nThis is a text", "<hr />\n<h2>this: is a frontmatter</h2>\n<p>This is a text</p>", "yaml", context: "Example 3\nSection Extensions / YAML frontmatter discard\n"); }
public void ExtensionsPipeTable_Example024() { // Example 24 // Section: Extensions / Pipe Table // // The following Markdown: // | abc | def | // |---|---| // | cde| ddd| // | eee| fff| // | fff | fffff | // |gggg | ffff | // // Should be rendered as: // <table> // <thead> // <tr> // <th>abc</th> // <th>def</th> // </tr> // </thead> // <tbody> // <tr> // <td>cde</td> // <td>ddd</td> // </tr> // <tr> // <td>eee</td> // <td>fff</td> // </tr> // <tr> // <td>fff</td> // <td>fffff</td> // </tr> // <tr> // <td>gggg</td> // <td>ffff</td> // </tr> // </tbody> // </table> Console.WriteLine("Example 24\nSection Extensions / Pipe Table\n"); TestParser.TestSpec("| abc | def | \n|---|---|\n| cde| ddd| \n| eee| fff|\n| fff | fffff | \n|gggg | ffff | ", "<table>\n<thead>\n<tr>\n<th>abc</th>\n<th>def</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>cde</td>\n<td>ddd</td>\n</tr>\n<tr>\n<td>eee</td>\n<td>fff</td>\n</tr>\n<tr>\n<td>fff</td>\n<td>fffff</td>\n</tr>\n<tr>\n<td>gggg</td>\n<td>ffff</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced"); }
public void ExtensionsGlobalization_Example004() { // Example 4 // Section: Extensions / Globalization // // The following Markdown: // Foo میوە // // میوە bar // // Baz میوە // // Should be rendered as: // <p>Foo میوە</p> // <p dir="rtl">میوە bar</p> // <p>Baz میوە</p> TestParser.TestSpec("Foo میوە\n\nمیوە bar\n\nBaz میوە", "<p>Foo میوە</p>\n<p dir=\"rtl\">میوە bar</p>\n<p>Baz میوە</p>", "globalization+advanced+emojis", context: "Example 4\nSection Extensions / Globalization\n"); }
public void SingleTestParser() { IImpliedModelParser modelParser = new TestParser(); IModel model = new CobolModel("Parent", "NAME SHOULD SEPARATE TEST DATA 1", "This is test data"); Assert.That(modelParser.Matches(model), Is.True); IModel child = modelParser.Parse(model); Assert.That(child, Is.Not.Null); Assert.That(child, Is.Not.SameAs(model)); IModel expected = new HierarchyModel(new CobolModel("Parent", "NAME SHOULD SEPARATE", "This is test data"), new IModel[] { new CobolModel("Test", "TEST DATA 1", "Implied") }); AssertModelIsSame(child, expected, true); }
public void UnexpectedElement_GeneratesErrorAndParsingContinues() { var badElement = new XElement("bad", new XAttribute("message", "I am not expected!"), new XElement("additionalMessages", new XElement("message", "Mwwwahahahaha!"))); var xml = BuildValidXml(); xml.AddFirst(badElement); var r = XmlReader.Create(new StringReader(xml.ToString())); var results = TestParser.Parse(r); var library = results.Item1; Assert.AreEqual(xml.Elements("category").Count(), library.Categories.Count); AssertErrorCount(1, results.Item2); }
public void ExtensionsPipeTable_Example007() { // Example 7 // Section: Extensions / Pipe Table // // The following Markdown: // a | b // -- | -- // 0 | 1 | 2 // 3 | 4 // 5 | // // Should be rendered as: // <table> // <thead> // <tr> // <th>a</th> // <th>b</th> // <th></th> // </tr> // </thead> // <tbody> // <tr> // <td>0</td> // <td>1</td> // <td>2</td> // </tr> // <tr> // <td>3</td> // <td>4</td> // <td></td> // </tr> // <tr> // <td>5</td> // <td></td> // <td></td> // </tr> // </tbody> // </table> Console.WriteLine("Example 7\nSection Extensions / Pipe Table\n"); TestParser.TestSpec("a | b \n-- | --\n0 | 1 | 2\n3 | 4\n5 |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>2</td>\n</tr>\n<tr>\n<td>3</td>\n<td>4</td>\n<td></td>\n</tr>\n<tr>\n<td>5</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced"); }
public void Calculate_NoPreprocessorDirectoryWhenRequired_ThrowsInvalidOperationException() { // Setup var parser = new TestParser(); var settings = new HydraRingCalculationSettings("D:\\hlcd.sqlite", string.Empty, false); var calculator = new TestHydraRingCalculator(settings, parser); var hydraRingCalculationInput = new TestHydraRingCalculationInput { PreprocessorSetting = new PreprocessorSetting(1, 2, new NumericsSetting(1, 4, 50, 0.15, 0.05, 0.01, 0.01, 0, 2, 20000, 100000, 0.1, -6, 6)) }; // Call void Call() => calculator.PublicCalculate(hydraRingCalculationInput); // Assert string message = Assert.Throws <InvalidOperationException>(Call).Message; Assert.AreEqual("Preprocessor directory required but not specified.", message); }
public void ExtensionsGenericAttributes_Example003() { // Example 3 // Section: Extensions / Generic Attributes // // The following Markdown: // [Foo](url){data-x=1} // // [Foo](url){data-x='1'} // // [Foo](url){data-x=11} // // Should be rendered as: // <p><a href="url" data-x="1">Foo</a></p> // <p><a href="url" data-x="1">Foo</a></p> // <p><a href="url" data-x="11">Foo</a></p> TestParser.TestSpec("[Foo](url){data-x=1}\n\n[Foo](url){data-x='1'}\n\n[Foo](url){data-x=11}", "<p><a href=\"url\" data-x=\"1\">Foo</a></p>\n<p><a href=\"url\" data-x=\"1\">Foo</a></p>\n<p><a href=\"url\" data-x=\"11\">Foo</a></p>", "attributes|advanced", context: "Example 3\nSection Extensions / Generic Attributes\n"); }
public void ExtensionsPipeTable_Example017() { // Example 17 // Section: Extensions / Pipe Table // // The following Markdown: // a | b // -------|---x--- // 0 | 1 // 2 | 3 // // Should be rendered as: // <p>a | b // -------|---x--- // 0 | 1 // 2 | 3</p> TestParser.TestSpec(" a | b\n-------|---x---\n 0 | 1\n 2 | 3 ", "<p>a | b\n-------|---x---\n0 | 1\n2 | 3</p> ", "pipetables|advanced", context: "Example 17\nSection Extensions / Pipe Table\n"); }
public void ExtensionsForms_Example003() { // Example 3 // Section: Extensions / Forms // // The following Markdown: // city = {BOS, SFO, (NYC)} // // Should be rendered as: // <label for="city">City:</label> // <select id="city" name="city"> // <option value="BOS">BOS</option> // <option value="SFO">SFO</option> // <option value="NYC" selected="selected">NYC</option> // </select> Console.WriteLine("Example 3\nSection Extensions / Forms\n"); TestParser.TestSpec("city = {BOS, SFO, (NYC)}", "<label for=\"city\">City:</label>\n<select id=\"city\" name=\"city\">\n <option value=\"BOS\">BOS</option>\n <option value=\"SFO\">SFO</option>\n <option value=\"NYC\" selected=\"selected\">NYC</option>\n</select>", "forms|advanced"); }
public void ExtensionsAutoLinksGFMSupport_Example015() { // Example 15 // Section: Extensions / AutoLinks / GFM Support // // The following Markdown: // http://commonmark.org // // (Visit https://encrypted.google.com/search?q=Markup+(business)) // // Anonymous FTP is available at ftp://foo.bar.baz. // // Should be rendered as: // <p><a href="http://commonmark.org">http://commonmark.org</a></p> // <p>(Visit <a href="https://encrypted.google.com/search?q=Markup+(business)">https://encrypted.google.com/search?q=Markup+(business)</a>)</p> // <p>Anonymous FTP is available at <a href="ftp://foo.bar.baz">ftp://foo.bar.baz</a>.</p> TestParser.TestSpec("http://commonmark.org\n\n(Visit https://encrypted.google.com/search?q=Markup+(business))\n\nAnonymous FTP is available at ftp://foo.bar.baz.", "<p><a href=\"http://commonmark.org\">http://commonmark.org</a></p>\n<p>(Visit <a href=\"https://encrypted.google.com/search?q=Markup+(business)\">https://encrypted.google.com/search?q=Markup+(business)</a>)</p>\n<p>Anonymous FTP is available at <a href=\"ftp://foo.bar.baz\">ftp://foo.bar.baz</a>.</p>", "autolinks|advanced", context: "Example 15\nSection Extensions / AutoLinks / GFM Support\n"); }
public void SdkTestsShouldRunOnlyWithSdk(string sdkVersion, bool requiresSdk, bool expectedToRun) { TestParser parser = new TestParser(); SystemUnderTest system = new SystemUnderTest( runtimeVersion: Version.Parse("3.1"), sdkVersion: Version.Parse(sdkVersion), platformIds: new List <string>()); TestDescriptor test = new TestDescriptor() { Enabled = true, RequiresSdk = requiresSdk, VersionSpecific = false, Version = "2.1", }; var shouldRun = parser.ShouldRunTest(system, test); Assert.Equal(expectedToRun, shouldRun); }
public void AttributeWithExpression () { var parser = new TestParser (CreateRootState (), true); parser.Parse (@"<tag foo='<%=5$%>' bar=""<%$$5$%><%--$--%>"" baz='<%#5$%>=<%:fhfjhf %0 $%>' quux = <% 5 $%> />", delegate { parser.AssertNodeIs<AspNetRenderExpression> (); }, delegate { parser.AssertNodeIs<AspNetResourceExpression> (); }, delegate { parser.AssertNodeIs<AspNetServerComment> (); }, delegate { parser.AssertNodeIs<AspNetDataBindingExpression> (); }, delegate { parser.AssertNodeIs<AspNetHtmlEncodedExpression> (); }, delegate { parser.AssertNodeIs<AspNetRenderBlock> (); }); parser.AssertNoErrors (); var doc = (XDocument) parser.Nodes.Peek (); }
public void TestExampleRequestWithStartIndex() { TestParser parser = new TestParser(512); byte[] requestData = Encoding.ASCII.GetBytes(exampleRequest); byte[] paddedRequestData = createWhiteSpaceArray(requestData.Length + 512); Array.Copy(requestData, 0, paddedRequestData, 512, requestData.Length); parser.AddBytes(paddedRequestData, 512, requestData.Length); }
public void TestSplitLineEndRecognition() { TestParser parser = new TestParser(128); byte[] requestData = Encoding.ASCII.GetBytes(exampleRequest); int crIndex = Array.IndexOf<byte>(requestData, 13); System.Diagnostics.Trace.Assert(crIndex != -1); parser.AddBytes(requestData, 0, crIndex + 1); Assert.Throws<Exceptions.RequestEntityTooLargeException>( delegate() { parser.AddBytes(requestData, crIndex + 1, requestData.Length - crIndex); } ); }
public void Misc () { TestParser parser = new TestParser (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 DocTypeCapture () { TestParser parser = new TestParser (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.Start.Line, 4); Assert.AreEqual (dt.InternalDeclarationRegion.End.Line, 7); parser.AssertNoErrors (); }
public void TestIncompleteLineParsing() { TestParser parser = new TestParser(128); byte[] requestData = Encoding.ASCII.GetBytes("This is a boring test string"); parser.ProcessBytes(requestData, 0, requestData.Length); Assert.AreEqual(0, parser.ParsedLineCount); }
public void Unclosed () { TestParser parser = new TestParser (CreateRootState ()); parser.Parse (@" <doc> <tag.a> <tag.b><tag.b>$ </tag.a>$ </doc> ", delegate { parser.AssertStateIs<XmlFreeState> (); parser.AssertNodeDepth (5); parser.AssertPath ("//doc/tag.a/tag.b/tag.b"); }, delegate { parser.AssertStateIs<XmlFreeState> (); parser.AssertNodeDepth (2); parser.AssertPath ("//doc"); } ); parser.AssertEmpty (); parser.AssertErrorCount (2); }
public void TestExampleRequest() { TestParser parser = new TestParser(512); byte[] requestData = Encoding.ASCII.GetBytes(exampleRequest); parser.AddBytes(requestData, 0, requestData.Length); }
public void TestReset() { byte[] beginning = Encoding.ASCII.GetBytes("This is a test\r"); byte[] ending = Encoding.ASCII.GetBytes("\nA real test\r\n"); TestParser parser = new TestParser(128); parser.SetReceivedData(beginning, 0, beginning.Length); Assert.IsNull(parser.ParseLine()); parser.Reset(); // If the Reset() didn't work, the parser would now complain that it discovered // a lone carriage return inmidst of the data stream parser.SetReceivedData(beginning, 0, beginning.Length); Assert.IsNull(parser.ParseLine()); parser.SetReceivedData(ending, 0, ending.Length); Assert.AreEqual("This is a test", parser.ParseLine()); Assert.AreEqual("A real test", parser.ParseLine()); Assert.IsNull(parser.ParseLine()); }
public void TestSlightlyTooLargeSplitMessage() { byte[] slightlyTooLargeData = Encoding.ASCII.GetBytes( new string(' ', 30) + "\r\n" + new string(' ', 30) + "\r\n" + new string(' ', 31) + "\r\n" ); TestParser parser = new TestParser(96); parser.SetReceivedData(slightlyTooLargeData, 0, slightlyTooLargeData.Length); Assert.AreEqual(new string(' ', 30), parser.ParseLine()); Assert.AreEqual(new string(' ', 30), parser.ParseLine()); Assert.Throws<InsufficientMemoryException>( delegate() { Console.WriteLine(parser.ParseLine()); } ); }
public void NamespacedAttributes () { var parser = new TestParser (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.BeginLine); Assert.AreEqual (25, parser.Errors [0].Region.BeginColumn); }
public void TestSplitLine() { byte[] firstPart = Encoding.ASCII.GetBytes("This "); byte[] secondPart = Encoding.ASCII.GetBytes("is a "); byte[] thirdPart = Encoding.ASCII.GetBytes("test\r\n"); TestParser parser = new TestParser(64); parser.SetReceivedData(firstPart, 0, firstPart.Length); Assert.IsNull(parser.ParseLine()); parser.SetReceivedData(secondPart, 0, secondPart.Length); Assert.IsNull(parser.ParseLine()); parser.SetReceivedData(thirdPart, 0, thirdPart.Length); Assert.AreEqual("This is a test", parser.ParseLine()); Assert.IsNull(parser.ParseLine()); }
public void TestLargeMessage() { byte[] firstPart = Encoding.ASCII.GetBytes(new string(' ', 128)); byte[] secondPart = Encoding.ASCII.GetBytes("This is a test\r\n"); TestParser parser = new TestParser(192); parser.SetReceivedData(firstPart, 0, firstPart.Length); Assert.IsNull(parser.ParseLine()); parser.SetReceivedData(secondPart, 0, secondPart.Length); Assert.AreEqual(new string(' ', 128) + "This is a test", parser.ParseLine()); Assert.IsNull(parser.ParseLine()); }
public void TestRemainingDataRetrieval() { byte[] binaryData = new byte[9] { 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88 }; byte[] requestData = Encoding.ASCII.GetBytes("This is a test\r\n123456789"); for(int index = 0; index < 9; ++index) { requestData[index + 16] = binaryData[index]; } TestParser parser = new TestParser(128); parser.SetReceivedData(requestData, 0, requestData.Length); Assert.AreEqual("This is a test", parser.ParseLine()); Assert.IsTrue( arraySegmentContentsAreEqual( new ArraySegment<byte>(binaryData, 0, 9), parser.GetRemainingData() ) ); }
public void AttributeRecovery () { TestParser parser = new TestParser (CreateRootState ()); parser.Parse (@" <doc> <tag.a> <tag.b arg='fff' sdd = sdsds= 'foo' ff $ /> </tag.a> <a><b valid/></a> </doc> ", delegate { parser.AssertStateIs<XmlTagState> (); parser.AssertAttributes ("arg", "fff", "sdd", "", "sdsds", "foo", "ff", ""); parser.AssertErrorCount (1); } ); parser.AssertEmpty (); parser.AssertErrorCount (1); }
public void TestLoneCarriageReturn() { byte[] badData = Encoding.ASCII.GetBytes("First line\r\nThis is a \r test"); TestParser parser = new TestParser(64); parser.SetReceivedData(badData, 0, badData.Length); Assert.AreEqual("First line", parser.ParseLine()); Assert.Throws<FormatException>( delegate() { parser.ParseLine(); } ); }
public void TestBarelyFittingMessage() { byte[] barelyFittingData = Encoding.ASCII.GetBytes( new string(' ', 62) + "\r\n" ); TestParser parser = new TestParser(64); parser.SetReceivedData(barelyFittingData, 0, barelyFittingData.Length); Assert.AreEqual(new string(' ', 62), parser.ParseLine()); Assert.IsNull(parser.ParseLine()); }
public void IncompleteTags () { TestParser parser = new TestParser (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<XmlSingleQuotedAttributeValueState> (); parser.AssertNodeDepth (9); parser.AssertPath ("//doc/tag.a/tag.b/tag.c/tag.d/tag.e/tag.f/@id"); } ); parser.AssertEmpty (); parser.AssertErrorCount (3, x => x.ErrorType == ErrorType.Error); parser.AssertErrorCount (2, x => x.ErrorType == ErrorType.Warning); }
public void TestInvalidCharactersInRequest() { TestParser parser = new TestParser(128); byte[] requestData = Encoding.ASCII.GetBytes("GET /something HTTP/1.1\r\n"); requestData[6] = 10; requestData[9] = 13; Assert.Throws<Exceptions.BadRequestException>( delegate() { parser.AddBytes(requestData, 0, requestData.Length); } ); }
public void Init () { parser = new TestParser (new RazorTestFreeState ()); }
public void TestFarTooLargeSplitMessage() { byte[] farTooLargeData = Encoding.ASCII.GetBytes(new string(' ', 128)); TestParser parser = new TestParser(64); parser.SetReceivedData(farTooLargeData, 0, farTooLargeData.Length); Assert.Throws<InsufficientMemoryException>( delegate() { Console.WriteLine(parser.ParseLine()); } ); }
public void TestLoneCarriageReturnInSplitStream() { byte[] badData = Encoding.ASCII.GetBytes("This is a test\r"); TestParser parser = new TestParser(128); // Parse a chunk of data that leaves an open-ended carriage return. No exception // should be thrown here because the next chunk the parser get might start // with a line feed, thus forming a valid line. try { parser.SetReceivedData(badData, 0, badData.Length); Assert.IsNull(parser.ParseLine()); } catch(FormatException) { Assert.Fail("Line parser complained about what could yet become a valid line"); } // Parse the same thing again. Now the parser should notice that the carriage // return wasn't followed by a line feed and legitimately complain. parser.SetReceivedData(badData, 0, badData.Length); Assert.Throws<FormatException>( delegate() { parser.ParseLine(); } ); }