public void TestGfmWithSequenceRewrite()
{
const string source = @"
# A
## B
### C";
const string expected = @"<h2 id=""a"">A</h2>
<h4 id=""b"">B</h4>
<h4 id=""c"">C</h4>
";
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.Sequence(
MarkdownTokenRewriterFactory.FromLambda(
(IMarkdownRewriteEngine e, MarkdownHeadingBlockToken t) =>
t.Depth <= 2 ? new MarkdownHeadingBlockToken(t.Rule, t.Context, t.Content, t.Id, t.Depth + 1, t.SourceInfo) : null),
MarkdownTokenRewriterFactory.FromLambda(
(IMarkdownRewriteEngine e, MarkdownHeadingBlockToken t) =>
t.Depth == 3 ? new MarkdownHeadingBlockToken(t.Rule, t.Context, t.Content, t.Id, t.Depth + 1, t.SourceInfo) : null)
);
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
}
public void TestGfmWithValidator()
{
const string source = "#Hello World";
const string expected = "<h1 id=\"hello-world\">Hello World</h1>\n";
const string expectedMessage = "a space is expected after '#'";
string message = null;
var builder = new GfmEngineBuilder(new Options
{
LegacyMode = true,
});
builder.Rewriter =
MarkdownTokenRewriterFactory.FromValidators(
MarkdownTokenValidatorFactory.FromLambda(
(MarkdownHeadingBlockToken token) =>
{
if (!token.SourceInfo.Markdown.StartsWith("# "))
{
message = expectedMessage;
}
}));
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
Assert.Equal(expectedMessage, message);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
var builder = new GfmEngineBuilder(new Options());
var engine = builder.CreateEngine(new HtmlRenderer());
services.AddSingleton<IMarkdownEngine>(engine);
}
public void TestGfmInGeneral(string source, string expected)
{
var builder = new GfmEngineBuilder(new Options());
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
}
public void TestAggregateHead1_Hr_To_Head2(string source, string expected)
{
var builder = new GfmEngineBuilder(new Options())
{
TokenAggregators = ImmutableList.Create <IMarkdownTokenAggregator>(new Head1HrAggregateToHead2()),
};
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
}
public void TestAggregatePara_Para_To_Para(string source, string expected)
{
var builder = new GfmEngineBuilder(new Options())
{
TokenAggregator = new ParaParaAggregateToPara(),
};
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(
IServiceCollection services)
{
services.AddControllers();
var builder = new GfmEngineBuilder(
options: new Options());
var engine = builder.CreateEngine(
renderer: new HtmlRenderer());
services.AddSingleton <IMarkdownEngine>(
implementationInstance: engine);
}
public void TestPerf()
{
const int RepeatCount = 1000;
string source = GetSource(RepeatCount);
var builder = new GfmEngineBuilder(new Options());
var engine = builder.CreateEngine(new HtmlRenderer());
for (int i = 0; i < 2; i++)
{
var result = engine.Markup(source);
Assert.True(Enumerable.SequenceEqual(GetExpectedLines(RepeatCount), GetLines(result)));
}
GC.Collect();
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
var builder = new GfmEngineBuilder(new Options());
var engine = builder.CreateEngine(new HtmlRenderer());
services.AddSingleton <IMarkdownEngine>(engine);
var configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile("config.json", false); // false == this file is not optional, throw if not found
services.AddSingleton <IConfigurationRoot>(configBuilder.Build());
}
public void TestCompositeAggregate(string source, string expected)
{
var builder = new GfmEngineBuilder(new Options())
{
TokenAggregator = new CompositeMarkdownTokenAggregator(
new IMarkdownTokenAggregator[]
{
new ParaParaAggregateToPara(),
new Head1HrAggregateToHead2(),
}),
};
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
var builder = new GfmEngineBuilder(new Options());
var engine = builder.CreateEngine(new HtmlRenderer());
services.AddSingleton <IMarkdownEngine>(engine);
var configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile("config.json", true);
var configRoot = configBuilder.Build();
services.AddSingleton <IConfigurationRoot>(configRoot);
}
public static void Main()
{
string source = @"
Building Your First .NET Core Applications
=======
In this chapter, we will learn how to setup our development environment,
create an application, and
";
var builder = new GfmEngineBuilder(
new Options());
var engine = builder.CreateEngine(
new HtmlRenderer());
var result = engine.Markup(
source);
Console.WriteLine(
result);
}
public void TestGfmWithValidatorWithQuery()
{
const string source = @"abc (not match)
- abc (match)
- a*b*c (match)
- xyz
- x
> a**b**c (not match)";
const string expected = @"<p>abc (not match)</p>
<ul>
<li>abc (match)</li>
<li>a<em>b</em>c (match)</li>
<li>xyz</li>
<li>x</li>
</ul>
<blockquote>
<p>a<strong>b</strong>c (not match)</p>
</blockquote>
";
int matchCount = 0;
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.FromValidators(
MarkdownTokenValidatorFactory.FromLambda(
(MarkdownListItemBlockToken token) =>
{
var text = string.Concat(from t in token.Descendants <MarkdownTextToken>() select t.Content);
if (text.Contains("abc"))
{
matchCount++;
}
}));
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
Assert.Equal(2, matchCount);
}
public void TestGfmWithValidatorWithContext()
{
const string source = @"# Title-1
# Title-2";
const string expected = @"<h1 id=""title-1"">Title-1</h1>
<h1 id=""title-2"">Title-2</h1>
";
const string expectedMessage = "expected one title in one document.";
string message = null;
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.FromValidators(
MarkdownTokenValidatorFactory.FromLambda(
(MarkdownHeadingBlockToken token) =>
{
var re = MarkdownTokenValidatorContext.CurrentRewriteEngine;
if (token.Depth == 1)
{
re.SetVariable("count", (int)re.GetVariable("count") + 1);
}
},
re =>
{
re.SetVariable("count", 0);
re.SetPostProcess("h1 count", re1 =>
{
if ((int)re.GetVariable("count") != 1)
{
message = expectedMessage;
}
});
}));
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
Assert.Equal(expectedMessage, message);
}
private static ImmutableArray <IMarkdownToken> Tokenize(string markdown, string file)
{
var gfm = new GfmEngineBuilder(new Options()).CreateEngine(new HtmlRenderer());
var sourceInfo = SourceInfo.Create(markdown.Replace("\r\n", "\n"), file);
var tokens = gfm.Parser.Tokenize(sourceInfo);
tokens = TokenHelper.CreateParagraghs(
gfm.Parser,
MarkdownParagraphBlockRule.Instance,
tokens,
true,
sourceInfo);
var rewriter =
new MarkdownRewriteEngine(
gfm,
MarkdownTokenRewriterFactory.FromLambda <IMarkdownRewriteEngine, TwoPhaseBlockToken>(
(e, t) => t.Extract(gfm.Parser)));
tokens = rewriter.Rewrite(tokens);
return(tokens);
}
public void ParseWithBadRewrite()
{
const string source = @"
# Heading
";
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.Loop(
MarkdownTokenRewriterFactory.Composite(
MarkdownTokenRewriterFactory.FromLambda(
(IMarkdownRewriteEngine e, MarkdownHeadingBlockToken t) => new MarkdownTextToken(t.Rule, t.Context, t.RawMarkdown, t.RawMarkdown)
),
MarkdownTokenRewriterFactory.FromLambda(
(IMarkdownRewriteEngine e, MarkdownTextToken t) => new MarkdownHeadingBlockToken(t.Rule, t.Context, new InlineContent(ImmutableArray <IMarkdownToken> .Empty), "aaaa", 1, t.RawMarkdown)
)
),
10);
var engine = builder.CreateEngine(new HtmlRenderer());
Assert.Throws <InvalidOperationException>(() => engine.Markup(source));
}
public void ParseWithBadRewrite()
{
const string source = @"
# Heading
";
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownRewriterFactory.Loop(
MarkdownRewriterFactory.Composite(
MarkdownRewriterFactory.FromLambda(
(MarkdownEngine e, MarkdownHeadingBlockToken t) => new MarkdownTextToken(t.Rule, t.Content)
),
MarkdownRewriterFactory.FromLambda(
(MarkdownEngine e, MarkdownTextToken t) => new MarkdownHeadingBlockToken(t.Rule, t.Content, 1)
)
),
10);
var engine = builder.CreateEngine(new MarkdownRenderer());
Assert.Throws <InvalidOperationException>(() => engine.Markup(source));
}
public void TestSourceInfo_Table()
{
const string File = "test.md";
var gfm = new GfmEngineBuilder(new Options()).CreateEngine(new HtmlRenderer());
var tokens = gfm.Parser.Tokenize(
SourceInfo.Create(@"
| H1 | H2 |
|----|----|
|R1C1|R1C2|
|R2C1|R2C2|
".Replace("\r\n", "\n"), File));
var rewriter =
new MarkdownRewriteEngine(
gfm,
MarkdownTokenRewriterFactory.FromLambda <IMarkdownRewriteEngine, TwoPhaseBlockToken>(
(e, t) => t.Extract(gfm.Parser)));
tokens = rewriter.Rewrite(tokens);
Assert.Equal(2, tokens.Length);
Assert.IsType <MarkdownTableBlockToken>(tokens[1]);
var table = (MarkdownTableBlockToken)tokens[1];
Assert.Equal(2, table.Header.Length);
Assert.Equal(2, table.Cells.Length);
Assert.Equal(2, table.SourceInfo.LineNumber);
Assert.Equal(File, table.SourceInfo.File);
Assert.Equal(2, table.Header[0].SourceInfo.LineNumber);
Assert.Equal(2, table.Header[1].SourceInfo.LineNumber);
Assert.Equal(4, table.Cells[0][0].SourceInfo.LineNumber);
Assert.Equal(4, table.Cells[0][1].SourceInfo.LineNumber);
Assert.Equal(5, table.Cells[1][0].SourceInfo.LineNumber);
Assert.Equal(5, table.Cells[1][1].SourceInfo.LineNumber);
}
public void TestPerf()
{
const string source = @"
Heading
=======
Sub-heading
-----------
### Another deeper heading
Paragraphs are separated
by a blank line.
Leave 2 spaces at the end of a line to do a
line break
Text attributes *italic*, **bold**,
`monospace`, ~~strikethrough~~ .
A [link](http://example.com).
Shopping list:
* apples
* oranges
* pears
Numbered list:
1. apples
2. oranges
3. pears
";
const string expectedTemplate = @"<h1 id=""heading{0}"">Heading</h1>
<h2 id=""sub-heading{0}"">Sub-heading</h2>
<h3 id=""another-deeper-heading{0}"">Another deeper heading</h3>
<p>Paragraphs are separated
by a blank line.</p>
<p>Leave 2 spaces at the end of a line to do a<br>line break</p>
<p>Text attributes <em>italic</em>, <strong>bold</strong>,
<code>monospace</code>, <del>strikethrough</del> .</p>
<p>A <a href=""http://example.com"">link</a>.</p>
<p>Shopping list:</p>
<ul>
<li>apples</li>
<li>oranges</li>
<li>pears</li>
</ul>
<p>Numbered list:</p>
<ol>
<li>apples</li>
<li>oranges</li>
<li>pears</li>
</ol>
";
var builder = new GfmEngineBuilder(new Options());
var source1000 = string.Concat(Enumerable.Repeat(source, 1000));
var template = Regex.Replace(expectedTemplate, "\r?\n", "\n");
var first = string.Format(template, "");
var expectedList = new List <string> {
first
};
for (var i = 1; i < 1000; i++)
{
var content = string.Concat("-", i - 1);
expectedList.Add(string.Format(template, content));
}
var expected1000 = string.Concat(expectedList);
var engine = builder.CreateEngine(new HtmlRenderer());
for (int i = 0; i < 2; i++)
{
var result = engine.Markup(source1000);
Assert.Equal(expected1000, result);
}
GC.Collect();
}
public void TestGfmWithRewrite()
{
const string source = @"
Heading
=======
Sub-heading
-----------
### Another deeper heading
Paragraphs are separated
by a blank line.
Leave 2 spaces at the end of a line to do a
line break
Text attributes *italic*, **bold**,
`monospace`, ~~strikethrough~~ .
A [link](http://example.com).
Shopping list:
* apples
* oranges
* pears
Numbered list:
1. apples
2. oranges
3. pears
";
const string expected = @"<p>Paragraphs are separated
by a blank line.</p>
<p>Leave 2 spaces at the end of a line to do a<br>line break</p>
<p>Text attributes <em>italic</em>, <strong>bold</strong>,
<code>monospace</code>, <del>strikethrough</del> .</p>
<p>A <a href=""http://example.com"">link</a>.</p>
<p>Shopping list:</p>
<ul>
<li>apples</li>
<li>oranges</li>
<li>pears</li>
</ul>
<p>Numbered list:</p>
<ol>
<li>apples</li>
<li>oranges</li>
<li>pears</li>
</ol>
";
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.FromLambda(
(IMarkdownRewriteEngine e, MarkdownHeadingBlockToken t) => new MarkdownIgnoreToken(t.Rule, t.Context, t.RawMarkdown) // ignore all heading
);
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
}
public void TestSourceInfo_BlockquoteAndList()
{
const string File = "test.md";
var gfm = new GfmEngineBuilder(new Options()).CreateEngine(new HtmlRenderer());
var tokens = gfm.Parser.Tokenize(
SourceInfo.Create(@"> blockquote
> [link text](sometarget)
>
> - list item 1
> - list item 1-1
> - list item 1-2
> - list item 2
>
> more para.
".Replace("\r\n", "\n"), File));
var rewriter =
new MarkdownRewriteEngine(
gfm,
MarkdownTokenRewriterFactory.FromLambda <IMarkdownRewriteEngine, TwoPhaseBlockToken>(
(e, t) => t.Extract(gfm.Parser)));
tokens = rewriter.Rewrite(tokens);
Assert.Equal(1, tokens.Length);
Assert.IsType <MarkdownBlockquoteBlockToken>(tokens[0]);
var blockquote = (MarkdownBlockquoteBlockToken)tokens[0];
Assert.Equal(3, blockquote.Tokens.Length);
Assert.Equal(1, blockquote.SourceInfo.LineNumber);
Assert.Equal(File, blockquote.SourceInfo.File);
Assert.IsType <MarkdownParagraphBlockToken>(blockquote.Tokens[0]);
{
var para = (MarkdownParagraphBlockToken)blockquote.Tokens[0];
Assert.Equal(1, para.SourceInfo.LineNumber);
Assert.Equal(File, para.SourceInfo.File);
Assert.Equal(2, para.InlineTokens.Tokens.Length);
Assert.IsType <MarkdownTextToken>(para.InlineTokens.Tokens[0]);
var text = (MarkdownTextToken)para.InlineTokens.Tokens[0];
Assert.Equal(1, text.SourceInfo.LineNumber);
Assert.Equal(File, text.SourceInfo.File);
Assert.IsType <MarkdownLinkInlineToken>(para.InlineTokens.Tokens[1]);
var link = (MarkdownLinkInlineToken)para.InlineTokens.Tokens[1];
Assert.Equal(2, link.SourceInfo.LineNumber);
Assert.Equal(File, link.SourceInfo.File);
}
Assert.IsType <MarkdownListBlockToken>(blockquote.Tokens[1]);
{
var list = (MarkdownListBlockToken)blockquote.Tokens[1];
Assert.Equal(4, list.SourceInfo.LineNumber);
Assert.Equal(File, list.SourceInfo.File);
Assert.Equal(2, list.Tokens.Length);
Assert.IsType <MarkdownListItemBlockToken>(list.Tokens[0]);
{
var listItem = (MarkdownListItemBlockToken)list.Tokens[0];
Assert.Equal(4, listItem.SourceInfo.LineNumber);
Assert.Equal(File, listItem.SourceInfo.File);
Assert.IsType <MarkdownNonParagraphBlockToken>(listItem.Tokens[0]);
var np = (MarkdownNonParagraphBlockToken)listItem.Tokens[0];
Assert.Equal(1, np.Content.Tokens.Length);
Assert.Equal(4, np.SourceInfo.LineNumber);
Assert.Equal(File, np.SourceInfo.File);
Assert.IsType <MarkdownListBlockToken>(listItem.Tokens[1]);
var subList = (MarkdownListBlockToken)listItem.Tokens[1];
Assert.Equal(2, subList.Tokens.Length);
Assert.IsType <MarkdownListItemBlockToken>(subList.Tokens[0]);
{
var subListItem = (MarkdownListItemBlockToken)subList.Tokens[0];
Assert.Equal(5, subListItem.SourceInfo.LineNumber);
Assert.Equal(File, subListItem.SourceInfo.File);
}
Assert.IsType <MarkdownListItemBlockToken>(subList.Tokens[1]);
{
var subListItem = (MarkdownListItemBlockToken)subList.Tokens[1];
Assert.Equal(6, subListItem.SourceInfo.LineNumber);
Assert.Equal(File, subListItem.SourceInfo.File);
}
}
Assert.IsType <MarkdownListItemBlockToken>(list.Tokens[1]);
{
var listItem = (MarkdownListItemBlockToken)list.Tokens[1];
Assert.Equal(7, listItem.SourceInfo.LineNumber);
Assert.Equal(File, listItem.SourceInfo.File);
}
}
Assert.IsType <MarkdownParagraphBlockToken>(blockquote.Tokens[2]);
{
var para = (MarkdownParagraphBlockToken)blockquote.Tokens[2];
Assert.Equal(9, para.SourceInfo.LineNumber);
Assert.Equal(File, para.SourceInfo.File);
}
}
public void TestSourceInfo_Basic()
{
const string File = "test.md";
var gfm = new GfmEngineBuilder(new Options()).CreateEngine(new HtmlRenderer());
var tokens = gfm.Parser.Tokenize(
SourceInfo.Create(@"
# HEAD1
First line.
More line.
## HEAD2
Yeah!".Replace("\r\n", "\n"), File));
var rewriter =
new MarkdownRewriteEngine(
gfm,
MarkdownTokenRewriterFactory.FromLambda <IMarkdownRewriteEngine, TwoPhaseBlockToken>(
(e, t) => t.Extract(gfm.Parser)));
tokens = rewriter.Rewrite(tokens);
Assert.Equal(5, tokens.Length);
Assert.IsType <MarkdownNewLineBlockToken>(tokens[0]);
Assert.IsType <MarkdownHeadingBlockToken>(tokens[1]);
Assert.IsType <MarkdownParagraphBlockToken>(tokens[2]);
Assert.IsType <MarkdownHeadingBlockToken>(tokens[3]);
Assert.IsType <MarkdownParagraphBlockToken>(tokens[4]);
var para = (MarkdownParagraphBlockToken)tokens[2];
Assert.Equal(3, para.InlineTokens.Tokens.Length);
Assert.IsType <MarkdownTextToken>(para.InlineTokens.Tokens[0]);
Assert.IsType <MarkdownBrInlineToken>(para.InlineTokens.Tokens[1]);
Assert.IsType <MarkdownTextToken>(para.InlineTokens.Tokens[2]);
Assert.Equal(1, tokens[0].SourceInfo.LineNumber);
Assert.Equal(File, tokens[0].SourceInfo.File);
Assert.Equal("\n\n", tokens[0].SourceInfo.Markdown);
Assert.Equal(3, tokens[1].SourceInfo.LineNumber);
Assert.Equal(File, tokens[1].SourceInfo.File);
Assert.Equal("# HEAD1\n", tokens[1].SourceInfo.Markdown);
Assert.Equal(4, tokens[2].SourceInfo.LineNumber);
Assert.Equal(File, tokens[2].SourceInfo.File);
Assert.Equal("First line. \nMore line.\n", tokens[2].SourceInfo.Markdown);
Assert.Equal(4, para.InlineTokens.Tokens[0].SourceInfo.LineNumber);
Assert.Equal(File, para.InlineTokens.Tokens[0].SourceInfo.File);
Assert.Equal("First line.", para.InlineTokens.Tokens[0].SourceInfo.Markdown);
Assert.Equal(4, para.InlineTokens.Tokens[1].SourceInfo.LineNumber);
Assert.Equal(File, para.InlineTokens.Tokens[1].SourceInfo.File);
Assert.Equal(" \n", para.InlineTokens.Tokens[1].SourceInfo.Markdown);
Assert.Equal(5, para.InlineTokens.Tokens[2].SourceInfo.LineNumber);
Assert.Equal(File, para.InlineTokens.Tokens[2].SourceInfo.File);
Assert.Equal("More line.", para.InlineTokens.Tokens[2].SourceInfo.Markdown);
Assert.Equal(6, tokens[3].SourceInfo.LineNumber);
Assert.Equal(File, tokens[3].SourceInfo.File);
Assert.Equal("## HEAD2\n", tokens[3].SourceInfo.Markdown);
Assert.Equal(7, tokens[4].SourceInfo.LineNumber);
Assert.Equal(File, tokens[4].SourceInfo.File);
Assert.Equal("Yeah!", tokens[4].SourceInfo.Markdown);
}
public void TestGfmWithValidatorWithParents()
{
const string source = @"# abc
> *abc*
- abc
abc
";
const string expected = @"<h1 id=""abc"">abc</h1>
<blockquote>
<p><em>abc</em></p>
</blockquote>
<ul>
<li>abc</li>
</ul>
<p>abc</p>
";
int headingTextCount = 0;
int blockquoteTextCount = 0;
int listTextCount = 0;
int paraTextCount = 0;
var builder = new GfmEngineBuilder(new Options());
builder.Rewriter =
MarkdownTokenRewriterFactory.FromValidators(
MarkdownTokenValidatorFactory.FromLambda(
(MarkdownTextToken token) =>
{
if (token.Content == "abc")
{
var re = MarkdownTokenValidatorContext.CurrentRewriteEngine;
foreach (var parent in re.GetParents())
{
if (parent is MarkdownHeadingBlockToken)
{
headingTextCount++;
}
else if (parent is MarkdownBlockquoteBlockToken)
{
blockquoteTextCount++;
}
else if (parent is MarkdownListItemBlockToken)
{
listTextCount++;
}
else if (parent is MarkdownParagraphBlockToken)
{
paraTextCount++;
}
}
}
}));
var engine = builder.CreateEngine(new HtmlRenderer());
var result = engine.Markup(source);
Assert.Equal(expected.Replace("\r\n", "\n"), result);
Assert.Equal(1, headingTextCount);
Assert.Equal(1, blockquoteTextCount);
Assert.Equal(1, listTextCount);
Assert.Equal(2, paraTextCount);
}
