clang-tools 22.0.0git
MarkupTests.cpp
Go to the documentation of this file.
1//===-- MarkupTests.cpp ---------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8#include "support/Markup.h"
9#include "clang/Basic/LLVM.h"
10#include "llvm/ADT/StringRef.h"
11#include "gmock/gmock.h"
12#include "gtest/gtest.h"
13
14namespace clang {
15namespace clangd {
16namespace markup {
17namespace {
18
19std::string escape(llvm::StringRef Text) {
20 return Paragraph().appendText(Text.str()).asEscapedMarkdown();
21}
22
23std::string dontEscape(llvm::StringRef Text) {
24 return Paragraph().appendText(Text.str()).asMarkdown();
25}
26
27MATCHER_P(escaped, C, "") {
28 return testing::ExplainMatchResult(::testing::HasSubstr(std::string{'\\', C}),
29 arg, result_listener);
30}
31
32MATCHER(escapedNone, "") {
33 return testing::ExplainMatchResult(::testing::Not(::testing::HasSubstr("\\")),
34 arg, result_listener);
35}
36
37TEST(Render, Escaping) {
38 // Check all ASCII punctuation.
39 std::string Punctuation = R"txt(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)txt";
40 std::string EscapedPunc = R"txt(!"#$%&'()\*+,-./:;<=>?@[\\]^\_\`{|}~)txt";
41 EXPECT_EQ(escape(Punctuation), EscapedPunc);
42
43 // Inline code
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\`\`)");
48 // Code blocks
49 EXPECT_EQ(escape("```"), R"(\`\`\`)"); // This could also be inline code!
50 EXPECT_EQ(escape("~~~"), R"(\~~~)");
51
52 // Rulers and headings
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"(\*\*\*)"); // \** could start emphasis!
60
61 // HTML tags.
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());
70 // Autolinks
71 EXPECT_THAT(escape("Email <foo@bar.com>"), escapedNone());
72 EXPECT_THAT(escape("Website <http://foo.bar>"), escapedNone());
73
74 // Bullet lists.
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());
83
84 // Emphasis.
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());
94
95 // HTML entities.
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 &#42; bar"), escaped('&'));
100 EXPECT_THAT(escape("foo &#xaf; bar"), escaped('&'));
101 EXPECT_THAT(escape("foo &?; bar"), escapedNone());
102
103 // Links.
104 EXPECT_THAT(escape("[foo](bar)"), escaped(']'));
105 EXPECT_THAT(escape("[foo]: bar"), escaped(']'));
106 // No need to escape these, as the target never exists.
107 EXPECT_THAT(escape("[foo][]"), escapedNone());
108 EXPECT_THAT(escape("[foo][bar]"), escapedNone());
109 EXPECT_THAT(escape("[foo]"), escapedNone());
110
111 // In code blocks we don't need to escape ASCII punctuation.
112 Paragraph P = Paragraph();
113 P.appendCode("* foo !+ bar * baz");
114 EXPECT_EQ(P.asEscapedMarkdown(), "`* foo !+ bar * baz`");
115
116 // But we have to escape the backticks.
117 P = Paragraph();
118 P.appendCode("foo`bar`baz", /*Preserve=*/true);
119 EXPECT_EQ(P.asEscapedMarkdown(), "`foo``bar``baz`");
120 // In plain-text, we fall back to different quotes.
121 EXPECT_EQ(P.asPlainText(), "'foo`bar`baz'");
122
123 // Inline code blocks starting or ending with backticks should add spaces.
124 P = Paragraph();
125 P.appendCode("`foo");
126 EXPECT_EQ(P.asEscapedMarkdown(), "` ``foo `");
127 P = Paragraph();
128 P.appendCode("foo`");
129 EXPECT_EQ(P.asEscapedMarkdown(), "` foo`` `");
130 P = Paragraph();
131 P.appendCode("`foo`");
132 EXPECT_EQ(P.asEscapedMarkdown(), "` ``foo`` `");
133
134 // Code blocks might need more than 3 backticks.
135 Document D;
136 D.addCodeBlock("foobarbaz `\nqux");
137 EXPECT_EQ(D.asEscapedMarkdown(), "```cpp\n"
138 "foobarbaz `\nqux\n"
139 "```");
140 D = Document();
141 D.addCodeBlock("foobarbaz ``\nqux");
142 EXPECT_THAT(D.asEscapedMarkdown(), "```cpp\n"
143 "foobarbaz ``\nqux\n"
144 "```");
145 D = Document();
146 D.addCodeBlock("foobarbaz ```\nqux");
147 EXPECT_EQ(D.asEscapedMarkdown(), "````cpp\n"
148 "foobarbaz ```\nqux\n"
149 "````");
150 D = Document();
151 D.addCodeBlock("foobarbaz ` `` ``` ```` `\nqux");
152 EXPECT_EQ(D.asEscapedMarkdown(), "`````cpp\n"
153 "foobarbaz ` `` ``` ```` `\nqux\n"
154 "`````");
155}
156
157TEST(Render, NoEscaping) {
158 // Check all ASCII punctuation.
159 std::string Punctuation = R"txt(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)txt";
160 EXPECT_EQ(dontEscape(Punctuation), Punctuation);
161
162 // Inline code
163 EXPECT_THAT(dontEscape("`foo`"), escapedNone());
164 EXPECT_THAT(dontEscape("`foo"), escapedNone());
165 EXPECT_THAT(dontEscape("foo`"), escapedNone());
166 EXPECT_THAT(dontEscape("``foo``"), escapedNone());
167 // Code blocks
168 EXPECT_THAT(dontEscape("```"), escapedNone());
169 EXPECT_THAT(dontEscape("~~~"), escapedNone());
170
171 // Rulers and headings
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()); // \** could start emphasis!
179
180 // HTML tags.
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());
189 // Autolinks
190 EXPECT_THAT(dontEscape("Email <foo@bar.com>"), escapedNone());
191 EXPECT_THAT(dontEscape("Website <http://foo.bar>"), escapedNone());
192
193 // Bullet lists.
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());
202
203 // Emphasis.
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());
213
214 // HTML entities.
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 &#42; bar"), escaped('&'));
219 EXPECT_THAT(dontEscape("foo &#xaf; bar"), escaped('&'));
220 EXPECT_THAT(dontEscape("foo &?; bar"), escapedNone());
221
222 // Links.
223 EXPECT_THAT(dontEscape("[foo](bar)"), escapedNone());
224 EXPECT_THAT(dontEscape("[foo]: bar"), escapedNone());
225 // No need to escape these, as the target never exists.
226 EXPECT_THAT(dontEscape("[foo][]"), escapedNone());
227 EXPECT_THAT(dontEscape("[foo][bar]"), escapedNone());
228 EXPECT_THAT(dontEscape("[foo]"), escapedNone());
229
230 // In code blocks we don't need to escape ASCII punctuation.
231 Paragraph P = Paragraph();
232 P.appendCode("* foo !+ bar * baz");
233 EXPECT_EQ(P.asMarkdown(), "`* foo !+ bar * baz`");
234
235 // But we have to escape the backticks.
236 P = Paragraph();
237 P.appendCode("foo`bar`baz", /*Preserve=*/true);
238 EXPECT_EQ(P.asMarkdown(), "`foo``bar``baz`");
239
240 // Inline code blocks starting or ending with backticks should add spaces.
241 P = Paragraph();
242 P.appendCode("`foo");
243 EXPECT_EQ(P.asMarkdown(), "` ``foo `");
244 P = Paragraph();
245 P.appendCode("foo`");
246 EXPECT_EQ(P.asMarkdown(), "` foo`` `");
247 P = Paragraph();
248 P.appendCode("`foo`");
249 EXPECT_EQ(P.asMarkdown(), "` ``foo`` `");
250
251 // Code blocks might need more than 3 backticks.
252 Document D;
253 D.addCodeBlock("foobarbaz `\nqux");
254 EXPECT_EQ(D.asMarkdown(), "```cpp\n"
255 "foobarbaz `\nqux\n"
256 "```");
257 D = Document();
258 D.addCodeBlock("foobarbaz ``\nqux");
259 EXPECT_THAT(D.asMarkdown(), "```cpp\n"
260 "foobarbaz ``\nqux\n"
261 "```");
262 D = Document();
263 D.addCodeBlock("foobarbaz ```\nqux");
264 EXPECT_EQ(D.asMarkdown(), "````cpp\n"
265 "foobarbaz ```\nqux\n"
266 "````");
267 D = Document();
268 D.addCodeBlock("foobarbaz ` `` ``` ```` `\nqux");
269 EXPECT_EQ(D.asMarkdown(), "`````cpp\n"
270 "foobarbaz ` `` ``` ```` `\nqux\n"
271 "`````");
272}
273
274TEST(Paragraph, SeparationOfChunks) {
275 // This test keeps appending contents to a single Paragraph and checks
276 // expected accumulated contents after each one.
277 // Purpose is to check for separation between different chunks.
278 Paragraph P;
279
280 P.appendText("after ");
281 EXPECT_EQ(P.asEscapedMarkdown(), "after");
282 EXPECT_EQ(P.asMarkdown(), "after");
283 EXPECT_EQ(P.asPlainText(), "after");
284
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");
289
290 P.appendText("bat");
291 EXPECT_EQ(P.asEscapedMarkdown(), "after `foobar` bat");
292 EXPECT_EQ(P.asMarkdown(), "after `foobar` bat");
293 EXPECT_EQ(P.asPlainText(), "after foobar bat");
294
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");
299
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");
304
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");
311}
312
313TEST(Paragraph, SeparationOfChunks2) {
314 // This test keeps appending contents to a single Paragraph and checks
315 // expected accumulated contents after each one.
316 // Purpose is to check for separation between different chunks
317 // where the spacing is in the appended string rather set by appendSpace.
318 Paragraph P;
319
320 P.appendText("after ");
321 EXPECT_EQ(P.asEscapedMarkdown(), "after");
322 EXPECT_EQ(P.asMarkdown(), "after");
323 EXPECT_EQ(P.asPlainText(), "after");
324
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");
329
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");
334
335 P.appendText("baz");
336 EXPECT_EQ(P.asEscapedMarkdown(), "after foobar batbaz");
337 EXPECT_EQ(P.asMarkdown(), "after foobar batbaz");
338 EXPECT_EQ(P.asPlainText(), "after foobar batbaz");
339
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");
344
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");
349
350 P.appendText("qux");
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");
354}
355
356TEST(Paragraph, SeparationOfChunks3) {
357 // This test keeps appending contents to a single Paragraph and checks
358 // expected accumulated contents after each one.
359 // Purpose is to check for separation between different chunks
360 // where the spacing is in the appended string rather set by appendSpace.
361 Paragraph P;
362
363 P.appendText("after \n");
364 EXPECT_EQ(P.asEscapedMarkdown(), "after");
365 EXPECT_EQ(P.asMarkdown(), "after");
366 EXPECT_EQ(P.asPlainText(), "after");
367
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");
372
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");
377
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");
382
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");
387}
388
389TEST(Paragraph, ExtraSpaces) {
390 // Make sure spaces inside chunks are preserved for markdown
391 // and dropped for plain text.
392 Paragraph P;
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");
398}
399
400TEST(Paragraph, SpacesCollapsed) {
401 Paragraph P;
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");
407}
408
409TEST(Paragraph, NewLines) {
410 // New lines before and after chunks are dropped.
411 Paragraph P;
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");
417}
418
419TEST(Paragraph, BoldText) {
420 Paragraph P;
421 P.appendBoldText("");
422 EXPECT_EQ(P.asEscapedMarkdown(), "");
423 EXPECT_EQ(P.asMarkdown(), "");
424 EXPECT_EQ(P.asPlainText(), "");
425
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**");
430
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**");
435}
436
437TEST(Paragraph, EmphasizedText) {
438 Paragraph P;
439 P.appendEmphasizedText("");
440 EXPECT_EQ(P.asEscapedMarkdown(), "");
441 EXPECT_EQ(P.asMarkdown(), "");
442 EXPECT_EQ(P.asPlainText(), "");
443
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*");
448
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*");
453}
454
455TEST(Document, Separators) {
456 Document D;
457 D.addParagraph().appendText("foo");
458 D.addCodeBlock("test");
459 D.addParagraph().appendText("bar");
460
461 const char ExpectedMarkdown[] = R"md(foo
462
463```cpp
464test
465```
466
467bar)md";
468 EXPECT_EQ(D.asEscapedMarkdown(), ExpectedMarkdown);
469 EXPECT_EQ(D.asMarkdown(), ExpectedMarkdown);
470
471 const char ExpectedText[] = R"pt(foo
472
473test
474
475bar)pt";
476 EXPECT_EQ(D.asPlainText(), ExpectedText);
477}
478
479TEST(Document, Ruler) {
480 Document D;
481 D.addParagraph().appendText("foo");
482 D.addRuler();
483
484 // Ruler followed by paragraph.
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");
489
490 D = Document();
491 D.addParagraph().appendText("foo");
492 D.addRuler();
493 D.addCodeBlock("bar");
494 // Ruler followed by a codeblock.
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");
498
499 // Ruler followed by another ruler
500 D = Document();
501 D.addParagraph().appendText("foo");
502 D.addRuler();
503 D.addRuler();
504 EXPECT_EQ(D.asEscapedMarkdown(), "foo");
505 EXPECT_EQ(D.asMarkdown(), "foo");
506 EXPECT_EQ(D.asPlainText(), "foo");
507
508 // Multiple rulers between blocks
509 D.addRuler();
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");
514}
515
516TEST(Document, Append) {
517 Document D;
518 D.addParagraph().appendText("foo");
519 D.addRuler();
520 Document E;
521 E.addRuler();
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");
526}
527
528TEST(Document, Heading) {
529 Document D;
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");
536}
537
538TEST(CodeBlock, Render) {
539 Document D;
540 // Code blocks preserves any extra spaces.
541 D.addCodeBlock("foo\n bar\n baz");
542
543 llvm::StringRef ExpectedMarkdown =
544 R"md(```cpp
545foo
546 bar
547 baz
548```)md";
549 llvm::StringRef ExpectedPlainText =
550 R"pt(foo
551 bar
552 baz)pt";
553 EXPECT_EQ(D.asEscapedMarkdown(), ExpectedMarkdown);
554 EXPECT_EQ(D.asMarkdown(), ExpectedMarkdown);
555 EXPECT_EQ(D.asPlainText(), ExpectedPlainText);
556 D.addCodeBlock("foo");
557 ExpectedMarkdown =
558 R"md(```cpp
559foo
560 bar
561 baz
562```
563
564```cpp
565foo
566```)md";
567 EXPECT_EQ(D.asEscapedMarkdown(), ExpectedMarkdown);
568 EXPECT_EQ(D.asMarkdown(), ExpectedMarkdown);
569 ExpectedPlainText =
570 R"pt(foo
571 bar
572 baz
573
574foo)pt";
575 EXPECT_EQ(D.asPlainText(), ExpectedPlainText);
576
577 Document D2;
578 D2.addCodeBlock("");
579 EXPECT_EQ(D2.asEscapedMarkdown(), "```cpp\n```");
580 EXPECT_EQ(D2.asMarkdown(), "```cpp\n```");
581 EXPECT_EQ(D2.asPlainText(), "");
582}
583
584TEST(BulletList, Render) {
585 BulletList L;
586 // Flat list
587 L.addItem().addParagraph().appendText("foo");
588 EXPECT_EQ(L.asEscapedMarkdown(), "- foo");
589 EXPECT_EQ(L.asMarkdown(), "- foo");
590 EXPECT_EQ(L.asPlainText(), "- foo");
591
592 L.addItem().addParagraph().appendText("bar");
593 llvm::StringRef Expected = R"md(- foo
594- bar)md";
595 EXPECT_EQ(L.asEscapedMarkdown(), Expected);
596 EXPECT_EQ(L.asMarkdown(), Expected);
597 EXPECT_EQ(L.asPlainText(), Expected);
598
599 // Nested list, with a single item.
600 Document &D = L.addItem();
601 // First item with 2 paragraphs - foo\n\n baz
602 D.addParagraph().appendText("foo");
603 D.addParagraph().appendText("baz");
604
605 // Nest one level.
606 Document &Inner = D.addBulletList().addItem();
607 Inner.addParagraph().appendText("foo");
608
609 // Nest one more level.
610 BulletList &InnerList = Inner.addBulletList();
611 // Single item, baz\nbaz
612 Document &DeepDoc = InnerList.addItem();
613 DeepDoc.addParagraph().appendText("baz");
614 DeepDoc.addParagraph().appendText("baz");
615 StringRef ExpectedMarkdown = R"md(- foo
616- bar
617- foo
618
619 baz
620
621 - foo
622
623 - baz
624
625 baz)md";
626 EXPECT_EQ(L.asEscapedMarkdown(), ExpectedMarkdown);
627 EXPECT_EQ(L.asMarkdown(), ExpectedMarkdown);
628 StringRef ExpectedPlainText = R"pt(- foo
629- bar
630- foo
631
632 baz
633
634 - foo
635
636 - baz
637
638 baz)pt";
639 EXPECT_EQ(L.asPlainText(), ExpectedPlainText);
640
641 // Termination
642 Inner.addParagraph().appendText("after");
643 ExpectedMarkdown = R"md(- foo
644- bar
645- foo
646
647 baz
648
649 - foo
650
651 - baz
652
653 baz
654
655 after)md";
656 EXPECT_EQ(L.asEscapedMarkdown(), ExpectedMarkdown);
657 EXPECT_EQ(L.asMarkdown(), ExpectedMarkdown);
658 ExpectedPlainText = R"pt(- foo
659- bar
660- foo
661
662 baz
663
664 - foo
665
666 - baz
667
668 baz
669
670 after)pt";
671 EXPECT_EQ(L.asPlainText(), ExpectedPlainText);
672}
673
674} // namespace
675} // namespace markup
676} // namespace clangd
677} // namespace clang
clang::clangd::markup::Paragraph
Represents parts of the markup that can contain strings, like inline code, code block or plain text.
Definition Markup.h:45
clang::clangd::markup::Paragraph::asMarkdown
std::string asMarkdown() const
Doesn't contain any trailing newlines.
clang::clangd::markup::Paragraph::appendText
Paragraph & appendText(llvm::StringRef Text)
Append plain text to the end of the string.
Definition Markup.cpp:721
clang::clangd::markup::Paragraph::asEscapedMarkdown
std::string asEscapedMarkdown() const
Doesn't contain any trailing newlines and escaped markdown syntax.
clang::clangd
FIXME: Skip testing on windows temporarily due to the different escaping code mode.
Definition AST.cpp:45
clang::clangd::MATCHER_P
MATCHER_P(named, N, "")
Definition BackgroundIndexTests.cpp:30
clang::clangd::TEST
TEST(BackgroundQueueTest, Priority)
Definition BackgroundIndexTests.cpp:706
clang::tidy::P
cppcoreguidelines::ProBoundsAvoidUncheckedContainerAccess P
Definition ProBoundsAvoidUncheckedContainerAccess.cpp:254
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition ApplyReplacements.h:27
Generated on for clang-tools by doxygen 1.14.0