blob: 507daf8391312429f6fd82a59b9f415d58d07e73 [file] [log] [blame]
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001//===- unittests/AST/CommentLexer.cpp ------ Comment lexer tests ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Chandler Carruth1050e8b2012-12-04 09:45:34 +000010#include "clang/AST/CommentLexer.h"
Chandler Carruth1050e8b2012-12-04 09:45:34 +000011#include "clang/AST/CommentCommandTraits.h"
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +000012#include "clang/Basic/CommentOptions.h"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +000013#include "clang/Basic/Diagnostic.h"
Douglas Gregor3aeb34f2012-10-23 22:38:58 +000014#include "clang/Basic/DiagnosticOptions.h"
Chandler Carruth1050e8b2012-12-04 09:45:34 +000015#include "clang/Basic/FileManager.h"
Chandler Carruth7cc315c2012-12-04 09:53:37 +000016#include "clang/Basic/SourceManager.h"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +000017#include "llvm/ADT/STLExtras.h"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +000018#include "gtest/gtest.h"
Chandler Carruth1050e8b2012-12-04 09:45:34 +000019#include <vector>
Dmitri Gribenko2d44d772012-06-26 20:39:18 +000020
21using namespace llvm;
22using namespace clang;
23
24namespace clang {
25namespace comments {
26
27namespace {
28class CommentLexerTest : public ::testing::Test {
29protected:
30 CommentLexerTest()
31 : FileMgr(FileMgrOpts),
32 DiagID(new DiagnosticIDs()),
Douglas Gregor8e023612012-10-23 22:31:51 +000033 Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +000034 SourceMgr(Diags, FileMgr),
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +000035 Traits(Allocator, CommentOptions()) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +000036 }
37
38 FileSystemOptions FileMgrOpts;
39 FileManager FileMgr;
40 IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
41 DiagnosticsEngine Diags;
42 SourceManager SourceMgr;
Dmitri Gribenko477a9f52012-07-27 20:37:06 +000043 llvm::BumpPtrAllocator Allocator;
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +000044 CommandTraits Traits;
Dmitri Gribenko2d44d772012-06-26 20:39:18 +000045
46 void lexString(const char *Source, std::vector<Token> &Toks);
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +000047
48 StringRef getCommandName(const Token &Tok) {
49 return Traits.getCommandInfo(Tok.getCommandID())->Name;
50 }
51
52 StringRef getVerbatimBlockName(const Token &Tok) {
53 return Traits.getCommandInfo(Tok.getVerbatimBlockID())->Name;
54 }
55
56 StringRef getVerbatimLineName(const Token &Tok) {
57 return Traits.getCommandInfo(Tok.getVerbatimLineID())->Name;
58 }
Dmitri Gribenko2d44d772012-06-26 20:39:18 +000059};
60
61void CommentLexerTest::lexString(const char *Source,
62 std::vector<Token> &Toks) {
63 MemoryBuffer *Buf = MemoryBuffer::getMemBuffer(Source);
64 FileID File = SourceMgr.createFileIDForMemBuffer(Buf);
65 SourceLocation Begin = SourceMgr.getLocForStartOfFile(File);
66
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +000067 Lexer L(Allocator, Traits, Begin, Source, Source + strlen(Source));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +000068
69 while (1) {
70 Token Tok;
71 L.lex(Tok);
72 if (Tok.is(tok::eof))
73 break;
74 Toks.push_back(Tok);
75 }
76}
77
78} // unnamed namespace
79
80// Empty source range should be handled.
81TEST_F(CommentLexerTest, Basic1) {
82 const char *Source = "";
83 std::vector<Token> Toks;
84
85 lexString(Source, Toks);
86
87 ASSERT_EQ(0U, Toks.size());
88}
89
90// Empty comments should be handled.
91TEST_F(CommentLexerTest, Basic2) {
92 const char *Sources[] = {
93 "//", "///", "//!", "///<", "//!<"
94 };
95 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
96 std::vector<Token> Toks;
97
98 lexString(Sources[i], Toks);
99
100 ASSERT_EQ(1U, Toks.size());
101
102 ASSERT_EQ(tok::newline, Toks[0].getKind());
103 }
104}
105
106// Empty comments should be handled.
107TEST_F(CommentLexerTest, Basic3) {
108 const char *Sources[] = {
109 "/**/", "/***/", "/*!*/", "/**<*/", "/*!<*/"
110 };
111 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
112 std::vector<Token> Toks;
113
114 lexString(Sources[i], Toks);
115
116 ASSERT_EQ(2U, Toks.size());
117
118 ASSERT_EQ(tok::newline, Toks[0].getKind());
119 ASSERT_EQ(tok::newline, Toks[1].getKind());
120 }
121}
122
123// Single comment with plain text.
124TEST_F(CommentLexerTest, Basic4) {
125 const char *Sources[] = {
126 "// Meow", "/// Meow", "//! Meow",
127 "// Meow\n", "// Meow\r\n", "//! Meow\r",
128 };
129
130 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
131 std::vector<Token> Toks;
132
133 lexString(Sources[i], Toks);
134
135 ASSERT_EQ(2U, Toks.size());
136
137 ASSERT_EQ(tok::text, Toks[0].getKind());
138 ASSERT_EQ(StringRef(" Meow"), Toks[0].getText());
139
140 ASSERT_EQ(tok::newline, Toks[1].getKind());
141 }
142}
143
144// Single comment with plain text.
145TEST_F(CommentLexerTest, Basic5) {
146 const char *Sources[] = {
147 "/* Meow*/", "/** Meow*/", "/*! Meow*/"
148 };
149
150 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
151 std::vector<Token> Toks;
152
153 lexString(Sources[i], Toks);
154
155 ASSERT_EQ(3U, Toks.size());
156
157 ASSERT_EQ(tok::text, Toks[0].getKind());
158 ASSERT_EQ(StringRef(" Meow"), Toks[0].getText());
159
160 ASSERT_EQ(tok::newline, Toks[1].getKind());
161 ASSERT_EQ(tok::newline, Toks[2].getKind());
162 }
163}
164
165// Test newline escaping.
166TEST_F(CommentLexerTest, Basic6) {
167 const char *Sources[] = {
168 "// Aaa\\\n" " Bbb\\ \n" " Ccc?" "?/\n",
169 "// Aaa\\\r\n" " Bbb\\ \r\n" " Ccc?" "?/\r\n",
170 "// Aaa\\\r" " Bbb\\ \r" " Ccc?" "?/\r"
171 };
172
173 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
174 std::vector<Token> Toks;
175
176 lexString(Sources[i], Toks);
177
178 ASSERT_EQ(10U, Toks.size());
179
180 ASSERT_EQ(tok::text, Toks[0].getKind());
181 ASSERT_EQ(StringRef(" Aaa"), Toks[0].getText());
182 ASSERT_EQ(tok::text, Toks[1].getKind());
183 ASSERT_EQ(StringRef("\\"), Toks[1].getText());
184 ASSERT_EQ(tok::newline, Toks[2].getKind());
185
186 ASSERT_EQ(tok::text, Toks[3].getKind());
187 ASSERT_EQ(StringRef(" Bbb"), Toks[3].getText());
188 ASSERT_EQ(tok::text, Toks[4].getKind());
189 ASSERT_EQ(StringRef("\\"), Toks[4].getText());
190 ASSERT_EQ(tok::text, Toks[5].getKind());
191 ASSERT_EQ(StringRef(" "), Toks[5].getText());
192 ASSERT_EQ(tok::newline, Toks[6].getKind());
193
194 ASSERT_EQ(tok::text, Toks[7].getKind());
195 ASSERT_EQ(StringRef(" Ccc?" "?/"), Toks[7].getText());
196 ASSERT_EQ(tok::newline, Toks[8].getKind());
197
198 ASSERT_EQ(tok::newline, Toks[9].getKind());
199 }
200}
201
202// Check that we skip C-style aligned stars correctly.
203TEST_F(CommentLexerTest, Basic7) {
204 const char *Source =
205 "/* Aaa\n"
206 " * Bbb\r\n"
207 "\t* Ccc\n"
208 " ! Ddd\n"
209 " * Eee\n"
210 " ** Fff\n"
211 " */";
212 std::vector<Token> Toks;
213
214 lexString(Source, Toks);
215
216 ASSERT_EQ(15U, Toks.size());
217
218 ASSERT_EQ(tok::text, Toks[0].getKind());
219 ASSERT_EQ(StringRef(" Aaa"), Toks[0].getText());
220 ASSERT_EQ(tok::newline, Toks[1].getKind());
221
222 ASSERT_EQ(tok::text, Toks[2].getKind());
223 ASSERT_EQ(StringRef(" Bbb"), Toks[2].getText());
224 ASSERT_EQ(tok::newline, Toks[3].getKind());
225
226 ASSERT_EQ(tok::text, Toks[4].getKind());
227 ASSERT_EQ(StringRef(" Ccc"), Toks[4].getText());
228 ASSERT_EQ(tok::newline, Toks[5].getKind());
229
230 ASSERT_EQ(tok::text, Toks[6].getKind());
231 ASSERT_EQ(StringRef(" ! Ddd"), Toks[6].getText());
232 ASSERT_EQ(tok::newline, Toks[7].getKind());
233
234 ASSERT_EQ(tok::text, Toks[8].getKind());
235 ASSERT_EQ(StringRef(" Eee"), Toks[8].getText());
236 ASSERT_EQ(tok::newline, Toks[9].getKind());
237
238 ASSERT_EQ(tok::text, Toks[10].getKind());
239 ASSERT_EQ(StringRef("* Fff"), Toks[10].getText());
240 ASSERT_EQ(tok::newline, Toks[11].getKind());
241
242 ASSERT_EQ(tok::text, Toks[12].getKind());
243 ASSERT_EQ(StringRef(" "), Toks[12].getText());
244
245 ASSERT_EQ(tok::newline, Toks[13].getKind());
246 ASSERT_EQ(tok::newline, Toks[14].getKind());
247}
248
249// A command marker followed by comment end.
250TEST_F(CommentLexerTest, DoxygenCommand1) {
251 const char *Sources[] = { "//@", "///@", "//!@" };
252 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
253 std::vector<Token> Toks;
254
255 lexString(Sources[i], Toks);
256
257 ASSERT_EQ(2U, Toks.size());
258
259 ASSERT_EQ(tok::text, Toks[0].getKind());
260 ASSERT_EQ(StringRef("@"), Toks[0].getText());
261
262 ASSERT_EQ(tok::newline, Toks[1].getKind());
263 }
264}
265
266// A command marker followed by comment end.
267TEST_F(CommentLexerTest, DoxygenCommand2) {
268 const char *Sources[] = { "/*@*/", "/**@*/", "/*!@*/"};
269 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
270 std::vector<Token> Toks;
271
272 lexString(Sources[i], Toks);
273
274 ASSERT_EQ(3U, Toks.size());
275
276 ASSERT_EQ(tok::text, Toks[0].getKind());
277 ASSERT_EQ(StringRef("@"), Toks[0].getText());
278
279 ASSERT_EQ(tok::newline, Toks[1].getKind());
280 ASSERT_EQ(tok::newline, Toks[2].getKind());
281 }
282}
283
284// A command marker followed by comment end.
285TEST_F(CommentLexerTest, DoxygenCommand3) {
286 const char *Sources[] = { "/*\\*/", "/**\\*/" };
287 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
288 std::vector<Token> Toks;
289
290 lexString(Sources[i], Toks);
291
292 ASSERT_EQ(3U, Toks.size());
293
294 ASSERT_EQ(tok::text, Toks[0].getKind());
295 ASSERT_EQ(StringRef("\\"), Toks[0].getText());
296
297 ASSERT_EQ(tok::newline, Toks[1].getKind());
298 ASSERT_EQ(tok::newline, Toks[2].getKind());
299 }
300}
301
302// Doxygen escape sequences.
303TEST_F(CommentLexerTest, DoxygenCommand4) {
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000304 const char *Sources[] = {
305 "/// \\\\ \\@ \\& \\$ \\# \\< \\> \\% \\\" \\. \\::",
306 "/// @\\ @@ @& @$ @# @< @> @% @\" @. @::"
307 };
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000308 const char *Text[] = {
309 " ",
310 "\\", " ", "@", " ", "&", " ", "$", " ", "#", " ",
311 "<", " ", ">", " ", "%", " ", "\"", " ", ".", " ",
312 "::", ""
313 };
314
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000315 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
316 std::vector<Token> Toks;
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000317
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000318 lexString(Sources[i], Toks);
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000319
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000320 ASSERT_EQ(array_lengthof(Text), Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000321
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000322 for (size_t j = 0, e = Toks.size(); j != e; j++) {
323 if(Toks[j].is(tok::text))
324 ASSERT_EQ(StringRef(Text[j]), Toks[j].getText())
325 << "index " << i;
326 }
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000327 }
328}
329
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000330// A command marker followed by a non-letter that is not a part of an escape
331// sequence.
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000332TEST_F(CommentLexerTest, DoxygenCommand5) {
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000333 const char *Source = "/// \\^ \\0";
334 std::vector<Token> Toks;
335
336 lexString(Source, Toks);
337
338 ASSERT_EQ(6U, Toks.size());
339
340 ASSERT_EQ(tok::text, Toks[0].getKind());
341 ASSERT_EQ(StringRef(" "), Toks[0].getText());
342
343 ASSERT_EQ(tok::text, Toks[1].getKind());
344 ASSERT_EQ(StringRef("\\"), Toks[1].getText());
345
346 ASSERT_EQ(tok::text, Toks[2].getKind());
347 ASSERT_EQ(StringRef("^ "), Toks[2].getText());
348
349 ASSERT_EQ(tok::text, Toks[3].getKind());
350 ASSERT_EQ(StringRef("\\"), Toks[3].getText());
351
352 ASSERT_EQ(tok::text, Toks[4].getKind());
353 ASSERT_EQ(StringRef("0"), Toks[4].getText());
354
355 ASSERT_EQ(tok::newline, Toks[5].getKind());
356}
357
358TEST_F(CommentLexerTest, DoxygenCommand6) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000359 const char *Source = "/// \\brief Aaa.";
360 std::vector<Token> Toks;
361
362 lexString(Source, Toks);
363
364 ASSERT_EQ(4U, Toks.size());
365
366 ASSERT_EQ(tok::text, Toks[0].getKind());
367 ASSERT_EQ(StringRef(" "), Toks[0].getText());
368
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000369 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000370 ASSERT_EQ(StringRef("brief"), getCommandName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000371
372 ASSERT_EQ(tok::text, Toks[2].getKind());
373 ASSERT_EQ(StringRef(" Aaa."), Toks[2].getText());
374
375 ASSERT_EQ(tok::newline, Toks[3].getKind());
376}
377
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000378TEST_F(CommentLexerTest, DoxygenCommand7) {
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000379 const char *Source = "/// \\em\\em \\em\t\\em\n";
380 std::vector<Token> Toks;
381
382 lexString(Source, Toks);
383
384 ASSERT_EQ(8U, Toks.size());
385
386 ASSERT_EQ(tok::text, Toks[0].getKind());
387 ASSERT_EQ(StringRef(" "), Toks[0].getText());
388
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000389 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000390 ASSERT_EQ(StringRef("em"), getCommandName(Toks[1]));
391
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000392 ASSERT_EQ(tok::backslash_command, Toks[2].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000393 ASSERT_EQ(StringRef("em"), getCommandName(Toks[2]));
394
395 ASSERT_EQ(tok::text, Toks[3].getKind());
396 ASSERT_EQ(StringRef(" "), Toks[3].getText());
397
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000398 ASSERT_EQ(tok::backslash_command, Toks[4].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000399 ASSERT_EQ(StringRef("em"), getCommandName(Toks[4]));
400
401 ASSERT_EQ(tok::text, Toks[5].getKind());
402 ASSERT_EQ(StringRef("\t"), Toks[5].getText());
403
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000404 ASSERT_EQ(tok::backslash_command, Toks[6].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000405 ASSERT_EQ(StringRef("em"), getCommandName(Toks[6]));
406
407 ASSERT_EQ(tok::newline, Toks[7].getKind());
408}
409
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000410TEST_F(CommentLexerTest, DoxygenCommand8) {
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000411 const char *Source = "/// @em@em @em\t@em\n";
412 std::vector<Token> Toks;
413
414 lexString(Source, Toks);
415
416 ASSERT_EQ(8U, Toks.size());
417
418 ASSERT_EQ(tok::text, Toks[0].getKind());
419 ASSERT_EQ(StringRef(" "), Toks[0].getText());
420
421 ASSERT_EQ(tok::at_command, Toks[1].getKind());
422 ASSERT_EQ(StringRef("em"), getCommandName(Toks[1]));
423
424 ASSERT_EQ(tok::at_command, Toks[2].getKind());
425 ASSERT_EQ(StringRef("em"), getCommandName(Toks[2]));
426
427 ASSERT_EQ(tok::text, Toks[3].getKind());
428 ASSERT_EQ(StringRef(" "), Toks[3].getText());
429
430 ASSERT_EQ(tok::at_command, Toks[4].getKind());
431 ASSERT_EQ(StringRef("em"), getCommandName(Toks[4]));
432
433 ASSERT_EQ(tok::text, Toks[5].getKind());
434 ASSERT_EQ(StringRef("\t"), Toks[5].getText());
435
436 ASSERT_EQ(tok::at_command, Toks[6].getKind());
437 ASSERT_EQ(StringRef("em"), getCommandName(Toks[6]));
438
439 ASSERT_EQ(tok::newline, Toks[7].getKind());
440}
441
442TEST_F(CommentLexerTest, DoxygenCommand9) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000443 const char *Source = "/// \\aaa\\bbb \\ccc\t\\ddd\n";
444 std::vector<Token> Toks;
445
446 lexString(Source, Toks);
447
448 ASSERT_EQ(8U, Toks.size());
449
450 ASSERT_EQ(tok::text, Toks[0].getKind());
451 ASSERT_EQ(StringRef(" "), Toks[0].getText());
452
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000453 ASSERT_EQ(tok::unknown_command, Toks[1].getKind());
454 ASSERT_EQ(StringRef("aaa"), Toks[1].getUnknownCommandName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000455
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000456 ASSERT_EQ(tok::unknown_command, Toks[2].getKind());
457 ASSERT_EQ(StringRef("bbb"), Toks[2].getUnknownCommandName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000458
459 ASSERT_EQ(tok::text, Toks[3].getKind());
460 ASSERT_EQ(StringRef(" "), Toks[3].getText());
461
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000462 ASSERT_EQ(tok::unknown_command, Toks[4].getKind());
463 ASSERT_EQ(StringRef("ccc"), Toks[4].getUnknownCommandName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000464
465 ASSERT_EQ(tok::text, Toks[5].getKind());
466 ASSERT_EQ(StringRef("\t"), Toks[5].getText());
467
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000468 ASSERT_EQ(tok::unknown_command, Toks[6].getKind());
469 ASSERT_EQ(StringRef("ddd"), Toks[6].getUnknownCommandName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000470
471 ASSERT_EQ(tok::newline, Toks[7].getKind());
472}
473
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000474TEST_F(CommentLexerTest, DoxygenCommand10) {
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000475 const char *Source = "// \\c\n";
476 std::vector<Token> Toks;
477
478 lexString(Source, Toks);
479
480 ASSERT_EQ(3U, Toks.size());
481
482 ASSERT_EQ(tok::text, Toks[0].getKind());
483 ASSERT_EQ(StringRef(" "), Toks[0].getText());
484
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000485 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000486 ASSERT_EQ(StringRef("c"), getCommandName(Toks[1]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000487
488 ASSERT_EQ(tok::newline, Toks[2].getKind());
489}
490
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000491TEST_F(CommentLexerTest, RegisterCustomBlockCommand) {
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000492 const char *Source =
493 "/// \\NewBlockCommand Aaa.\n"
494 "/// @NewBlockCommand Aaa.\n";
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000495
496 Traits.registerBlockCommand(StringRef("NewBlockCommand"));
497
498 std::vector<Token> Toks;
499
500 lexString(Source, Toks);
501
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000502 ASSERT_EQ(8U, Toks.size());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000503
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000504 ASSERT_EQ(tok::text, Toks[0].getKind());
505 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000506
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000507 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000508 ASSERT_EQ(StringRef("NewBlockCommand"), getCommandName(Toks[1]));
509
510 ASSERT_EQ(tok::text, Toks[2].getKind());
511 ASSERT_EQ(StringRef(" Aaa."), Toks[2].getText());
512
Dmitri Gribenko808383d2013-03-04 23:06:15 +0000513 ASSERT_EQ(tok::newline, Toks[3].getKind());
514
515 ASSERT_EQ(tok::text, Toks[4].getKind());
516 ASSERT_EQ(StringRef(" "), Toks[4].getText());
517
518 ASSERT_EQ(tok::at_command, Toks[5].getKind());
519 ASSERT_EQ(StringRef("NewBlockCommand"), getCommandName(Toks[5]));
520
521 ASSERT_EQ(tok::text, Toks[6].getKind());
522 ASSERT_EQ(StringRef(" Aaa."), Toks[6].getText());
523
524 ASSERT_EQ(tok::newline, Toks[7].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000525}
526
527TEST_F(CommentLexerTest, RegisterMultipleBlockCommands) {
528 const char *Source =
529 "/// \\Foo\n"
530 "/// \\Bar Baz\n"
531 "/// \\Blech quux=corge\n";
532
533 Traits.registerBlockCommand(StringRef("Foo"));
534 Traits.registerBlockCommand(StringRef("Bar"));
535 Traits.registerBlockCommand(StringRef("Blech"));
536
537 std::vector<Token> Toks;
538
539 lexString(Source, Toks);
540
541 ASSERT_EQ(11U, Toks.size());
542
543 ASSERT_EQ(tok::text, Toks[0].getKind());
544 ASSERT_EQ(StringRef(" "), Toks[0].getText());
545
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000546 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000547 ASSERT_EQ(StringRef("Foo"), getCommandName(Toks[1]));
548
549 ASSERT_EQ(tok::newline, Toks[2].getKind());
550
551 ASSERT_EQ(tok::text, Toks[3].getKind());
552 ASSERT_EQ(StringRef(" "), Toks[3].getText());
553
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000554 ASSERT_EQ(tok::backslash_command, Toks[4].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000555 ASSERT_EQ(StringRef("Bar"), getCommandName(Toks[4]));
556
557 ASSERT_EQ(tok::text, Toks[5].getKind());
558 ASSERT_EQ(StringRef(" Baz"), Toks[5].getText());
559
560 ASSERT_EQ(tok::newline, Toks[6].getKind());
561
562 ASSERT_EQ(tok::text, Toks[7].getKind());
563 ASSERT_EQ(StringRef(" "), Toks[7].getText());
564
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000565 ASSERT_EQ(tok::backslash_command, Toks[8].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000566 ASSERT_EQ(StringRef("Blech"), getCommandName(Toks[8]));
567
568 ASSERT_EQ(tok::text, Toks[9].getKind());
569 ASSERT_EQ(StringRef(" quux=corge"), Toks[9].getText());
570
571 ASSERT_EQ(tok::newline, Toks[10].getKind());
572}
573
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000574// Empty verbatim block.
575TEST_F(CommentLexerTest, VerbatimBlock1) {
576 const char *Sources[] = {
577 "/// \\verbatim\\endverbatim\n//",
578 "/** \\verbatim\\endverbatim*/"
579 };
580
581 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
582 std::vector<Token> Toks;
583
584 lexString(Sources[i], Toks);
585
586 ASSERT_EQ(5U, Toks.size());
587
588 ASSERT_EQ(tok::text, Toks[0].getKind());
589 ASSERT_EQ(StringRef(" "), Toks[0].getText());
590
591 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000592 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000593
594 ASSERT_EQ(tok::verbatim_block_end, Toks[2].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000595 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[2]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000596
597 ASSERT_EQ(tok::newline, Toks[3].getKind());
598 ASSERT_EQ(tok::newline, Toks[4].getKind());
599 }
600}
601
602// Empty verbatim block without an end command.
603TEST_F(CommentLexerTest, VerbatimBlock2) {
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000604 const char *Source = "/// \\verbatim";
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000605
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000606 std::vector<Token> Toks;
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000607
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000608 lexString(Source, Toks);
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000609
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000610 ASSERT_EQ(3U, Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000611
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000612 ASSERT_EQ(tok::text, Toks[0].getKind());
613 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000614
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000615 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000616 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000617
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000618 ASSERT_EQ(tok::newline, Toks[2].getKind());
619}
620
621// Empty verbatim block without an end command.
622TEST_F(CommentLexerTest, VerbatimBlock3) {
623 const char *Source = "/** \\verbatim*/";
624
625 std::vector<Token> Toks;
626
627 lexString(Source, Toks);
628
629 ASSERT_EQ(4U, Toks.size());
630
631 ASSERT_EQ(tok::text, Toks[0].getKind());
632 ASSERT_EQ(StringRef(" "), Toks[0].getText());
633
634 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000635 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000636
637 ASSERT_EQ(tok::newline, Toks[2].getKind());
638 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000639}
640
641// Single-line verbatim block.
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000642TEST_F(CommentLexerTest, VerbatimBlock4) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000643 const char *Sources[] = {
644 "/// Meow \\verbatim aaa \\endverbatim\n//",
645 "/** Meow \\verbatim aaa \\endverbatim*/"
646 };
647
648 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
649 std::vector<Token> Toks;
650
651 lexString(Sources[i], Toks);
652
653 ASSERT_EQ(6U, Toks.size());
654
655 ASSERT_EQ(tok::text, Toks[0].getKind());
656 ASSERT_EQ(StringRef(" Meow "), Toks[0].getText());
657
658 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000659 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000660
661 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
662 ASSERT_EQ(StringRef(" aaa "), Toks[2].getVerbatimBlockText());
663
664 ASSERT_EQ(tok::verbatim_block_end, Toks[3].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000665 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[3]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000666
667 ASSERT_EQ(tok::newline, Toks[4].getKind());
668 ASSERT_EQ(tok::newline, Toks[5].getKind());
669 }
670}
671
672// Single-line verbatim block without an end command.
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000673TEST_F(CommentLexerTest, VerbatimBlock5) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000674 const char *Sources[] = {
675 "/// Meow \\verbatim aaa \n//",
676 "/** Meow \\verbatim aaa */"
677 };
678
679 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
680 std::vector<Token> Toks;
681
682 lexString(Sources[i], Toks);
683
684 ASSERT_EQ(5U, Toks.size());
685
686 ASSERT_EQ(tok::text, Toks[0].getKind());
687 ASSERT_EQ(StringRef(" Meow "), Toks[0].getText());
688
689 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000690 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000691
692 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
693 ASSERT_EQ(StringRef(" aaa "), Toks[2].getVerbatimBlockText());
694
695 ASSERT_EQ(tok::newline, Toks[3].getKind());
696 ASSERT_EQ(tok::newline, Toks[4].getKind());
697 }
698}
699
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000700TEST_F(CommentLexerTest, VerbatimBlock6) {
701 const char *Source =
702 "// \\verbatim\n"
703 "// Aaa\n"
704 "//\n"
705 "// Bbb\n"
706 "// \\endverbatim\n";
707
708 std::vector<Token> Toks;
709
710 lexString(Source, Toks);
711
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000712 ASSERT_EQ(10U, Toks.size());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000713
714 ASSERT_EQ(tok::text, Toks[0].getKind());
715 ASSERT_EQ(StringRef(" "), Toks[0].getText());
716
717 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000718 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000719
720 ASSERT_EQ(tok::newline, Toks[2].getKind());
721
722 ASSERT_EQ(tok::verbatim_block_line, Toks[3].getKind());
723 ASSERT_EQ(StringRef(" Aaa"), Toks[3].getVerbatimBlockText());
724
725 ASSERT_EQ(tok::newline, Toks[4].getKind());
726
727 ASSERT_EQ(tok::newline, Toks[5].getKind());
728
729 ASSERT_EQ(tok::verbatim_block_line, Toks[6].getKind());
730 ASSERT_EQ(StringRef(" Bbb"), Toks[6].getVerbatimBlockText());
731
732 ASSERT_EQ(tok::newline, Toks[7].getKind());
733
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000734 ASSERT_EQ(tok::verbatim_block_end, Toks[8].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000735 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[8]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000736
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000737 ASSERT_EQ(tok::newline, Toks[9].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000738}
739
740TEST_F(CommentLexerTest, VerbatimBlock7) {
741 const char *Source =
742 "/* \\verbatim\n"
743 " * Aaa\n"
744 " *\n"
745 " * Bbb\n"
746 " * \\endverbatim\n"
747 " */";
748
749 std::vector<Token> Toks;
750
751 lexString(Source, Toks);
752
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000753 ASSERT_EQ(10U, Toks.size());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000754
755 ASSERT_EQ(tok::text, Toks[0].getKind());
756 ASSERT_EQ(StringRef(" "), Toks[0].getText());
757
758 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000759 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000760
761 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
762 ASSERT_EQ(StringRef(" Aaa"), Toks[2].getVerbatimBlockText());
763
764 ASSERT_EQ(tok::verbatim_block_line, Toks[3].getKind());
765 ASSERT_EQ(StringRef(""), Toks[3].getVerbatimBlockText());
766
767 ASSERT_EQ(tok::verbatim_block_line, Toks[4].getKind());
768 ASSERT_EQ(StringRef(" Bbb"), Toks[4].getVerbatimBlockText());
769
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000770 ASSERT_EQ(tok::verbatim_block_end, Toks[5].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000771 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[5]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000772
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000773 ASSERT_EQ(tok::newline, Toks[6].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000774
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000775 ASSERT_EQ(tok::text, Toks[7].getKind());
776 ASSERT_EQ(StringRef(" "), Toks[7].getText());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000777
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000778 ASSERT_EQ(tok::newline, Toks[8].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000779 ASSERT_EQ(tok::newline, Toks[9].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000780}
781
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000782// Complex test for verbatim blocks.
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000783TEST_F(CommentLexerTest, VerbatimBlock8) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000784 const char *Source =
785 "/* Meow \\verbatim aaa\\$\\@\n"
786 "bbb \\endverbati\r"
787 "ccc\r\n"
788 "ddd \\endverbatim Blah \\verbatim eee\n"
789 "\\endverbatim BlahBlah*/";
790 std::vector<Token> Toks;
791
792 lexString(Source, Toks);
793
794 ASSERT_EQ(14U, Toks.size());
795
796 ASSERT_EQ(tok::text, Toks[0].getKind());
797 ASSERT_EQ(StringRef(" Meow "), Toks[0].getText());
798
799 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000800 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000801
802 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000803 ASSERT_EQ(StringRef(" aaa\\$\\@"), Toks[2].getVerbatimBlockText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000804
805 ASSERT_EQ(tok::verbatim_block_line, Toks[3].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000806 ASSERT_EQ(StringRef("bbb \\endverbati"), Toks[3].getVerbatimBlockText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000807
808 ASSERT_EQ(tok::verbatim_block_line, Toks[4].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000809 ASSERT_EQ(StringRef("ccc"), Toks[4].getVerbatimBlockText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000810
811 ASSERT_EQ(tok::verbatim_block_line, Toks[5].getKind());
812 ASSERT_EQ(StringRef("ddd "), Toks[5].getVerbatimBlockText());
813
814 ASSERT_EQ(tok::verbatim_block_end, Toks[6].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000815 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[6]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000816
817 ASSERT_EQ(tok::text, Toks[7].getKind());
818 ASSERT_EQ(StringRef(" Blah "), Toks[7].getText());
819
820 ASSERT_EQ(tok::verbatim_block_begin, Toks[8].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000821 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[8]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000822
823 ASSERT_EQ(tok::verbatim_block_line, Toks[9].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000824 ASSERT_EQ(StringRef(" eee"), Toks[9].getVerbatimBlockText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000825
826 ASSERT_EQ(tok::verbatim_block_end, Toks[10].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000827 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[10]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000828
829 ASSERT_EQ(tok::text, Toks[11].getKind());
830 ASSERT_EQ(StringRef(" BlahBlah"), Toks[11].getText());
831
832 ASSERT_EQ(tok::newline, Toks[12].getKind());
833 ASSERT_EQ(tok::newline, Toks[13].getKind());
834}
835
836// LaTeX verbatim blocks.
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000837TEST_F(CommentLexerTest, VerbatimBlock9) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000838 const char *Source =
839 "/// \\f$ Aaa \\f$ \\f[ Bbb \\f] \\f{ Ccc \\f}";
840 std::vector<Token> Toks;
841
842 lexString(Source, Toks);
843
844 ASSERT_EQ(13U, Toks.size());
845
846 ASSERT_EQ(tok::text, Toks[0].getKind());
847 ASSERT_EQ(StringRef(" "), Toks[0].getText());
848
849 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000850 ASSERT_EQ(StringRef("f$"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000851
852 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
853 ASSERT_EQ(StringRef(" Aaa "), Toks[2].getVerbatimBlockText());
854
855 ASSERT_EQ(tok::verbatim_block_end, Toks[3].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000856 ASSERT_EQ(StringRef("f$"), getVerbatimBlockName(Toks[3]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000857
858 ASSERT_EQ(tok::text, Toks[4].getKind());
859 ASSERT_EQ(StringRef(" "), Toks[4].getText());
860
861 ASSERT_EQ(tok::verbatim_block_begin, Toks[5].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000862 ASSERT_EQ(StringRef("f["), getVerbatimBlockName(Toks[5]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000863
864 ASSERT_EQ(tok::verbatim_block_line, Toks[6].getKind());
865 ASSERT_EQ(StringRef(" Bbb "), Toks[6].getVerbatimBlockText());
866
867 ASSERT_EQ(tok::verbatim_block_end, Toks[7].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000868 ASSERT_EQ(StringRef("f]"), getVerbatimBlockName(Toks[7]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000869
870 ASSERT_EQ(tok::text, Toks[8].getKind());
871 ASSERT_EQ(StringRef(" "), Toks[8].getText());
872
873 ASSERT_EQ(tok::verbatim_block_begin, Toks[9].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000874 ASSERT_EQ(StringRef("f{"), getVerbatimBlockName(Toks[9]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000875
876 ASSERT_EQ(tok::verbatim_block_line, Toks[10].getKind());
877 ASSERT_EQ(StringRef(" Ccc "), Toks[10].getVerbatimBlockText());
878
879 ASSERT_EQ(tok::verbatim_block_end, Toks[11].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000880 ASSERT_EQ(StringRef("f}"), getVerbatimBlockName(Toks[11]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000881
882 ASSERT_EQ(tok::newline, Toks[12].getKind());
883}
884
885// Empty verbatim line.
886TEST_F(CommentLexerTest, VerbatimLine1) {
887 const char *Sources[] = {
888 "/// \\fn\n//",
889 "/** \\fn*/"
890 };
891
892 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
893 std::vector<Token> Toks;
894
895 lexString(Sources[i], Toks);
896
897 ASSERT_EQ(4U, Toks.size());
898
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000899 ASSERT_EQ(tok::text, Toks[0].getKind());
900 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000901
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000902 ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000903 ASSERT_EQ(StringRef("fn"), getVerbatimLineName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000904
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000905 ASSERT_EQ(tok::newline, Toks[2].getKind());
906 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000907 }
908}
909
910// Verbatim line with Doxygen escape sequences, which should not be expanded.
911TEST_F(CommentLexerTest, VerbatimLine2) {
912 const char *Sources[] = {
913 "/// \\fn void *foo(const char *zzz = \"\\$\");\n//",
914 "/** \\fn void *foo(const char *zzz = \"\\$\");*/"
915 };
916
917 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
918 std::vector<Token> Toks;
919
920 lexString(Sources[i], Toks);
921
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000922 ASSERT_EQ(5U, Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000923
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000924 ASSERT_EQ(tok::text, Toks[0].getKind());
925 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000926
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000927 ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000928 ASSERT_EQ(StringRef("fn"), getVerbatimLineName(Toks[1]));
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000929
930 ASSERT_EQ(tok::verbatim_line_text, Toks[2].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000931 ASSERT_EQ(StringRef(" void *foo(const char *zzz = \"\\$\");"),
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000932 Toks[2].getVerbatimLineText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000933
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000934 ASSERT_EQ(tok::newline, Toks[3].getKind());
935 ASSERT_EQ(tok::newline, Toks[4].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000936 }
937}
938
939// Verbatim line should not eat anything from next source line.
940TEST_F(CommentLexerTest, VerbatimLine3) {
941 const char *Source =
942 "/** \\fn void *foo(const char *zzz = \"\\$\");\n"
943 " * Meow\n"
944 " */";
945
946 std::vector<Token> Toks;
947
948 lexString(Source, Toks);
949
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000950 ASSERT_EQ(9U, Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000951
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000952 ASSERT_EQ(tok::text, Toks[0].getKind());
953 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000954
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000955 ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000956 ASSERT_EQ(StringRef("fn"), getVerbatimLineName(Toks[1]));
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000957
958 ASSERT_EQ(tok::verbatim_line_text, Toks[2].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000959 ASSERT_EQ(StringRef(" void *foo(const char *zzz = \"\\$\");"),
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000960 Toks[2].getVerbatimLineText());
961 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000962
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000963 ASSERT_EQ(tok::text, Toks[4].getKind());
964 ASSERT_EQ(StringRef(" Meow"), Toks[4].getText());
965 ASSERT_EQ(tok::newline, Toks[5].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000966
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000967 ASSERT_EQ(tok::text, Toks[6].getKind());
968 ASSERT_EQ(StringRef(" "), Toks[6].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000969
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000970 ASSERT_EQ(tok::newline, Toks[7].getKind());
971 ASSERT_EQ(tok::newline, Toks[8].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000972}
973
974TEST_F(CommentLexerTest, HTML1) {
975 const char *Source =
976 "// <";
977
978 std::vector<Token> Toks;
979
980 lexString(Source, Toks);
981
982 ASSERT_EQ(3U, Toks.size());
983
984 ASSERT_EQ(tok::text, Toks[0].getKind());
985 ASSERT_EQ(StringRef(" "), Toks[0].getText());
986
987 ASSERT_EQ(tok::text, Toks[1].getKind());
988 ASSERT_EQ(StringRef("<"), Toks[1].getText());
989
990 ASSERT_EQ(tok::newline, Toks[2].getKind());
991}
992
993TEST_F(CommentLexerTest, HTML2) {
Dmitri Gribenko5676d322012-06-27 23:28:29 +0000994 const char *Source =
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +0000995 "// a<2";
996
997 std::vector<Token> Toks;
998
999 lexString(Source, Toks);
1000
1001 ASSERT_EQ(4U, Toks.size());
1002
1003 ASSERT_EQ(tok::text, Toks[0].getKind());
1004 ASSERT_EQ(StringRef(" a"), Toks[0].getText());
1005
1006 ASSERT_EQ(tok::text, Toks[1].getKind());
1007 ASSERT_EQ(StringRef("<"), Toks[1].getText());
1008
1009 ASSERT_EQ(tok::text, Toks[2].getKind());
1010 ASSERT_EQ(StringRef("2"), Toks[2].getText());
1011
1012 ASSERT_EQ(tok::newline, Toks[3].getKind());
1013}
1014
1015TEST_F(CommentLexerTest, HTML3) {
1016 const char *Source =
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001017 "// < img";
Dmitri Gribenko5676d322012-06-27 23:28:29 +00001018
1019 std::vector<Token> Toks;
1020
1021 lexString(Source, Toks);
1022
1023 ASSERT_EQ(4U, Toks.size());
1024
1025 ASSERT_EQ(tok::text, Toks[0].getKind());
1026 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1027
1028 ASSERT_EQ(tok::text, Toks[1].getKind());
1029 ASSERT_EQ(StringRef("<"), Toks[1].getText());
1030
1031 ASSERT_EQ(tok::text, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001032 ASSERT_EQ(StringRef(" img"), Toks[2].getText());
Dmitri Gribenko5676d322012-06-27 23:28:29 +00001033
1034 ASSERT_EQ(tok::newline, Toks[3].getKind());
1035}
1036
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001037TEST_F(CommentLexerTest, HTML4) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001038 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001039 "// <img",
1040 "// <img "
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001041 };
1042
1043 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1044 std::vector<Token> Toks;
1045
1046 lexString(Sources[i], Toks);
1047
1048 ASSERT_EQ(3U, Toks.size());
1049
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001050 ASSERT_EQ(tok::text, Toks[0].getKind());
1051 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001052
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001053 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001054 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001055
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001056 ASSERT_EQ(tok::newline, Toks[2].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001057 }
1058}
1059
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001060TEST_F(CommentLexerTest, HTML5) {
1061 const char *Source =
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001062 "// <img 42";
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001063
1064 std::vector<Token> Toks;
1065
1066 lexString(Source, Toks);
1067
1068 ASSERT_EQ(4U, Toks.size());
1069
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001070 ASSERT_EQ(tok::text, Toks[0].getKind());
1071 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001072
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001073 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001074 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001075
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001076 ASSERT_EQ(tok::text, Toks[2].getKind());
1077 ASSERT_EQ(StringRef("42"), Toks[2].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001078
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001079 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001080}
1081
1082TEST_F(CommentLexerTest, HTML6) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001083 const char *Source = "// <img> Meow";
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001084
1085 std::vector<Token> Toks;
1086
1087 lexString(Source, Toks);
1088
1089 ASSERT_EQ(5U, Toks.size());
1090
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001091 ASSERT_EQ(tok::text, Toks[0].getKind());
1092 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001093
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001094 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001095 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001096
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001097 ASSERT_EQ(tok::html_greater, Toks[2].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001098
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001099 ASSERT_EQ(tok::text, Toks[3].getKind());
1100 ASSERT_EQ(StringRef(" Meow"), Toks[3].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001101
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001102 ASSERT_EQ(tok::newline, Toks[4].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001103}
1104
1105TEST_F(CommentLexerTest, HTML7) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001106 const char *Source = "// <img=";
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001107
1108 std::vector<Token> Toks;
1109
1110 lexString(Source, Toks);
1111
1112 ASSERT_EQ(4U, Toks.size());
1113
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001114 ASSERT_EQ(tok::text, Toks[0].getKind());
1115 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001116
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001117 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001118 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001119
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001120 ASSERT_EQ(tok::text, Toks[2].getKind());
1121 ASSERT_EQ(StringRef("="), Toks[2].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001122
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001123 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001124}
1125
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001126TEST_F(CommentLexerTest, HTML8) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001127 const char *Source = "// <img src=> Meow";
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001128
1129 std::vector<Token> Toks;
1130
1131 lexString(Source, Toks);
1132
1133 ASSERT_EQ(7U, Toks.size());
1134
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001135 ASSERT_EQ(tok::text, Toks[0].getKind());
1136 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001137
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001138 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001139 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001140
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001141 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001142 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001143
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001144 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001145
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001146 ASSERT_EQ(tok::html_greater, Toks[4].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001147
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001148 ASSERT_EQ(tok::text, Toks[5].getKind());
1149 ASSERT_EQ(StringRef(" Meow"), Toks[5].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001150
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001151 ASSERT_EQ(tok::newline, Toks[6].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001152}
1153
1154TEST_F(CommentLexerTest, HTML9) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001155 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001156 "// <img src",
1157 "// <img src "
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001158 };
1159
1160 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1161 std::vector<Token> Toks;
1162
1163 lexString(Sources[i], Toks);
1164
1165 ASSERT_EQ(4U, Toks.size());
1166
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001167 ASSERT_EQ(tok::text, Toks[0].getKind());
1168 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001169
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001170 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001171 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001172
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001173 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001174 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001175
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001176 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001177 }
1178}
1179
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001180TEST_F(CommentLexerTest, HTML10) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001181 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001182 "// <img src=",
1183 "// <img src ="
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001184 };
1185
1186 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1187 std::vector<Token> Toks;
1188
1189 lexString(Sources[i], Toks);
1190
1191 ASSERT_EQ(5U, Toks.size());
1192
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001193 ASSERT_EQ(tok::text, Toks[0].getKind());
1194 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001195
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001196 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001197 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001198
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001199 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001200 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001201
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001202 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001203
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001204 ASSERT_EQ(tok::newline, Toks[4].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001205 }
1206}
1207
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001208TEST_F(CommentLexerTest, HTML11) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001209 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001210 "// <img src=\"",
1211 "// <img src = \"",
1212 "// <img src=\'",
1213 "// <img src = \'"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001214 };
1215
1216 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1217 std::vector<Token> Toks;
1218
1219 lexString(Sources[i], Toks);
1220
1221 ASSERT_EQ(6U, Toks.size());
1222
1223 ASSERT_EQ(tok::text, Toks[0].getKind());
1224 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1225
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001226 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001227 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001228
1229 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001230 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001231
1232 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
1233
1234 ASSERT_EQ(tok::html_quoted_string, Toks[4].getKind());
1235 ASSERT_EQ(StringRef(""), Toks[4].getHTMLQuotedString());
1236
1237 ASSERT_EQ(tok::newline, Toks[5].getKind());
1238 }
1239}
1240
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001241TEST_F(CommentLexerTest, HTML12) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001242 const char *Source = "// <img src=@";
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001243
1244 std::vector<Token> Toks;
1245
1246 lexString(Source, Toks);
1247
1248 ASSERT_EQ(6U, Toks.size());
1249
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001250 ASSERT_EQ(tok::text, Toks[0].getKind());
1251 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001252
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001253 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001254 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001255
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001256 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001257 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001258
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001259 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001260
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001261 ASSERT_EQ(tok::text, Toks[4].getKind());
1262 ASSERT_EQ(StringRef("@"), Toks[4].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001263
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001264 ASSERT_EQ(tok::newline, Toks[5].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001265}
1266
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001267TEST_F(CommentLexerTest, HTML13) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001268 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001269 "// <img src=\"val\\\"\\'val",
1270 "// <img src=\"val\\\"\\'val\"",
1271 "// <img src=\'val\\\"\\'val",
1272 "// <img src=\'val\\\"\\'val\'"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001273 };
1274
1275 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1276 std::vector<Token> Toks;
1277
1278 lexString(Sources[i], Toks);
1279
1280 ASSERT_EQ(6U, Toks.size());
1281
1282 ASSERT_EQ(tok::text, Toks[0].getKind());
1283 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1284
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001285 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001286 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001287
1288 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001289 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001290
1291 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
1292
1293 ASSERT_EQ(tok::html_quoted_string, Toks[4].getKind());
1294 ASSERT_EQ(StringRef("val\\\"\\'val"), Toks[4].getHTMLQuotedString());
1295
1296 ASSERT_EQ(tok::newline, Toks[5].getKind());
1297 }
1298}
1299
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001300TEST_F(CommentLexerTest, HTML14) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001301 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001302 "// <img src=\"val\\\"\\'val\">",
1303 "// <img src=\'val\\\"\\'val\'>"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001304 };
1305
1306 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1307 std::vector<Token> Toks;
1308
1309 lexString(Sources[i], Toks);
1310
1311 ASSERT_EQ(7U, Toks.size());
1312
1313 ASSERT_EQ(tok::text, Toks[0].getKind());
1314 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1315
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001316 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001317 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001318
1319 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001320 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001321
1322 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
1323
1324 ASSERT_EQ(tok::html_quoted_string, Toks[4].getKind());
1325 ASSERT_EQ(StringRef("val\\\"\\'val"), Toks[4].getHTMLQuotedString());
1326
1327 ASSERT_EQ(tok::html_greater, Toks[5].getKind());
1328
1329 ASSERT_EQ(tok::newline, Toks[6].getKind());
1330 }
1331}
1332
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001333TEST_F(CommentLexerTest, HTML15) {
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001334 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001335 "// <img/>",
1336 "// <img />"
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001337 };
1338
1339 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1340 std::vector<Token> Toks;
1341
1342 lexString(Sources[i], Toks);
1343
1344 ASSERT_EQ(4U, Toks.size());
1345
1346 ASSERT_EQ(tok::text, Toks[0].getKind());
1347 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1348
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001349 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001350 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001351
1352 ASSERT_EQ(tok::html_slash_greater, Toks[2].getKind());
1353
1354 ASSERT_EQ(tok::newline, Toks[3].getKind());
1355 }
1356}
1357
1358TEST_F(CommentLexerTest, HTML16) {
1359 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001360 "// <img/ Aaa",
1361 "// <img / Aaa"
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001362 };
1363
1364 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1365 std::vector<Token> Toks;
1366
1367 lexString(Sources[i], Toks);
1368
1369 ASSERT_EQ(5U, Toks.size());
1370
1371 ASSERT_EQ(tok::text, Toks[0].getKind());
1372 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1373
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001374 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001375 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001376
1377 ASSERT_EQ(tok::text, Toks[2].getKind());
1378 ASSERT_EQ(StringRef("/"), Toks[2].getText());
1379
1380 ASSERT_EQ(tok::text, Toks[3].getKind());
1381 ASSERT_EQ(StringRef(" Aaa"), Toks[3].getText());
1382
1383 ASSERT_EQ(tok::newline, Toks[4].getKind());
1384 }
1385}
1386
1387TEST_F(CommentLexerTest, HTML17) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001388 const char *Source = "// </";
1389
1390 std::vector<Token> Toks;
1391
1392 lexString(Source, Toks);
1393
1394 ASSERT_EQ(3U, Toks.size());
1395
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001396 ASSERT_EQ(tok::text, Toks[0].getKind());
1397 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001398
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001399 ASSERT_EQ(tok::text, Toks[1].getKind());
1400 ASSERT_EQ(StringRef("</"), Toks[1].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001401
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001402 ASSERT_EQ(tok::newline, Toks[2].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001403}
1404
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001405TEST_F(CommentLexerTest, HTML18) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001406 const char *Source = "// </@";
1407
1408 std::vector<Token> Toks;
1409
1410 lexString(Source, Toks);
1411
1412 ASSERT_EQ(4U, Toks.size());
1413
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001414 ASSERT_EQ(tok::text, Toks[0].getKind());
1415 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001416
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001417 ASSERT_EQ(tok::text, Toks[1].getKind());
1418 ASSERT_EQ(StringRef("</"), Toks[1].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001419
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001420 ASSERT_EQ(tok::text, Toks[2].getKind());
1421 ASSERT_EQ(StringRef("@"), Toks[2].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001422
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001423 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001424}
1425
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001426TEST_F(CommentLexerTest, HTML19) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001427 const char *Source = "// </img";
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001428
1429 std::vector<Token> Toks;
1430
1431 lexString(Source, Toks);
1432
1433 ASSERT_EQ(3U, Toks.size());
1434
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001435 ASSERT_EQ(tok::text, Toks[0].getKind());
1436 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001437
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001438 ASSERT_EQ(tok::html_end_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001439 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagEndName());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001440
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001441 ASSERT_EQ(tok::newline, Toks[2].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001442}
1443
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001444TEST_F(CommentLexerTest, NotAKnownHTMLTag1) {
1445 const char *Source = "// <tag>";
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001446
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001447 std::vector<Token> Toks;
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001448
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001449 lexString(Source, Toks);
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001450
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001451 ASSERT_EQ(4U, Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001452
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001453 ASSERT_EQ(tok::text, Toks[0].getKind());
1454 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001455
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001456 ASSERT_EQ(tok::text, Toks[1].getKind());
1457 ASSERT_EQ(StringRef("<tag"), Toks[1].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001458
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001459 ASSERT_EQ(tok::text, Toks[2].getKind());
1460 ASSERT_EQ(StringRef(">"), Toks[2].getText());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001461
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001462 ASSERT_EQ(tok::newline, Toks[3].getKind());
1463}
1464
1465TEST_F(CommentLexerTest, NotAKnownHTMLTag2) {
1466 const char *Source = "// </tag>";
1467
1468 std::vector<Token> Toks;
1469
1470 lexString(Source, Toks);
1471
1472 ASSERT_EQ(4U, Toks.size());
1473
1474 ASSERT_EQ(tok::text, Toks[0].getKind());
1475 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1476
1477 ASSERT_EQ(tok::text, Toks[1].getKind());
1478 ASSERT_EQ(StringRef("</tag"), Toks[1].getText());
1479
1480 ASSERT_EQ(tok::text, Toks[2].getKind());
1481 ASSERT_EQ(StringRef(">"), Toks[2].getText());
1482
1483 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001484}
1485
Dmitri Gribenko477a9f52012-07-27 20:37:06 +00001486TEST_F(CommentLexerTest, HTMLCharacterReferences1) {
1487 const char *Source = "// &";
1488
1489 std::vector<Token> Toks;
1490
1491 lexString(Source, Toks);
1492
1493 ASSERT_EQ(3U, Toks.size());
1494
1495 ASSERT_EQ(tok::text, Toks[0].getKind());
1496 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1497
1498 ASSERT_EQ(tok::text, Toks[1].getKind());
1499 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1500
1501 ASSERT_EQ(tok::newline, Toks[2].getKind());
1502}
1503
1504TEST_F(CommentLexerTest, HTMLCharacterReferences2) {
1505 const char *Source = "// &!";
1506
1507 std::vector<Token> Toks;
1508
1509 lexString(Source, Toks);
1510
1511 ASSERT_EQ(4U, Toks.size());
1512
1513 ASSERT_EQ(tok::text, Toks[0].getKind());
1514 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1515
1516 ASSERT_EQ(tok::text, Toks[1].getKind());
1517 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1518
1519 ASSERT_EQ(tok::text, Toks[2].getKind());
1520 ASSERT_EQ(StringRef("!"), Toks[2].getText());
1521
1522 ASSERT_EQ(tok::newline, Toks[3].getKind());
1523}
1524
1525TEST_F(CommentLexerTest, HTMLCharacterReferences3) {
1526 const char *Source = "// &amp";
1527
1528 std::vector<Token> Toks;
1529
1530 lexString(Source, Toks);
1531
1532 ASSERT_EQ(3U, Toks.size());
1533
1534 ASSERT_EQ(tok::text, Toks[0].getKind());
1535 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1536
1537 ASSERT_EQ(tok::text, Toks[1].getKind());
1538 ASSERT_EQ(StringRef("&amp"), Toks[1].getText());
1539
1540 ASSERT_EQ(tok::newline, Toks[2].getKind());
1541}
1542
1543TEST_F(CommentLexerTest, HTMLCharacterReferences4) {
1544 const char *Source = "// &amp!";
1545
1546 std::vector<Token> Toks;
1547
1548 lexString(Source, Toks);
1549
1550 ASSERT_EQ(4U, Toks.size());
1551
1552 ASSERT_EQ(tok::text, Toks[0].getKind());
1553 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1554
1555 ASSERT_EQ(tok::text, Toks[1].getKind());
1556 ASSERT_EQ(StringRef("&amp"), Toks[1].getText());
1557
1558 ASSERT_EQ(tok::text, Toks[2].getKind());
1559 ASSERT_EQ(StringRef("!"), Toks[2].getText());
1560
1561 ASSERT_EQ(tok::newline, Toks[3].getKind());
1562}
1563
1564TEST_F(CommentLexerTest, HTMLCharacterReferences5) {
1565 const char *Source = "// &#";
1566
1567 std::vector<Token> Toks;
1568
1569 lexString(Source, Toks);
1570
1571 ASSERT_EQ(3U, Toks.size());
1572
1573 ASSERT_EQ(tok::text, Toks[0].getKind());
1574 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1575
1576 ASSERT_EQ(tok::text, Toks[1].getKind());
1577 ASSERT_EQ(StringRef("&#"), Toks[1].getText());
1578
1579 ASSERT_EQ(tok::newline, Toks[2].getKind());
1580}
1581
1582TEST_F(CommentLexerTest, HTMLCharacterReferences6) {
1583 const char *Source = "// &#a";
1584
1585 std::vector<Token> Toks;
1586
1587 lexString(Source, Toks);
1588
1589 ASSERT_EQ(4U, Toks.size());
1590
1591 ASSERT_EQ(tok::text, Toks[0].getKind());
1592 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1593
1594 ASSERT_EQ(tok::text, Toks[1].getKind());
1595 ASSERT_EQ(StringRef("&#"), Toks[1].getText());
1596
1597 ASSERT_EQ(tok::text, Toks[2].getKind());
1598 ASSERT_EQ(StringRef("a"), Toks[2].getText());
1599
1600 ASSERT_EQ(tok::newline, Toks[3].getKind());
1601}
1602
1603TEST_F(CommentLexerTest, HTMLCharacterReferences7) {
1604 const char *Source = "// &#42";
1605
1606 std::vector<Token> Toks;
1607
1608 lexString(Source, Toks);
1609
1610 ASSERT_EQ(3U, Toks.size());
1611
1612 ASSERT_EQ(tok::text, Toks[0].getKind());
1613 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1614
1615 ASSERT_EQ(tok::text, Toks[1].getKind());
1616 ASSERT_EQ(StringRef("&#42"), Toks[1].getText());
1617
1618 ASSERT_EQ(tok::newline, Toks[2].getKind());
1619}
1620
1621TEST_F(CommentLexerTest, HTMLCharacterReferences8) {
1622 const char *Source = "// &#42a";
1623
1624 std::vector<Token> Toks;
1625
1626 lexString(Source, Toks);
1627
1628 ASSERT_EQ(4U, Toks.size());
1629
1630 ASSERT_EQ(tok::text, Toks[0].getKind());
1631 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1632
1633 ASSERT_EQ(tok::text, Toks[1].getKind());
1634 ASSERT_EQ(StringRef("&#42"), Toks[1].getText());
1635
1636 ASSERT_EQ(tok::text, Toks[2].getKind());
1637 ASSERT_EQ(StringRef("a"), Toks[2].getText());
1638
1639 ASSERT_EQ(tok::newline, Toks[3].getKind());
1640}
1641
1642TEST_F(CommentLexerTest, HTMLCharacterReferences9) {
1643 const char *Source = "// &#x";
1644
1645 std::vector<Token> Toks;
1646
1647 lexString(Source, Toks);
1648
1649 ASSERT_EQ(3U, Toks.size());
1650
1651 ASSERT_EQ(tok::text, Toks[0].getKind());
1652 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1653
1654 ASSERT_EQ(tok::text, Toks[1].getKind());
1655 ASSERT_EQ(StringRef("&#x"), Toks[1].getText());
1656
1657 ASSERT_EQ(tok::newline, Toks[2].getKind());
1658}
1659
1660TEST_F(CommentLexerTest, HTMLCharacterReferences10) {
1661 const char *Source = "// &#xz";
1662
1663 std::vector<Token> Toks;
1664
1665 lexString(Source, Toks);
1666
1667 ASSERT_EQ(4U, Toks.size());
1668
1669 ASSERT_EQ(tok::text, Toks[0].getKind());
1670 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1671
1672 ASSERT_EQ(tok::text, Toks[1].getKind());
1673 ASSERT_EQ(StringRef("&#x"), Toks[1].getText());
1674
1675 ASSERT_EQ(tok::text, Toks[2].getKind());
1676 ASSERT_EQ(StringRef("z"), Toks[2].getText());
1677
1678 ASSERT_EQ(tok::newline, Toks[3].getKind());
1679}
1680
1681TEST_F(CommentLexerTest, HTMLCharacterReferences11) {
1682 const char *Source = "// &#xab";
1683
1684 std::vector<Token> Toks;
1685
1686 lexString(Source, Toks);
1687
1688 ASSERT_EQ(3U, Toks.size());
1689
1690 ASSERT_EQ(tok::text, Toks[0].getKind());
1691 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1692
1693 ASSERT_EQ(tok::text, Toks[1].getKind());
1694 ASSERT_EQ(StringRef("&#xab"), Toks[1].getText());
1695
1696 ASSERT_EQ(tok::newline, Toks[2].getKind());
1697}
1698
1699TEST_F(CommentLexerTest, HTMLCharacterReferences12) {
1700 const char *Source = "// &#xaBz";
1701
1702 std::vector<Token> Toks;
1703
1704 lexString(Source, Toks);
1705
1706 ASSERT_EQ(4U, Toks.size());
1707
1708 ASSERT_EQ(tok::text, Toks[0].getKind());
1709 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1710
1711 ASSERT_EQ(tok::text, Toks[1].getKind());
1712 ASSERT_EQ(StringRef("&#xaB"), Toks[1].getText());
1713
1714 ASSERT_EQ(tok::text, Toks[2].getKind());
1715 ASSERT_EQ(StringRef("z"), Toks[2].getText());
1716
1717 ASSERT_EQ(tok::newline, Toks[3].getKind());
1718}
1719
1720TEST_F(CommentLexerTest, HTMLCharacterReferences13) {
1721 const char *Source = "// &amp;";
1722
1723 std::vector<Token> Toks;
1724
1725 lexString(Source, Toks);
1726
1727 ASSERT_EQ(3U, Toks.size());
1728
1729 ASSERT_EQ(tok::text, Toks[0].getKind());
1730 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1731
1732 ASSERT_EQ(tok::text, Toks[1].getKind());
1733 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1734
1735 ASSERT_EQ(tok::newline, Toks[2].getKind());
1736}
1737
1738TEST_F(CommentLexerTest, HTMLCharacterReferences14) {
1739 const char *Source = "// &amp;&lt;";
1740
1741 std::vector<Token> Toks;
1742
1743 lexString(Source, Toks);
1744
1745 ASSERT_EQ(4U, Toks.size());
1746
1747 ASSERT_EQ(tok::text, Toks[0].getKind());
1748 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1749
1750 ASSERT_EQ(tok::text, Toks[1].getKind());
1751 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1752
1753 ASSERT_EQ(tok::text, Toks[2].getKind());
1754 ASSERT_EQ(StringRef("<"), Toks[2].getText());
1755
1756 ASSERT_EQ(tok::newline, Toks[3].getKind());
1757}
1758
1759TEST_F(CommentLexerTest, HTMLCharacterReferences15) {
1760 const char *Source = "// &amp; meow";
1761
1762 std::vector<Token> Toks;
1763
1764 lexString(Source, Toks);
1765
1766 ASSERT_EQ(4U, Toks.size());
1767
1768 ASSERT_EQ(tok::text, Toks[0].getKind());
1769 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1770
1771 ASSERT_EQ(tok::text, Toks[1].getKind());
1772 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1773
1774 ASSERT_EQ(tok::text, Toks[2].getKind());
1775 ASSERT_EQ(StringRef(" meow"), Toks[2].getText());
1776
1777 ASSERT_EQ(tok::newline, Toks[3].getKind());
1778}
1779
1780TEST_F(CommentLexerTest, HTMLCharacterReferences16) {
1781 const char *Sources[] = {
1782 "// &#61;",
1783 "// &#x3d;",
Dmitri Gribenko44a3ddb2013-01-19 22:04:44 +00001784 "// &#X3d;",
1785 "// &#X3D;"
Dmitri Gribenko477a9f52012-07-27 20:37:06 +00001786 };
1787
1788 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1789 std::vector<Token> Toks;
1790
1791 lexString(Sources[i], Toks);
1792
1793 ASSERT_EQ(3U, Toks.size());
1794
1795 ASSERT_EQ(tok::text, Toks[0].getKind());
1796 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1797
1798 ASSERT_EQ(tok::text, Toks[1].getKind());
1799 ASSERT_EQ(StringRef("="), Toks[1].getText());
1800
1801 ASSERT_EQ(tok::newline, Toks[2].getKind());
1802 }
1803}
1804
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001805TEST_F(CommentLexerTest, MultipleComments) {
1806 const char *Source =
1807 "// Aaa\n"
1808 "/// Bbb\n"
1809 "/* Ccc\n"
1810 " * Ddd*/\n"
1811 "/** Eee*/";
1812
1813 std::vector<Token> Toks;
1814
1815 lexString(Source, Toks);
1816
1817 ASSERT_EQ(12U, Toks.size());
1818
1819 ASSERT_EQ(tok::text, Toks[0].getKind());
1820 ASSERT_EQ(StringRef(" Aaa"), Toks[0].getText());
1821 ASSERT_EQ(tok::newline, Toks[1].getKind());
1822
1823 ASSERT_EQ(tok::text, Toks[2].getKind());
1824 ASSERT_EQ(StringRef(" Bbb"), Toks[2].getText());
1825 ASSERT_EQ(tok::newline, Toks[3].getKind());
1826
1827 ASSERT_EQ(tok::text, Toks[4].getKind());
1828 ASSERT_EQ(StringRef(" Ccc"), Toks[4].getText());
1829 ASSERT_EQ(tok::newline, Toks[5].getKind());
1830
1831 ASSERT_EQ(tok::text, Toks[6].getKind());
1832 ASSERT_EQ(StringRef(" Ddd"), Toks[6].getText());
1833 ASSERT_EQ(tok::newline, Toks[7].getKind());
1834 ASSERT_EQ(tok::newline, Toks[8].getKind());
1835
1836 ASSERT_EQ(tok::text, Toks[9].getKind());
1837 ASSERT_EQ(StringRef(" Eee"), Toks[9].getText());
1838
1839 ASSERT_EQ(tok::newline, Toks[10].getKind());
1840 ASSERT_EQ(tok::newline, Toks[11].getKind());
1841}
1842
1843} // end namespace comments
1844} // end namespace clang
1845