9#include "clang/Basic/LLVM.h"
10#include "llvm/ADT/StringRef.h"
11#include "gmock/gmock.h"
12#include "gtest/gtest.h"
19std::string escape(llvm::StringRef
Text) {
23std::string dontEscape(llvm::StringRef
Text) {
28 return testing::ExplainMatchResult(::testing::HasSubstr(std::string{
'\\',
C}),
29 arg, result_listener);
33 return testing::ExplainMatchResult(::testing::Not(::testing::HasSubstr(
"\\")),
34 arg, result_listener);
37TEST(Render, Escaping) {
39 std::string
Punctuation = R
"txt(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)txt";
40 std::string EscapedPunc = R"txt(!"#$%&'()\*+,-./:;<=>?@[\\]^\_\`{|}~)txt";
44 EXPECT_EQ(escape(
"`foo`"), R
"(\`foo\`)");
45 EXPECT_EQ(escape("`foo"), R
"(\`foo)");
46 EXPECT_EQ(escape("foo`"), R
"(foo\`)");
47 EXPECT_EQ(escape("``foo``"), R
"(\`\`foo\`\`)");
49 EXPECT_EQ(escape(
"```"), R
"(\`\`\`)");
50 EXPECT_EQ(escape(
"~~~"), R
"(\~~~)");
53 EXPECT_THAT(escape(
"## Heading"), escaped(
'#'));
54 EXPECT_THAT(escape(
"Foo # bar"), escapedNone());
55 EXPECT_EQ(escape(
"---"), R
"(\---)");
56 EXPECT_EQ(escape("-"), R
"(\-)");
57 EXPECT_EQ(escape("==="), R
"(\===)");
58 EXPECT_EQ(escape("="), R
"(\=)");
59 EXPECT_EQ(escape("***"), R
"(\*\*\*)");
62 EXPECT_THAT(escape(
"<pre"), escaped(
'<'));
63 EXPECT_THAT(escape(
"< pre"), escapedNone());
64 EXPECT_THAT(escape(
"if a<b then"), escaped(
'<'));
65 EXPECT_THAT(escape(
"if a<b then c."), escapedNone());
66 EXPECT_THAT(escape(
"if a<b then c='foo'."), escaped(
'<'));
67 EXPECT_THAT(escape(
"std::vector<T>"), escaped(
'<'));
68 EXPECT_THAT(escape(
"std::vector<std::string>"), escaped(
'<'));
69 EXPECT_THAT(escape(
"std::map<int, int>"), escapedNone());
71 EXPECT_THAT(escape(
"Email <foo@bar.com>"), escapedNone());
72 EXPECT_THAT(escape(
"Website <http://foo.bar>"), escapedNone());
75 EXPECT_THAT(escape(
"- foo"), escaped(
'-'));
76 EXPECT_THAT(escape(
"* foo"), escaped(
'*'));
77 EXPECT_THAT(escape(
"+ foo"), escaped(
'+'));
78 EXPECT_THAT(escape(
"+"), escaped(
'+'));
79 EXPECT_THAT(escape(
"a + foo"), escapedNone());
80 EXPECT_THAT(escape(
"a+ foo"), escapedNone());
81 EXPECT_THAT(escape(
"1. foo"), escaped(
'.'));
82 EXPECT_THAT(escape(
"a. foo"), escapedNone());
85 EXPECT_EQ(escape(
"*foo*"), R
"(\*foo\*)");
86 EXPECT_EQ(escape("**foo**"), R
"(\*\*foo\*\*)");
87 EXPECT_THAT(escape("*foo"), escaped(
'*'));
88 EXPECT_THAT(escape(
"foo *"), escapedNone());
89 EXPECT_THAT(escape(
"foo * bar"), escapedNone());
90 EXPECT_THAT(escape(
"foo_bar"), escapedNone());
91 EXPECT_THAT(escape(
"foo _bar"), escaped(
'_'));
92 EXPECT_THAT(escape(
"foo_ bar"), escaped(
'_'));
93 EXPECT_THAT(escape(
"foo _ bar"), escapedNone());
96 EXPECT_THAT(escape(
"fish &chips;"), escaped(
'&'));
97 EXPECT_THAT(escape(
"fish & chips;"), escapedNone());
98 EXPECT_THAT(escape(
"fish &chips"), escapedNone());
99 EXPECT_THAT(escape(
"foo * bar"), escaped(
'&'));
100 EXPECT_THAT(escape(
"foo ¯ bar"), escaped(
'&'));
101 EXPECT_THAT(escape(
"foo &?; bar"), escapedNone());
104 EXPECT_THAT(escape(
"[foo](bar)"), escaped(
']'));
105 EXPECT_THAT(escape(
"[foo]: bar"), escaped(
']'));
107 EXPECT_THAT(escape(
"[foo][]"), escapedNone());
108 EXPECT_THAT(escape(
"[foo][bar]"), escapedNone());
109 EXPECT_THAT(escape(
"[foo]"), escapedNone());
113 P.appendCode(
"* foo !+ bar * baz");
114 EXPECT_EQ(
P.asEscapedMarkdown(),
"`* foo !+ bar * baz`");
118 P.appendCode(
"foo`bar`baz",
true);
119 EXPECT_EQ(
P.asEscapedMarkdown(),
"`foo``bar``baz`");
121 EXPECT_EQ(
P.asPlainText(),
"'foo`bar`baz'");
125 P.appendCode(
"`foo");
126 EXPECT_EQ(
P.asEscapedMarkdown(),
"` ``foo `");
128 P.appendCode(
"foo`");
129 EXPECT_EQ(
P.asEscapedMarkdown(),
"` foo`` `");
131 P.appendCode(
"`foo`");
132 EXPECT_EQ(
P.asEscapedMarkdown(),
"` ``foo`` `");
136 D.addCodeBlock(
"foobarbaz `\nqux");
137 EXPECT_EQ(
D.asEscapedMarkdown(),
"```cpp\n"
141 D.addCodeBlock(
"foobarbaz ``\nqux");
142 EXPECT_THAT(
D.asEscapedMarkdown(),
"```cpp\n"
143 "foobarbaz ``\nqux\n"
146 D.addCodeBlock(
"foobarbaz ```\nqux");
147 EXPECT_EQ(
D.asEscapedMarkdown(),
"````cpp\n"
148 "foobarbaz ```\nqux\n"
151 D.addCodeBlock(
"foobarbaz ` `` ``` ```` `\nqux");
152 EXPECT_EQ(
D.asEscapedMarkdown(),
"`````cpp\n"
153 "foobarbaz ` `` ``` ```` `\nqux\n"
157TEST(Render, NoEscaping) {
159 std::string
Punctuation = R
"txt(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)txt";
163 EXPECT_THAT(dontEscape(
"`foo`"), escapedNone());
164 EXPECT_THAT(dontEscape(
"`foo"), escapedNone());
165 EXPECT_THAT(dontEscape(
"foo`"), escapedNone());
166 EXPECT_THAT(dontEscape(
"``foo``"), escapedNone());
168 EXPECT_THAT(dontEscape(
"```"), escapedNone());
169 EXPECT_THAT(dontEscape(
"~~~"), escapedNone());
172 EXPECT_THAT(dontEscape(
"## Heading"), escapedNone());
173 EXPECT_THAT(dontEscape(
"Foo # bar"), escapedNone());
174 EXPECT_THAT(dontEscape(
"---"), escapedNone());
175 EXPECT_THAT(dontEscape(
"-"), escapedNone());
176 EXPECT_THAT(dontEscape(
"==="), escapedNone());
177 EXPECT_THAT(dontEscape(
"="), escapedNone());
178 EXPECT_THAT(dontEscape(
"***"), escapedNone());
181 EXPECT_THAT(dontEscape(
"<pre"), escaped(
'<'));
182 EXPECT_THAT(dontEscape(
"< pre"), escapedNone());
183 EXPECT_THAT(dontEscape(
"if a<b then"), escaped(
'<'));
184 EXPECT_THAT(dontEscape(
"if a<b then c."), escapedNone());
185 EXPECT_THAT(dontEscape(
"if a<b then c='foo'."), escaped(
'<'));
186 EXPECT_THAT(dontEscape(
"std::vector<T>"), escaped(
'<'));
187 EXPECT_THAT(dontEscape(
"std::vector<std::string>"), escaped(
'<'));
188 EXPECT_THAT(dontEscape(
"std::map<int, int>"), escapedNone());
190 EXPECT_THAT(dontEscape(
"Email <foo@bar.com>"), escapedNone());
191 EXPECT_THAT(dontEscape(
"Website <http://foo.bar>"), escapedNone());
194 EXPECT_THAT(dontEscape(
"- foo"), escapedNone());
195 EXPECT_THAT(dontEscape(
"* foo"), escapedNone());
196 EXPECT_THAT(dontEscape(
"+ foo"), escapedNone());
197 EXPECT_THAT(dontEscape(
"+"), escapedNone());
198 EXPECT_THAT(dontEscape(
"a + foo"), escapedNone());
199 EXPECT_THAT(dontEscape(
"a+ foo"), escapedNone());
200 EXPECT_THAT(dontEscape(
"1. foo"), escapedNone());
201 EXPECT_THAT(dontEscape(
"a. foo"), escapedNone());
204 EXPECT_THAT(dontEscape(
"*foo*"), escapedNone());
205 EXPECT_THAT(dontEscape(
"**foo**"), escapedNone());
206 EXPECT_THAT(dontEscape(
"*foo"), escapedNone());
207 EXPECT_THAT(dontEscape(
"foo *"), escapedNone());
208 EXPECT_THAT(dontEscape(
"foo * bar"), escapedNone());
209 EXPECT_THAT(dontEscape(
"foo_bar"), escapedNone());
210 EXPECT_THAT(dontEscape(
"foo _bar"), escapedNone());
211 EXPECT_THAT(dontEscape(
"foo_ bar"), escapedNone());
212 EXPECT_THAT(dontEscape(
"foo _ bar"), escapedNone());
215 EXPECT_THAT(dontEscape(
"fish &chips;"), escaped(
'&'));
216 EXPECT_THAT(dontEscape(
"fish & chips;"), escapedNone());
217 EXPECT_THAT(dontEscape(
"fish &chips"), escapedNone());
218 EXPECT_THAT(dontEscape(
"foo * bar"), escaped(
'&'));
219 EXPECT_THAT(dontEscape(
"foo ¯ bar"), escaped(
'&'));
220 EXPECT_THAT(dontEscape(
"foo &?; bar"), escapedNone());
223 EXPECT_THAT(dontEscape(
"[foo](bar)"), escapedNone());
224 EXPECT_THAT(dontEscape(
"[foo]: bar"), escapedNone());
226 EXPECT_THAT(dontEscape(
"[foo][]"), escapedNone());
227 EXPECT_THAT(dontEscape(
"[foo][bar]"), escapedNone());
228 EXPECT_THAT(dontEscape(
"[foo]"), escapedNone());
232 P.appendCode(
"* foo !+ bar * baz");
233 EXPECT_EQ(
P.asMarkdown(),
"`* foo !+ bar * baz`");
237 P.appendCode(
"foo`bar`baz",
true);
238 EXPECT_EQ(
P.asMarkdown(),
"`foo``bar``baz`");
242 P.appendCode(
"`foo");
243 EXPECT_EQ(
P.asMarkdown(),
"` ``foo `");
245 P.appendCode(
"foo`");
246 EXPECT_EQ(
P.asMarkdown(),
"` foo`` `");
248 P.appendCode(
"`foo`");
249 EXPECT_EQ(
P.asMarkdown(),
"` ``foo`` `");
253 D.addCodeBlock(
"foobarbaz `\nqux");
254 EXPECT_EQ(
D.asMarkdown(),
"```cpp\n"
258 D.addCodeBlock(
"foobarbaz ``\nqux");
259 EXPECT_THAT(
D.asMarkdown(),
"```cpp\n"
260 "foobarbaz ``\nqux\n"
263 D.addCodeBlock(
"foobarbaz ```\nqux");
264 EXPECT_EQ(
D.asMarkdown(),
"````cpp\n"
265 "foobarbaz ```\nqux\n"
268 D.addCodeBlock(
"foobarbaz ` `` ``` ```` `\nqux");
269 EXPECT_EQ(
D.asMarkdown(),
"`````cpp\n"
270 "foobarbaz ` `` ``` ```` `\nqux\n"
280 P.appendText(
"after ");
281 EXPECT_EQ(
P.asEscapedMarkdown(),
"after");
282 EXPECT_EQ(
P.asMarkdown(),
"after");
283 EXPECT_EQ(
P.asPlainText(),
"after");
285 P.appendCode(
"foobar").appendSpace();
286 EXPECT_EQ(
P.asEscapedMarkdown(),
"after `foobar`");
287 EXPECT_EQ(
P.asMarkdown(),
"after `foobar`");
288 EXPECT_EQ(
P.asPlainText(),
"after foobar");
291 EXPECT_EQ(
P.asEscapedMarkdown(),
"after `foobar` bat");
292 EXPECT_EQ(
P.asMarkdown(),
"after `foobar` bat");
293 EXPECT_EQ(
P.asPlainText(),
"after foobar bat");
295 P.appendCode(
"no").appendCode(
"space");
296 EXPECT_EQ(
P.asEscapedMarkdown(),
"after `foobar` bat`no` `space`");
297 EXPECT_EQ(
P.asMarkdown(),
"after `foobar` bat`no` `space`");
298 EXPECT_EQ(
P.asPlainText(),
"after foobar batno space");
300 P.appendText(
" text");
301 EXPECT_EQ(
P.asEscapedMarkdown(),
"after `foobar` bat`no` `space` text");
302 EXPECT_EQ(
P.asMarkdown(),
"after `foobar` bat`no` `space` text");
303 EXPECT_EQ(
P.asPlainText(),
"after foobar batno space text");
305 P.appendSpace().appendCode(
"code").appendText(
".\n newline");
306 EXPECT_EQ(
P.asEscapedMarkdown(),
307 "after `foobar` bat`no` `space` text `code`.\n newline");
308 EXPECT_EQ(
P.asMarkdown(),
309 "after `foobar` bat`no` `space` text `code`.\n newline");
310 EXPECT_EQ(
P.asPlainText(),
"after foobar batno space text code.\nnewline");
320 P.appendText(
"after ");
321 EXPECT_EQ(
P.asEscapedMarkdown(),
"after");
322 EXPECT_EQ(
P.asMarkdown(),
"after");
323 EXPECT_EQ(
P.asPlainText(),
"after");
325 P.appendText(
"foobar");
326 EXPECT_EQ(
P.asEscapedMarkdown(),
"after foobar");
327 EXPECT_EQ(
P.asMarkdown(),
"after foobar");
328 EXPECT_EQ(
P.asPlainText(),
"after foobar");
330 P.appendText(
" bat");
331 EXPECT_EQ(
P.asEscapedMarkdown(),
"after foobar bat");
332 EXPECT_EQ(
P.asMarkdown(),
"after foobar bat");
333 EXPECT_EQ(
P.asPlainText(),
"after foobar bat");
336 EXPECT_EQ(
P.asEscapedMarkdown(),
"after foobar batbaz");
337 EXPECT_EQ(
P.asMarkdown(),
"after foobar batbaz");
338 EXPECT_EQ(
P.asPlainText(),
"after foobar batbaz");
340 P.appendText(
" faz ");
341 EXPECT_EQ(
P.asEscapedMarkdown(),
"after foobar batbaz faz");
342 EXPECT_EQ(
P.asMarkdown(),
"after foobar batbaz faz");
343 EXPECT_EQ(
P.asPlainText(),
"after foobar batbaz faz");
345 P.appendText(
" bar ");
346 EXPECT_EQ(
P.asEscapedMarkdown(),
"after foobar batbaz faz bar");
347 EXPECT_EQ(
P.asMarkdown(),
"after foobar batbaz faz bar");
348 EXPECT_EQ(
P.asPlainText(),
"after foobar batbaz faz bar");
351 EXPECT_EQ(
P.asEscapedMarkdown(),
"after foobar batbaz faz bar qux");
352 EXPECT_EQ(
P.asMarkdown(),
"after foobar batbaz faz bar qux");
353 EXPECT_EQ(
P.asPlainText(),
"after foobar batbaz faz bar qux");
363 P.appendText(
"after \n");
364 EXPECT_EQ(
P.asEscapedMarkdown(),
"after");
365 EXPECT_EQ(
P.asMarkdown(),
"after");
366 EXPECT_EQ(
P.asPlainText(),
"after");
368 P.appendText(
" foobar\n");
369 EXPECT_EQ(
P.asEscapedMarkdown(),
"after \n foobar");
370 EXPECT_EQ(
P.asMarkdown(),
"after \n foobar");
371 EXPECT_EQ(
P.asPlainText(),
"after\nfoobar");
373 P.appendText(
"- bat\n");
374 EXPECT_EQ(
P.asEscapedMarkdown(),
"after \n foobar\n\\- bat");
375 EXPECT_EQ(
P.asMarkdown(),
"after \n foobar\n- bat");
376 EXPECT_EQ(
P.asPlainText(),
"after\nfoobar\n- bat");
378 P.appendText(
"- baz");
379 EXPECT_EQ(
P.asEscapedMarkdown(),
"after \n foobar\n\\- bat\n\\- baz");
380 EXPECT_EQ(
P.asMarkdown(),
"after \n foobar\n- bat\n- baz");
381 EXPECT_EQ(
P.asPlainText(),
"after\nfoobar\n- bat\n- baz");
383 P.appendText(
" faz ");
384 EXPECT_EQ(
P.asEscapedMarkdown(),
"after \n foobar\n\\- bat\n\\- baz faz");
385 EXPECT_EQ(
P.asMarkdown(),
"after \n foobar\n- bat\n- baz faz");
386 EXPECT_EQ(
P.asPlainText(),
"after\nfoobar\n- bat\n- baz faz");
393 P.appendText(
"foo\n \t baz");
394 P.appendCode(
" bar\n");
395 EXPECT_EQ(
P.asEscapedMarkdown(),
"foo\n \t baz`bar`");
396 EXPECT_EQ(
P.asMarkdown(),
"foo\n \t baz`bar`");
397 EXPECT_EQ(
P.asPlainText(),
"foo bazbar");
402 P.appendText(
" foo bar ");
403 P.appendText(
" baz ");
404 EXPECT_EQ(
P.asEscapedMarkdown(),
"foo bar baz");
405 EXPECT_EQ(
P.asMarkdown(),
"foo bar baz");
406 EXPECT_EQ(
P.asPlainText(),
"foo bar baz");
412 P.appendText(
" \n foo\nbar\n ");
413 P.appendCode(
" \n foo\nbar \n ");
414 EXPECT_EQ(
P.asEscapedMarkdown(),
"foo\nbar\n `foo bar`");
415 EXPECT_EQ(
P.asMarkdown(),
"foo\nbar\n `foo bar`");
416 EXPECT_EQ(
P.asPlainText(),
"foo bar foo bar");
421 P.appendBoldText(
"");
422 EXPECT_EQ(
P.asEscapedMarkdown(),
"");
423 EXPECT_EQ(
P.asMarkdown(),
"");
424 EXPECT_EQ(
P.asPlainText(),
"");
426 P.appendBoldText(
" \n foo\nbar\n ");
427 EXPECT_EQ(
P.asEscapedMarkdown(),
"\\*\\*foo bar\\*\\*");
428 EXPECT_EQ(
P.asMarkdown(),
"**foo bar**");
429 EXPECT_EQ(
P.asPlainText(),
"**foo bar**");
431 P.appendSpace().appendBoldText(
"foobar");
432 EXPECT_EQ(
P.asEscapedMarkdown(),
"\\*\\*foo bar\\*\\* \\*\\*foobar\\*\\*");
433 EXPECT_EQ(
P.asMarkdown(),
"**foo bar** **foobar**");
434 EXPECT_EQ(
P.asPlainText(),
"**foo bar** **foobar**");
439 P.appendEmphasizedText(
"");
440 EXPECT_EQ(
P.asEscapedMarkdown(),
"");
441 EXPECT_EQ(
P.asMarkdown(),
"");
442 EXPECT_EQ(
P.asPlainText(),
"");
444 P.appendEmphasizedText(
" \n foo\nbar\n ");
445 EXPECT_EQ(
P.asEscapedMarkdown(),
"\\*foo bar\\*");
446 EXPECT_EQ(
P.asMarkdown(),
"*foo bar*");
447 EXPECT_EQ(
P.asPlainText(),
"*foo bar*");
449 P.appendSpace().appendEmphasizedText(
"foobar");
450 EXPECT_EQ(
P.asEscapedMarkdown(),
"\\*foo bar\\* \\*foobar\\*");
451 EXPECT_EQ(
P.asMarkdown(),
"*foo bar* *foobar*");
452 EXPECT_EQ(
P.asPlainText(),
"*foo bar* *foobar*");
455TEST(Document, Separators) {
457 D.addParagraph().appendText(
"foo");
458 D.addCodeBlock(
"test");
459 D.addParagraph().appendText(
"bar");
461 const char ExpectedMarkdown[] = R
"md(foo
468 EXPECT_EQ(D.asEscapedMarkdown(), ExpectedMarkdown);
469 EXPECT_EQ(D.asMarkdown(), ExpectedMarkdown);
471 const char ExpectedText[] = R
"pt(foo
476 EXPECT_EQ(D.asPlainText(), ExpectedText);
479TEST(Document, Ruler) {
481 D.addParagraph().appendText("foo");
485 D.addParagraph().appendText(
"bar");
486 EXPECT_EQ(
D.asEscapedMarkdown(),
"foo\n\n---\nbar");
487 EXPECT_EQ(
D.asMarkdown(),
"foo\n\n---\nbar");
488 EXPECT_EQ(
D.asPlainText(),
"foo\n\nbar");
491 D.addParagraph().appendText(
"foo");
493 D.addCodeBlock(
"bar");
495 EXPECT_EQ(
D.asEscapedMarkdown(),
"foo\n\n---\n```cpp\nbar\n```");
496 EXPECT_EQ(
D.asMarkdown(),
"foo\n\n---\n```cpp\nbar\n```");
497 EXPECT_EQ(
D.asPlainText(),
"foo\n\nbar");
501 D.addParagraph().appendText(
"foo");
504 EXPECT_EQ(
D.asEscapedMarkdown(),
"foo");
505 EXPECT_EQ(
D.asMarkdown(),
"foo");
506 EXPECT_EQ(
D.asPlainText(),
"foo");
510 D.addParagraph().appendText(
"foo");
511 EXPECT_EQ(
D.asEscapedMarkdown(),
"foo\n\n---\nfoo");
512 EXPECT_EQ(
D.asMarkdown(),
"foo\n\n---\nfoo");
513 EXPECT_EQ(
D.asPlainText(),
"foo\n\nfoo");
516TEST(Document, Append) {
518 D.addParagraph().appendText(
"foo");
522 E.addParagraph().appendText(
"bar");
523 D.append(std::move(E));
524 EXPECT_EQ(
D.asEscapedMarkdown(),
"foo\n\n---\nbar");
525 EXPECT_EQ(
D.asMarkdown(),
"foo\n\n---\nbar");
528TEST(Document, Heading) {
530 D.addHeading(1).appendText(
"foo");
531 D.addHeading(2).appendText(
"bar");
532 D.addParagraph().appendText(
"baz");
533 EXPECT_EQ(
D.asEscapedMarkdown(),
"# foo\n\n## bar\n\nbaz");
534 EXPECT_EQ(
D.asMarkdown(),
"# foo\n\n## bar\n\nbaz");
535 EXPECT_EQ(
D.asPlainText(),
"foo\n\nbar\n\nbaz");
538TEST(CodeBlock, Render) {
541 D.addCodeBlock(
"foo\n bar\n baz");
543 llvm::StringRef ExpectedMarkdown =
549 llvm::StringRef ExpectedPlainText =
553 EXPECT_EQ(D.asEscapedMarkdown(), ExpectedMarkdown);
554 EXPECT_EQ(D.asMarkdown(), ExpectedMarkdown);
555 EXPECT_EQ(D.asPlainText(), ExpectedPlainText);
556 D.addCodeBlock("foo");
567 EXPECT_EQ(D.asEscapedMarkdown(), ExpectedMarkdown);
568 EXPECT_EQ(D.asMarkdown(), ExpectedMarkdown);
575 EXPECT_EQ(D.asPlainText(), ExpectedPlainText);
579 EXPECT_EQ(D2.asEscapedMarkdown(),
"```cpp\n```");
580 EXPECT_EQ(D2.asMarkdown(),
"```cpp\n```");
581 EXPECT_EQ(D2.asPlainText(),
"");
584TEST(BulletList, Render) {
587 L.addItem().addParagraph().appendText(
"foo");
588 EXPECT_EQ(L.asEscapedMarkdown(),
"- foo");
589 EXPECT_EQ(L.asMarkdown(),
"- foo");
590 EXPECT_EQ(L.asPlainText(),
"- foo");
592 L.addItem().addParagraph().appendText(
"bar");
593 llvm::StringRef Expected = R
"md(- foo
595 EXPECT_EQ(L.asEscapedMarkdown(), Expected);
596 EXPECT_EQ(L.asMarkdown(), Expected);
597 EXPECT_EQ(L.asPlainText(), Expected);
600 Document &
D = L.addItem();
602 D.addParagraph().appendText(
"foo");
603 D.addParagraph().appendText(
"baz");
606 Document &Inner =
D.addBulletList().addItem();
607 Inner.addParagraph().appendText(
"foo");
610 BulletList &InnerList = Inner.addBulletList();
612 Document &DeepDoc = InnerList.addItem();
613 DeepDoc.addParagraph().appendText(
"baz");
614 DeepDoc.addParagraph().appendText(
"baz");
615 StringRef ExpectedMarkdown = R
"md(- foo
626 EXPECT_EQ(L.asEscapedMarkdown(), ExpectedMarkdown);
627 EXPECT_EQ(L.asMarkdown(), ExpectedMarkdown);
628 StringRef ExpectedPlainText = R"pt(- foo
639 EXPECT_EQ(L.asPlainText(), ExpectedPlainText);
642 Inner.addParagraph().appendText(
"after");
643 ExpectedMarkdown = R
"md(- foo
656 EXPECT_EQ(L.asEscapedMarkdown(), ExpectedMarkdown);
657 EXPECT_EQ(L.asMarkdown(), ExpectedMarkdown);
658 ExpectedPlainText = R"pt(- foo
671 EXPECT_EQ(L.asPlainText(), ExpectedPlainText);
Represents parts of the markup that can contain strings, like inline code, code block or plain text.
std::string asMarkdown() const
Doesn't contain any trailing newlines.
Paragraph & appendText(llvm::StringRef Text)
Append plain text to the end of the string.
std::string asEscapedMarkdown() const
Doesn't contain any trailing newlines and escaped markdown syntax.
FIXME: Skip testing on windows temporarily due to the different escaping code mode.
TEST(BackgroundQueueTest, Priority)
cppcoreguidelines::ProBoundsAvoidUncheckedContainerAccess P
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//