blob: 46de945ccacc76c47cacc336daad3842b90af598 [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) {
304 const char *Source =
305 "/// \\\\ \\@ \\& \\$ \\# \\< \\> \\% \\\" \\. \\::";
306 const char *Text[] = {
307 " ",
308 "\\", " ", "@", " ", "&", " ", "$", " ", "#", " ",
309 "<", " ", ">", " ", "%", " ", "\"", " ", ".", " ",
310 "::", ""
311 };
312
313 std::vector<Token> Toks;
314
315 lexString(Source, Toks);
316
317 ASSERT_EQ(array_lengthof(Text), Toks.size());
318
319 for (size_t i = 0, e = Toks.size(); i != e; i++) {
320 if(Toks[i].is(tok::text))
321 ASSERT_EQ(StringRef(Text[i]), Toks[i].getText())
322 << "index " << i;
323 }
324}
325
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000326// A command marker followed by a non-letter that is not a part of an escape
327// sequence.
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000328TEST_F(CommentLexerTest, DoxygenCommand5) {
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000329 const char *Source = "/// \\^ \\0";
330 std::vector<Token> Toks;
331
332 lexString(Source, Toks);
333
334 ASSERT_EQ(6U, Toks.size());
335
336 ASSERT_EQ(tok::text, Toks[0].getKind());
337 ASSERT_EQ(StringRef(" "), Toks[0].getText());
338
339 ASSERT_EQ(tok::text, Toks[1].getKind());
340 ASSERT_EQ(StringRef("\\"), Toks[1].getText());
341
342 ASSERT_EQ(tok::text, Toks[2].getKind());
343 ASSERT_EQ(StringRef("^ "), Toks[2].getText());
344
345 ASSERT_EQ(tok::text, Toks[3].getKind());
346 ASSERT_EQ(StringRef("\\"), Toks[3].getText());
347
348 ASSERT_EQ(tok::text, Toks[4].getKind());
349 ASSERT_EQ(StringRef("0"), Toks[4].getText());
350
351 ASSERT_EQ(tok::newline, Toks[5].getKind());
352}
353
354TEST_F(CommentLexerTest, DoxygenCommand6) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000355 const char *Source = "/// \\brief Aaa.";
356 std::vector<Token> Toks;
357
358 lexString(Source, Toks);
359
360 ASSERT_EQ(4U, Toks.size());
361
362 ASSERT_EQ(tok::text, Toks[0].getKind());
363 ASSERT_EQ(StringRef(" "), Toks[0].getText());
364
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000365 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000366 ASSERT_EQ(StringRef("brief"), getCommandName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000367
368 ASSERT_EQ(tok::text, Toks[2].getKind());
369 ASSERT_EQ(StringRef(" Aaa."), Toks[2].getText());
370
371 ASSERT_EQ(tok::newline, Toks[3].getKind());
372}
373
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000374TEST_F(CommentLexerTest, DoxygenCommand7) {
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000375 const char *Source = "/// \\em\\em \\em\t\\em\n";
376 std::vector<Token> Toks;
377
378 lexString(Source, Toks);
379
380 ASSERT_EQ(8U, Toks.size());
381
382 ASSERT_EQ(tok::text, Toks[0].getKind());
383 ASSERT_EQ(StringRef(" "), Toks[0].getText());
384
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000385 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000386 ASSERT_EQ(StringRef("em"), getCommandName(Toks[1]));
387
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000388 ASSERT_EQ(tok::backslash_command, Toks[2].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000389 ASSERT_EQ(StringRef("em"), getCommandName(Toks[2]));
390
391 ASSERT_EQ(tok::text, Toks[3].getKind());
392 ASSERT_EQ(StringRef(" "), Toks[3].getText());
393
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000394 ASSERT_EQ(tok::backslash_command, Toks[4].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000395 ASSERT_EQ(StringRef("em"), getCommandName(Toks[4]));
396
397 ASSERT_EQ(tok::text, Toks[5].getKind());
398 ASSERT_EQ(StringRef("\t"), Toks[5].getText());
399
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000400 ASSERT_EQ(tok::backslash_command, Toks[6].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000401 ASSERT_EQ(StringRef("em"), getCommandName(Toks[6]));
402
403 ASSERT_EQ(tok::newline, Toks[7].getKind());
404}
405
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000406TEST_F(CommentLexerTest, DoxygenCommand8) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000407 const char *Source = "/// \\aaa\\bbb \\ccc\t\\ddd\n";
408 std::vector<Token> Toks;
409
410 lexString(Source, Toks);
411
412 ASSERT_EQ(8U, Toks.size());
413
414 ASSERT_EQ(tok::text, Toks[0].getKind());
415 ASSERT_EQ(StringRef(" "), Toks[0].getText());
416
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000417 ASSERT_EQ(tok::unknown_command, Toks[1].getKind());
418 ASSERT_EQ(StringRef("aaa"), Toks[1].getUnknownCommandName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000419
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000420 ASSERT_EQ(tok::unknown_command, Toks[2].getKind());
421 ASSERT_EQ(StringRef("bbb"), Toks[2].getUnknownCommandName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000422
423 ASSERT_EQ(tok::text, Toks[3].getKind());
424 ASSERT_EQ(StringRef(" "), Toks[3].getText());
425
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000426 ASSERT_EQ(tok::unknown_command, Toks[4].getKind());
427 ASSERT_EQ(StringRef("ccc"), Toks[4].getUnknownCommandName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000428
429 ASSERT_EQ(tok::text, Toks[5].getKind());
430 ASSERT_EQ(StringRef("\t"), Toks[5].getText());
431
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000432 ASSERT_EQ(tok::unknown_command, Toks[6].getKind());
433 ASSERT_EQ(StringRef("ddd"), Toks[6].getUnknownCommandName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000434
435 ASSERT_EQ(tok::newline, Toks[7].getKind());
436}
437
Dmitri Gribenko8c05da32012-09-14 16:35:35 +0000438TEST_F(CommentLexerTest, DoxygenCommand9) {
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000439 const char *Source = "// \\c\n";
440 std::vector<Token> Toks;
441
442 lexString(Source, Toks);
443
444 ASSERT_EQ(3U, Toks.size());
445
446 ASSERT_EQ(tok::text, Toks[0].getKind());
447 ASSERT_EQ(StringRef(" "), Toks[0].getText());
448
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000449 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000450 ASSERT_EQ(StringRef("c"), getCommandName(Toks[1]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000451
452 ASSERT_EQ(tok::newline, Toks[2].getKind());
453}
454
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000455TEST_F(CommentLexerTest, RegisterCustomBlockCommand) {
456 const char *Source = "/// \\NewBlockCommand Aaa.\n";
457
458 Traits.registerBlockCommand(StringRef("NewBlockCommand"));
459
460 std::vector<Token> Toks;
461
462 lexString(Source, Toks);
463
464 ASSERT_EQ(4U, Toks.size());
465
466 ASSERT_EQ(tok::text, Toks[0].getKind());
467 ASSERT_EQ(StringRef(" "), Toks[0].getText());
468
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000469 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000470 ASSERT_EQ(StringRef("NewBlockCommand"), getCommandName(Toks[1]));
471
472 ASSERT_EQ(tok::text, Toks[2].getKind());
473 ASSERT_EQ(StringRef(" Aaa."), Toks[2].getText());
474
475 ASSERT_EQ(tok::newline, Toks[3].getKind());
476}
477
478TEST_F(CommentLexerTest, RegisterMultipleBlockCommands) {
479 const char *Source =
480 "/// \\Foo\n"
481 "/// \\Bar Baz\n"
482 "/// \\Blech quux=corge\n";
483
484 Traits.registerBlockCommand(StringRef("Foo"));
485 Traits.registerBlockCommand(StringRef("Bar"));
486 Traits.registerBlockCommand(StringRef("Blech"));
487
488 std::vector<Token> Toks;
489
490 lexString(Source, Toks);
491
492 ASSERT_EQ(11U, Toks.size());
493
494 ASSERT_EQ(tok::text, Toks[0].getKind());
495 ASSERT_EQ(StringRef(" "), Toks[0].getText());
496
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000497 ASSERT_EQ(tok::backslash_command, Toks[1].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000498 ASSERT_EQ(StringRef("Foo"), getCommandName(Toks[1]));
499
500 ASSERT_EQ(tok::newline, Toks[2].getKind());
501
502 ASSERT_EQ(tok::text, Toks[3].getKind());
503 ASSERT_EQ(StringRef(" "), Toks[3].getText());
504
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000505 ASSERT_EQ(tok::backslash_command, Toks[4].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000506 ASSERT_EQ(StringRef("Bar"), getCommandName(Toks[4]));
507
508 ASSERT_EQ(tok::text, Toks[5].getKind());
509 ASSERT_EQ(StringRef(" Baz"), Toks[5].getText());
510
511 ASSERT_EQ(tok::newline, Toks[6].getKind());
512
513 ASSERT_EQ(tok::text, Toks[7].getKind());
514 ASSERT_EQ(StringRef(" "), Toks[7].getText());
515
Fariborz Jahanian8536fa12013-03-02 02:39:57 +0000516 ASSERT_EQ(tok::backslash_command, Toks[8].getKind());
Dmitri Gribenko6ebf0912013-02-22 14:21:27 +0000517 ASSERT_EQ(StringRef("Blech"), getCommandName(Toks[8]));
518
519 ASSERT_EQ(tok::text, Toks[9].getKind());
520 ASSERT_EQ(StringRef(" quux=corge"), Toks[9].getText());
521
522 ASSERT_EQ(tok::newline, Toks[10].getKind());
523}
524
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000525// Empty verbatim block.
526TEST_F(CommentLexerTest, VerbatimBlock1) {
527 const char *Sources[] = {
528 "/// \\verbatim\\endverbatim\n//",
529 "/** \\verbatim\\endverbatim*/"
530 };
531
532 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
533 std::vector<Token> Toks;
534
535 lexString(Sources[i], Toks);
536
537 ASSERT_EQ(5U, Toks.size());
538
539 ASSERT_EQ(tok::text, Toks[0].getKind());
540 ASSERT_EQ(StringRef(" "), Toks[0].getText());
541
542 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000543 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000544
545 ASSERT_EQ(tok::verbatim_block_end, Toks[2].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000546 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[2]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000547
548 ASSERT_EQ(tok::newline, Toks[3].getKind());
549 ASSERT_EQ(tok::newline, Toks[4].getKind());
550 }
551}
552
553// Empty verbatim block without an end command.
554TEST_F(CommentLexerTest, VerbatimBlock2) {
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000555 const char *Source = "/// \\verbatim";
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000556
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000557 std::vector<Token> Toks;
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000558
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000559 lexString(Source, Toks);
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000560
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000561 ASSERT_EQ(3U, Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000562
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000563 ASSERT_EQ(tok::text, Toks[0].getKind());
564 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000565
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000566 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000567 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000568
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000569 ASSERT_EQ(tok::newline, Toks[2].getKind());
570}
571
572// Empty verbatim block without an end command.
573TEST_F(CommentLexerTest, VerbatimBlock3) {
574 const char *Source = "/** \\verbatim*/";
575
576 std::vector<Token> Toks;
577
578 lexString(Source, Toks);
579
580 ASSERT_EQ(4U, Toks.size());
581
582 ASSERT_EQ(tok::text, Toks[0].getKind());
583 ASSERT_EQ(StringRef(" "), Toks[0].getText());
584
585 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000586 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000587
588 ASSERT_EQ(tok::newline, Toks[2].getKind());
589 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000590}
591
592// Single-line verbatim block.
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000593TEST_F(CommentLexerTest, VerbatimBlock4) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000594 const char *Sources[] = {
595 "/// Meow \\verbatim aaa \\endverbatim\n//",
596 "/** Meow \\verbatim aaa \\endverbatim*/"
597 };
598
599 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
600 std::vector<Token> Toks;
601
602 lexString(Sources[i], Toks);
603
604 ASSERT_EQ(6U, Toks.size());
605
606 ASSERT_EQ(tok::text, Toks[0].getKind());
607 ASSERT_EQ(StringRef(" Meow "), Toks[0].getText());
608
609 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000610 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000611
612 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
613 ASSERT_EQ(StringRef(" aaa "), Toks[2].getVerbatimBlockText());
614
615 ASSERT_EQ(tok::verbatim_block_end, Toks[3].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000616 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[3]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000617
618 ASSERT_EQ(tok::newline, Toks[4].getKind());
619 ASSERT_EQ(tok::newline, Toks[5].getKind());
620 }
621}
622
623// Single-line verbatim block without an end command.
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000624TEST_F(CommentLexerTest, VerbatimBlock5) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000625 const char *Sources[] = {
626 "/// Meow \\verbatim aaa \n//",
627 "/** Meow \\verbatim aaa */"
628 };
629
630 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
631 std::vector<Token> Toks;
632
633 lexString(Sources[i], Toks);
634
635 ASSERT_EQ(5U, Toks.size());
636
637 ASSERT_EQ(tok::text, Toks[0].getKind());
638 ASSERT_EQ(StringRef(" Meow "), Toks[0].getText());
639
640 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000641 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000642
643 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
644 ASSERT_EQ(StringRef(" aaa "), Toks[2].getVerbatimBlockText());
645
646 ASSERT_EQ(tok::newline, Toks[3].getKind());
647 ASSERT_EQ(tok::newline, Toks[4].getKind());
648 }
649}
650
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000651TEST_F(CommentLexerTest, VerbatimBlock6) {
652 const char *Source =
653 "// \\verbatim\n"
654 "// Aaa\n"
655 "//\n"
656 "// Bbb\n"
657 "// \\endverbatim\n";
658
659 std::vector<Token> Toks;
660
661 lexString(Source, Toks);
662
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000663 ASSERT_EQ(10U, Toks.size());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000664
665 ASSERT_EQ(tok::text, Toks[0].getKind());
666 ASSERT_EQ(StringRef(" "), Toks[0].getText());
667
668 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000669 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000670
671 ASSERT_EQ(tok::newline, Toks[2].getKind());
672
673 ASSERT_EQ(tok::verbatim_block_line, Toks[3].getKind());
674 ASSERT_EQ(StringRef(" Aaa"), Toks[3].getVerbatimBlockText());
675
676 ASSERT_EQ(tok::newline, Toks[4].getKind());
677
678 ASSERT_EQ(tok::newline, Toks[5].getKind());
679
680 ASSERT_EQ(tok::verbatim_block_line, Toks[6].getKind());
681 ASSERT_EQ(StringRef(" Bbb"), Toks[6].getVerbatimBlockText());
682
683 ASSERT_EQ(tok::newline, Toks[7].getKind());
684
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000685 ASSERT_EQ(tok::verbatim_block_end, Toks[8].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000686 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[8]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000687
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000688 ASSERT_EQ(tok::newline, Toks[9].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000689}
690
691TEST_F(CommentLexerTest, VerbatimBlock7) {
692 const char *Source =
693 "/* \\verbatim\n"
694 " * Aaa\n"
695 " *\n"
696 " * Bbb\n"
697 " * \\endverbatim\n"
698 " */";
699
700 std::vector<Token> Toks;
701
702 lexString(Source, Toks);
703
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000704 ASSERT_EQ(10U, Toks.size());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000705
706 ASSERT_EQ(tok::text, Toks[0].getKind());
707 ASSERT_EQ(StringRef(" "), Toks[0].getText());
708
709 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000710 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000711
712 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
713 ASSERT_EQ(StringRef(" Aaa"), Toks[2].getVerbatimBlockText());
714
715 ASSERT_EQ(tok::verbatim_block_line, Toks[3].getKind());
716 ASSERT_EQ(StringRef(""), Toks[3].getVerbatimBlockText());
717
718 ASSERT_EQ(tok::verbatim_block_line, Toks[4].getKind());
719 ASSERT_EQ(StringRef(" Bbb"), Toks[4].getVerbatimBlockText());
720
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000721 ASSERT_EQ(tok::verbatim_block_end, Toks[5].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000722 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[5]));
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000723
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000724 ASSERT_EQ(tok::newline, Toks[6].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000725
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000726 ASSERT_EQ(tok::text, Toks[7].getKind());
727 ASSERT_EQ(StringRef(" "), Toks[7].getText());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000728
Dmitri Gribenko64da4e52012-07-18 23:01:58 +0000729 ASSERT_EQ(tok::newline, Toks[8].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000730 ASSERT_EQ(tok::newline, Toks[9].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000731}
732
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000733// Complex test for verbatim blocks.
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000734TEST_F(CommentLexerTest, VerbatimBlock8) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000735 const char *Source =
736 "/* Meow \\verbatim aaa\\$\\@\n"
737 "bbb \\endverbati\r"
738 "ccc\r\n"
739 "ddd \\endverbatim Blah \\verbatim eee\n"
740 "\\endverbatim BlahBlah*/";
741 std::vector<Token> Toks;
742
743 lexString(Source, Toks);
744
745 ASSERT_EQ(14U, Toks.size());
746
747 ASSERT_EQ(tok::text, Toks[0].getKind());
748 ASSERT_EQ(StringRef(" Meow "), Toks[0].getText());
749
750 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000751 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000752
753 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000754 ASSERT_EQ(StringRef(" aaa\\$\\@"), Toks[2].getVerbatimBlockText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000755
756 ASSERT_EQ(tok::verbatim_block_line, Toks[3].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000757 ASSERT_EQ(StringRef("bbb \\endverbati"), Toks[3].getVerbatimBlockText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000758
759 ASSERT_EQ(tok::verbatim_block_line, Toks[4].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000760 ASSERT_EQ(StringRef("ccc"), Toks[4].getVerbatimBlockText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000761
762 ASSERT_EQ(tok::verbatim_block_line, Toks[5].getKind());
763 ASSERT_EQ(StringRef("ddd "), Toks[5].getVerbatimBlockText());
764
765 ASSERT_EQ(tok::verbatim_block_end, Toks[6].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000766 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[6]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000767
768 ASSERT_EQ(tok::text, Toks[7].getKind());
769 ASSERT_EQ(StringRef(" Blah "), Toks[7].getText());
770
771 ASSERT_EQ(tok::verbatim_block_begin, Toks[8].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000772 ASSERT_EQ(StringRef("verbatim"), getVerbatimBlockName(Toks[8]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000773
774 ASSERT_EQ(tok::verbatim_block_line, Toks[9].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000775 ASSERT_EQ(StringRef(" eee"), Toks[9].getVerbatimBlockText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000776
777 ASSERT_EQ(tok::verbatim_block_end, Toks[10].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000778 ASSERT_EQ(StringRef("endverbatim"), getVerbatimBlockName(Toks[10]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000779
780 ASSERT_EQ(tok::text, Toks[11].getKind());
781 ASSERT_EQ(StringRef(" BlahBlah"), Toks[11].getText());
782
783 ASSERT_EQ(tok::newline, Toks[12].getKind());
784 ASSERT_EQ(tok::newline, Toks[13].getKind());
785}
786
787// LaTeX verbatim blocks.
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +0000788TEST_F(CommentLexerTest, VerbatimBlock9) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000789 const char *Source =
790 "/// \\f$ Aaa \\f$ \\f[ Bbb \\f] \\f{ Ccc \\f}";
791 std::vector<Token> Toks;
792
793 lexString(Source, Toks);
794
795 ASSERT_EQ(13U, Toks.size());
796
797 ASSERT_EQ(tok::text, Toks[0].getKind());
798 ASSERT_EQ(StringRef(" "), Toks[0].getText());
799
800 ASSERT_EQ(tok::verbatim_block_begin, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000801 ASSERT_EQ(StringRef("f$"), getVerbatimBlockName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000802
803 ASSERT_EQ(tok::verbatim_block_line, Toks[2].getKind());
804 ASSERT_EQ(StringRef(" Aaa "), Toks[2].getVerbatimBlockText());
805
806 ASSERT_EQ(tok::verbatim_block_end, Toks[3].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000807 ASSERT_EQ(StringRef("f$"), getVerbatimBlockName(Toks[3]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000808
809 ASSERT_EQ(tok::text, Toks[4].getKind());
810 ASSERT_EQ(StringRef(" "), Toks[4].getText());
811
812 ASSERT_EQ(tok::verbatim_block_begin, Toks[5].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000813 ASSERT_EQ(StringRef("f["), getVerbatimBlockName(Toks[5]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000814
815 ASSERT_EQ(tok::verbatim_block_line, Toks[6].getKind());
816 ASSERT_EQ(StringRef(" Bbb "), Toks[6].getVerbatimBlockText());
817
818 ASSERT_EQ(tok::verbatim_block_end, Toks[7].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000819 ASSERT_EQ(StringRef("f]"), getVerbatimBlockName(Toks[7]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000820
821 ASSERT_EQ(tok::text, Toks[8].getKind());
822 ASSERT_EQ(StringRef(" "), Toks[8].getText());
823
824 ASSERT_EQ(tok::verbatim_block_begin, Toks[9].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000825 ASSERT_EQ(StringRef("f{"), getVerbatimBlockName(Toks[9]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000826
827 ASSERT_EQ(tok::verbatim_block_line, Toks[10].getKind());
828 ASSERT_EQ(StringRef(" Ccc "), Toks[10].getVerbatimBlockText());
829
830 ASSERT_EQ(tok::verbatim_block_end, Toks[11].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000831 ASSERT_EQ(StringRef("f}"), getVerbatimBlockName(Toks[11]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000832
833 ASSERT_EQ(tok::newline, Toks[12].getKind());
834}
835
836// Empty verbatim line.
837TEST_F(CommentLexerTest, VerbatimLine1) {
838 const char *Sources[] = {
839 "/// \\fn\n//",
840 "/** \\fn*/"
841 };
842
843 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
844 std::vector<Token> Toks;
845
846 lexString(Sources[i], Toks);
847
848 ASSERT_EQ(4U, Toks.size());
849
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000850 ASSERT_EQ(tok::text, Toks[0].getKind());
851 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000852
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000853 ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000854 ASSERT_EQ(StringRef("fn"), getVerbatimLineName(Toks[1]));
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000855
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000856 ASSERT_EQ(tok::newline, Toks[2].getKind());
857 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000858 }
859}
860
861// Verbatim line with Doxygen escape sequences, which should not be expanded.
862TEST_F(CommentLexerTest, VerbatimLine2) {
863 const char *Sources[] = {
864 "/// \\fn void *foo(const char *zzz = \"\\$\");\n//",
865 "/** \\fn void *foo(const char *zzz = \"\\$\");*/"
866 };
867
868 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
869 std::vector<Token> Toks;
870
871 lexString(Sources[i], Toks);
872
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000873 ASSERT_EQ(5U, Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000874
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000875 ASSERT_EQ(tok::text, Toks[0].getKind());
876 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000877
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000878 ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000879 ASSERT_EQ(StringRef("fn"), getVerbatimLineName(Toks[1]));
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000880
881 ASSERT_EQ(tok::verbatim_line_text, Toks[2].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000882 ASSERT_EQ(StringRef(" void *foo(const char *zzz = \"\\$\");"),
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000883 Toks[2].getVerbatimLineText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000884
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000885 ASSERT_EQ(tok::newline, Toks[3].getKind());
886 ASSERT_EQ(tok::newline, Toks[4].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000887 }
888}
889
890// Verbatim line should not eat anything from next source line.
891TEST_F(CommentLexerTest, VerbatimLine3) {
892 const char *Source =
893 "/** \\fn void *foo(const char *zzz = \"\\$\");\n"
894 " * Meow\n"
895 " */";
896
897 std::vector<Token> Toks;
898
899 lexString(Source, Toks);
900
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000901 ASSERT_EQ(9U, Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000902
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000903 ASSERT_EQ(tok::text, Toks[0].getKind());
904 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000905
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000906 ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
Dmitri Gribenkoe4330a32012-09-10 20:32:42 +0000907 ASSERT_EQ(StringRef("fn"), getVerbatimLineName(Toks[1]));
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000908
909 ASSERT_EQ(tok::verbatim_line_text, Toks[2].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000910 ASSERT_EQ(StringRef(" void *foo(const char *zzz = \"\\$\");"),
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000911 Toks[2].getVerbatimLineText());
912 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000913
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000914 ASSERT_EQ(tok::text, Toks[4].getKind());
915 ASSERT_EQ(StringRef(" Meow"), Toks[4].getText());
916 ASSERT_EQ(tok::newline, Toks[5].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000917
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000918 ASSERT_EQ(tok::text, Toks[6].getKind());
919 ASSERT_EQ(StringRef(" "), Toks[6].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000920
Dmitri Gribenko962668d2012-06-27 16:53:58 +0000921 ASSERT_EQ(tok::newline, Toks[7].getKind());
922 ASSERT_EQ(tok::newline, Toks[8].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000923}
924
925TEST_F(CommentLexerTest, HTML1) {
926 const char *Source =
927 "// <";
928
929 std::vector<Token> Toks;
930
931 lexString(Source, Toks);
932
933 ASSERT_EQ(3U, Toks.size());
934
935 ASSERT_EQ(tok::text, Toks[0].getKind());
936 ASSERT_EQ(StringRef(" "), Toks[0].getText());
937
938 ASSERT_EQ(tok::text, Toks[1].getKind());
939 ASSERT_EQ(StringRef("<"), Toks[1].getText());
940
941 ASSERT_EQ(tok::newline, Toks[2].getKind());
942}
943
944TEST_F(CommentLexerTest, HTML2) {
Dmitri Gribenko5676d322012-06-27 23:28:29 +0000945 const char *Source =
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +0000946 "// a<2";
947
948 std::vector<Token> Toks;
949
950 lexString(Source, Toks);
951
952 ASSERT_EQ(4U, Toks.size());
953
954 ASSERT_EQ(tok::text, Toks[0].getKind());
955 ASSERT_EQ(StringRef(" a"), Toks[0].getText());
956
957 ASSERT_EQ(tok::text, Toks[1].getKind());
958 ASSERT_EQ(StringRef("<"), Toks[1].getText());
959
960 ASSERT_EQ(tok::text, Toks[2].getKind());
961 ASSERT_EQ(StringRef("2"), Toks[2].getText());
962
963 ASSERT_EQ(tok::newline, Toks[3].getKind());
964}
965
966TEST_F(CommentLexerTest, HTML3) {
967 const char *Source =
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +0000968 "// < img";
Dmitri Gribenko5676d322012-06-27 23:28:29 +0000969
970 std::vector<Token> Toks;
971
972 lexString(Source, Toks);
973
974 ASSERT_EQ(4U, Toks.size());
975
976 ASSERT_EQ(tok::text, Toks[0].getKind());
977 ASSERT_EQ(StringRef(" "), Toks[0].getText());
978
979 ASSERT_EQ(tok::text, Toks[1].getKind());
980 ASSERT_EQ(StringRef("<"), Toks[1].getText());
981
982 ASSERT_EQ(tok::text, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +0000983 ASSERT_EQ(StringRef(" img"), Toks[2].getText());
Dmitri Gribenko5676d322012-06-27 23:28:29 +0000984
985 ASSERT_EQ(tok::newline, Toks[3].getKind());
986}
987
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +0000988TEST_F(CommentLexerTest, HTML4) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000989 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +0000990 "// <img",
991 "// <img "
Dmitri Gribenko2d44d772012-06-26 20:39:18 +0000992 };
993
994 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
995 std::vector<Token> Toks;
996
997 lexString(Sources[i], Toks);
998
999 ASSERT_EQ(3U, Toks.size());
1000
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001001 ASSERT_EQ(tok::text, Toks[0].getKind());
1002 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001003
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001004 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001005 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001006
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001007 ASSERT_EQ(tok::newline, Toks[2].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001008 }
1009}
1010
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001011TEST_F(CommentLexerTest, HTML5) {
1012 const char *Source =
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001013 "// <img 42";
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001014
1015 std::vector<Token> Toks;
1016
1017 lexString(Source, Toks);
1018
1019 ASSERT_EQ(4U, Toks.size());
1020
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001021 ASSERT_EQ(tok::text, Toks[0].getKind());
1022 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001023
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001024 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001025 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001026
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001027 ASSERT_EQ(tok::text, Toks[2].getKind());
1028 ASSERT_EQ(StringRef("42"), Toks[2].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001029
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001030 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001031}
1032
1033TEST_F(CommentLexerTest, HTML6) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001034 const char *Source = "// <img> Meow";
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001035
1036 std::vector<Token> Toks;
1037
1038 lexString(Source, Toks);
1039
1040 ASSERT_EQ(5U, Toks.size());
1041
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001042 ASSERT_EQ(tok::text, Toks[0].getKind());
1043 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001044
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001045 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001046 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001047
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001048 ASSERT_EQ(tok::html_greater, Toks[2].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001049
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001050 ASSERT_EQ(tok::text, Toks[3].getKind());
1051 ASSERT_EQ(StringRef(" Meow"), Toks[3].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001052
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001053 ASSERT_EQ(tok::newline, Toks[4].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001054}
1055
1056TEST_F(CommentLexerTest, HTML7) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001057 const char *Source = "// <img=";
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001058
1059 std::vector<Token> Toks;
1060
1061 lexString(Source, Toks);
1062
1063 ASSERT_EQ(4U, Toks.size());
1064
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001065 ASSERT_EQ(tok::text, Toks[0].getKind());
1066 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001067
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001068 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001069 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001070
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001071 ASSERT_EQ(tok::text, Toks[2].getKind());
1072 ASSERT_EQ(StringRef("="), Toks[2].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001073
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001074 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001075}
1076
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001077TEST_F(CommentLexerTest, HTML8) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001078 const char *Source = "// <img src=> Meow";
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001079
1080 std::vector<Token> Toks;
1081
1082 lexString(Source, Toks);
1083
1084 ASSERT_EQ(7U, Toks.size());
1085
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001086 ASSERT_EQ(tok::text, Toks[0].getKind());
1087 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001088
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001089 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001090 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001091
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001092 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001093 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001094
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001095 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001096
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001097 ASSERT_EQ(tok::html_greater, Toks[4].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001098
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001099 ASSERT_EQ(tok::text, Toks[5].getKind());
1100 ASSERT_EQ(StringRef(" Meow"), Toks[5].getText());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001101
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001102 ASSERT_EQ(tok::newline, Toks[6].getKind());
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001103}
1104
1105TEST_F(CommentLexerTest, HTML9) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001106 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001107 "// <img src",
1108 "// <img src "
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001109 };
1110
1111 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1112 std::vector<Token> Toks;
1113
1114 lexString(Sources[i], Toks);
1115
1116 ASSERT_EQ(4U, Toks.size());
1117
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001118 ASSERT_EQ(tok::text, Toks[0].getKind());
1119 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001120
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001121 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001122 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001123
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001124 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001125 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001126
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001127 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001128 }
1129}
1130
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001131TEST_F(CommentLexerTest, HTML10) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001132 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001133 "// <img src=",
1134 "// <img src ="
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001135 };
1136
1137 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1138 std::vector<Token> Toks;
1139
1140 lexString(Sources[i], Toks);
1141
1142 ASSERT_EQ(5U, Toks.size());
1143
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001144 ASSERT_EQ(tok::text, Toks[0].getKind());
1145 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001146
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001147 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001148 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001149
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001150 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001151 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001152
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001153 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001154
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001155 ASSERT_EQ(tok::newline, Toks[4].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001156 }
1157}
1158
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001159TEST_F(CommentLexerTest, HTML11) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001160 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001161 "// <img src=\"",
1162 "// <img src = \"",
1163 "// <img src=\'",
1164 "// <img src = \'"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001165 };
1166
1167 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1168 std::vector<Token> Toks;
1169
1170 lexString(Sources[i], Toks);
1171
1172 ASSERT_EQ(6U, Toks.size());
1173
1174 ASSERT_EQ(tok::text, Toks[0].getKind());
1175 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1176
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001177 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001178 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001179
1180 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001181 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001182
1183 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
1184
1185 ASSERT_EQ(tok::html_quoted_string, Toks[4].getKind());
1186 ASSERT_EQ(StringRef(""), Toks[4].getHTMLQuotedString());
1187
1188 ASSERT_EQ(tok::newline, Toks[5].getKind());
1189 }
1190}
1191
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001192TEST_F(CommentLexerTest, HTML12) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001193 const char *Source = "// <img src=@";
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001194
1195 std::vector<Token> Toks;
1196
1197 lexString(Source, Toks);
1198
1199 ASSERT_EQ(6U, Toks.size());
1200
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001201 ASSERT_EQ(tok::text, Toks[0].getKind());
1202 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001203
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001204 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001205 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001206
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001207 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001208 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001209
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001210 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001211
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001212 ASSERT_EQ(tok::text, Toks[4].getKind());
1213 ASSERT_EQ(StringRef("@"), Toks[4].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001214
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001215 ASSERT_EQ(tok::newline, Toks[5].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001216}
1217
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001218TEST_F(CommentLexerTest, HTML13) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001219 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001220 "// <img src=\"val\\\"\\'val",
1221 "// <img src=\"val\\\"\\'val\"",
1222 "// <img src=\'val\\\"\\'val",
1223 "// <img src=\'val\\\"\\'val\'"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001224 };
1225
1226 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1227 std::vector<Token> Toks;
1228
1229 lexString(Sources[i], Toks);
1230
1231 ASSERT_EQ(6U, Toks.size());
1232
1233 ASSERT_EQ(tok::text, Toks[0].getKind());
1234 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1235
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001236 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001237 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001238
1239 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001240 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001241
1242 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
1243
1244 ASSERT_EQ(tok::html_quoted_string, Toks[4].getKind());
1245 ASSERT_EQ(StringRef("val\\\"\\'val"), Toks[4].getHTMLQuotedString());
1246
1247 ASSERT_EQ(tok::newline, Toks[5].getKind());
1248 }
1249}
1250
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001251TEST_F(CommentLexerTest, HTML14) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001252 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001253 "// <img src=\"val\\\"\\'val\">",
1254 "// <img src=\'val\\\"\\'val\'>"
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001255 };
1256
1257 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1258 std::vector<Token> Toks;
1259
1260 lexString(Sources[i], Toks);
1261
1262 ASSERT_EQ(7U, Toks.size());
1263
1264 ASSERT_EQ(tok::text, Toks[0].getKind());
1265 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1266
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001267 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001268 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001269
1270 ASSERT_EQ(tok::html_ident, Toks[2].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001271 ASSERT_EQ(StringRef("src"), Toks[2].getHTMLIdent());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001272
1273 ASSERT_EQ(tok::html_equals, Toks[3].getKind());
1274
1275 ASSERT_EQ(tok::html_quoted_string, Toks[4].getKind());
1276 ASSERT_EQ(StringRef("val\\\"\\'val"), Toks[4].getHTMLQuotedString());
1277
1278 ASSERT_EQ(tok::html_greater, Toks[5].getKind());
1279
1280 ASSERT_EQ(tok::newline, Toks[6].getKind());
1281 }
1282}
1283
Dmitri Gribenkoa99ec102012-07-09 21:32:40 +00001284TEST_F(CommentLexerTest, HTML15) {
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001285 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001286 "// <img/>",
1287 "// <img />"
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001288 };
1289
1290 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1291 std::vector<Token> Toks;
1292
1293 lexString(Sources[i], Toks);
1294
1295 ASSERT_EQ(4U, Toks.size());
1296
1297 ASSERT_EQ(tok::text, Toks[0].getKind());
1298 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1299
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001300 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001301 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001302
1303 ASSERT_EQ(tok::html_slash_greater, Toks[2].getKind());
1304
1305 ASSERT_EQ(tok::newline, Toks[3].getKind());
1306 }
1307}
1308
1309TEST_F(CommentLexerTest, HTML16) {
1310 const char *Sources[] = {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001311 "// <img/ Aaa",
1312 "// <img / Aaa"
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001313 };
1314
1315 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1316 std::vector<Token> Toks;
1317
1318 lexString(Sources[i], Toks);
1319
1320 ASSERT_EQ(5U, Toks.size());
1321
1322 ASSERT_EQ(tok::text, Toks[0].getKind());
1323 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1324
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001325 ASSERT_EQ(tok::html_start_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001326 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagStartName());
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001327
1328 ASSERT_EQ(tok::text, Toks[2].getKind());
1329 ASSERT_EQ(StringRef("/"), Toks[2].getText());
1330
1331 ASSERT_EQ(tok::text, Toks[3].getKind());
1332 ASSERT_EQ(StringRef(" Aaa"), Toks[3].getText());
1333
1334 ASSERT_EQ(tok::newline, Toks[4].getKind());
1335 }
1336}
1337
1338TEST_F(CommentLexerTest, HTML17) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001339 const char *Source = "// </";
1340
1341 std::vector<Token> Toks;
1342
1343 lexString(Source, Toks);
1344
1345 ASSERT_EQ(3U, Toks.size());
1346
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001347 ASSERT_EQ(tok::text, Toks[0].getKind());
1348 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001349
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001350 ASSERT_EQ(tok::text, Toks[1].getKind());
1351 ASSERT_EQ(StringRef("</"), Toks[1].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001352
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001353 ASSERT_EQ(tok::newline, Toks[2].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001354}
1355
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001356TEST_F(CommentLexerTest, HTML18) {
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001357 const char *Source = "// </@";
1358
1359 std::vector<Token> Toks;
1360
1361 lexString(Source, Toks);
1362
1363 ASSERT_EQ(4U, Toks.size());
1364
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001365 ASSERT_EQ(tok::text, Toks[0].getKind());
1366 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001367
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001368 ASSERT_EQ(tok::text, Toks[1].getKind());
1369 ASSERT_EQ(StringRef("</"), Toks[1].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001370
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001371 ASSERT_EQ(tok::text, Toks[2].getKind());
1372 ASSERT_EQ(StringRef("@"), Toks[2].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001373
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001374 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001375}
1376
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00001377TEST_F(CommentLexerTest, HTML19) {
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001378 const char *Source = "// </img";
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001379
1380 std::vector<Token> Toks;
1381
1382 lexString(Source, Toks);
1383
1384 ASSERT_EQ(3U, Toks.size());
1385
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001386 ASSERT_EQ(tok::text, Toks[0].getKind());
1387 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001388
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001389 ASSERT_EQ(tok::html_end_tag, Toks[1].getKind());
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001390 ASSERT_EQ(StringRef("img"), Toks[1].getHTMLTagEndName());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001391
Dmitri Gribenko3f38bf22012-07-13 00:44:24 +00001392 ASSERT_EQ(tok::newline, Toks[2].getKind());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001393}
1394
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001395TEST_F(CommentLexerTest, NotAKnownHTMLTag1) {
1396 const char *Source = "// <tag>";
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001397
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001398 std::vector<Token> Toks;
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001399
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001400 lexString(Source, Toks);
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001401
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001402 ASSERT_EQ(4U, Toks.size());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001403
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001404 ASSERT_EQ(tok::text, Toks[0].getKind());
1405 ASSERT_EQ(StringRef(" "), Toks[0].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001406
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001407 ASSERT_EQ(tok::text, Toks[1].getKind());
1408 ASSERT_EQ(StringRef("<tag"), Toks[1].getText());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001409
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001410 ASSERT_EQ(tok::text, Toks[2].getKind());
1411 ASSERT_EQ(StringRef(">"), Toks[2].getText());
Dmitri Gribenko8d3ba232012-07-06 00:28:32 +00001412
Dmitri Gribenko834a5bd2012-08-22 22:56:08 +00001413 ASSERT_EQ(tok::newline, Toks[3].getKind());
1414}
1415
1416TEST_F(CommentLexerTest, NotAKnownHTMLTag2) {
1417 const char *Source = "// </tag>";
1418
1419 std::vector<Token> Toks;
1420
1421 lexString(Source, Toks);
1422
1423 ASSERT_EQ(4U, Toks.size());
1424
1425 ASSERT_EQ(tok::text, Toks[0].getKind());
1426 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1427
1428 ASSERT_EQ(tok::text, Toks[1].getKind());
1429 ASSERT_EQ(StringRef("</tag"), Toks[1].getText());
1430
1431 ASSERT_EQ(tok::text, Toks[2].getKind());
1432 ASSERT_EQ(StringRef(">"), Toks[2].getText());
1433
1434 ASSERT_EQ(tok::newline, Toks[3].getKind());
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001435}
1436
Dmitri Gribenko477a9f52012-07-27 20:37:06 +00001437TEST_F(CommentLexerTest, HTMLCharacterReferences1) {
1438 const char *Source = "// &";
1439
1440 std::vector<Token> Toks;
1441
1442 lexString(Source, Toks);
1443
1444 ASSERT_EQ(3U, Toks.size());
1445
1446 ASSERT_EQ(tok::text, Toks[0].getKind());
1447 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1448
1449 ASSERT_EQ(tok::text, Toks[1].getKind());
1450 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1451
1452 ASSERT_EQ(tok::newline, Toks[2].getKind());
1453}
1454
1455TEST_F(CommentLexerTest, HTMLCharacterReferences2) {
1456 const char *Source = "// &!";
1457
1458 std::vector<Token> Toks;
1459
1460 lexString(Source, Toks);
1461
1462 ASSERT_EQ(4U, Toks.size());
1463
1464 ASSERT_EQ(tok::text, Toks[0].getKind());
1465 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1466
1467 ASSERT_EQ(tok::text, Toks[1].getKind());
1468 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1469
1470 ASSERT_EQ(tok::text, Toks[2].getKind());
1471 ASSERT_EQ(StringRef("!"), Toks[2].getText());
1472
1473 ASSERT_EQ(tok::newline, Toks[3].getKind());
1474}
1475
1476TEST_F(CommentLexerTest, HTMLCharacterReferences3) {
1477 const char *Source = "// &amp";
1478
1479 std::vector<Token> Toks;
1480
1481 lexString(Source, Toks);
1482
1483 ASSERT_EQ(3U, Toks.size());
1484
1485 ASSERT_EQ(tok::text, Toks[0].getKind());
1486 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1487
1488 ASSERT_EQ(tok::text, Toks[1].getKind());
1489 ASSERT_EQ(StringRef("&amp"), Toks[1].getText());
1490
1491 ASSERT_EQ(tok::newline, Toks[2].getKind());
1492}
1493
1494TEST_F(CommentLexerTest, HTMLCharacterReferences4) {
1495 const char *Source = "// &amp!";
1496
1497 std::vector<Token> Toks;
1498
1499 lexString(Source, Toks);
1500
1501 ASSERT_EQ(4U, Toks.size());
1502
1503 ASSERT_EQ(tok::text, Toks[0].getKind());
1504 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1505
1506 ASSERT_EQ(tok::text, Toks[1].getKind());
1507 ASSERT_EQ(StringRef("&amp"), Toks[1].getText());
1508
1509 ASSERT_EQ(tok::text, Toks[2].getKind());
1510 ASSERT_EQ(StringRef("!"), Toks[2].getText());
1511
1512 ASSERT_EQ(tok::newline, Toks[3].getKind());
1513}
1514
1515TEST_F(CommentLexerTest, HTMLCharacterReferences5) {
1516 const char *Source = "// &#";
1517
1518 std::vector<Token> Toks;
1519
1520 lexString(Source, Toks);
1521
1522 ASSERT_EQ(3U, Toks.size());
1523
1524 ASSERT_EQ(tok::text, Toks[0].getKind());
1525 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1526
1527 ASSERT_EQ(tok::text, Toks[1].getKind());
1528 ASSERT_EQ(StringRef("&#"), Toks[1].getText());
1529
1530 ASSERT_EQ(tok::newline, Toks[2].getKind());
1531}
1532
1533TEST_F(CommentLexerTest, HTMLCharacterReferences6) {
1534 const char *Source = "// &#a";
1535
1536 std::vector<Token> Toks;
1537
1538 lexString(Source, Toks);
1539
1540 ASSERT_EQ(4U, Toks.size());
1541
1542 ASSERT_EQ(tok::text, Toks[0].getKind());
1543 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1544
1545 ASSERT_EQ(tok::text, Toks[1].getKind());
1546 ASSERT_EQ(StringRef("&#"), Toks[1].getText());
1547
1548 ASSERT_EQ(tok::text, Toks[2].getKind());
1549 ASSERT_EQ(StringRef("a"), Toks[2].getText());
1550
1551 ASSERT_EQ(tok::newline, Toks[3].getKind());
1552}
1553
1554TEST_F(CommentLexerTest, HTMLCharacterReferences7) {
1555 const char *Source = "// &#42";
1556
1557 std::vector<Token> Toks;
1558
1559 lexString(Source, Toks);
1560
1561 ASSERT_EQ(3U, Toks.size());
1562
1563 ASSERT_EQ(tok::text, Toks[0].getKind());
1564 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1565
1566 ASSERT_EQ(tok::text, Toks[1].getKind());
1567 ASSERT_EQ(StringRef("&#42"), Toks[1].getText());
1568
1569 ASSERT_EQ(tok::newline, Toks[2].getKind());
1570}
1571
1572TEST_F(CommentLexerTest, HTMLCharacterReferences8) {
1573 const char *Source = "// &#42a";
1574
1575 std::vector<Token> Toks;
1576
1577 lexString(Source, Toks);
1578
1579 ASSERT_EQ(4U, Toks.size());
1580
1581 ASSERT_EQ(tok::text, Toks[0].getKind());
1582 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1583
1584 ASSERT_EQ(tok::text, Toks[1].getKind());
1585 ASSERT_EQ(StringRef("&#42"), Toks[1].getText());
1586
1587 ASSERT_EQ(tok::text, Toks[2].getKind());
1588 ASSERT_EQ(StringRef("a"), Toks[2].getText());
1589
1590 ASSERT_EQ(tok::newline, Toks[3].getKind());
1591}
1592
1593TEST_F(CommentLexerTest, HTMLCharacterReferences9) {
1594 const char *Source = "// &#x";
1595
1596 std::vector<Token> Toks;
1597
1598 lexString(Source, Toks);
1599
1600 ASSERT_EQ(3U, Toks.size());
1601
1602 ASSERT_EQ(tok::text, Toks[0].getKind());
1603 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1604
1605 ASSERT_EQ(tok::text, Toks[1].getKind());
1606 ASSERT_EQ(StringRef("&#x"), Toks[1].getText());
1607
1608 ASSERT_EQ(tok::newline, Toks[2].getKind());
1609}
1610
1611TEST_F(CommentLexerTest, HTMLCharacterReferences10) {
1612 const char *Source = "// &#xz";
1613
1614 std::vector<Token> Toks;
1615
1616 lexString(Source, Toks);
1617
1618 ASSERT_EQ(4U, Toks.size());
1619
1620 ASSERT_EQ(tok::text, Toks[0].getKind());
1621 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1622
1623 ASSERT_EQ(tok::text, Toks[1].getKind());
1624 ASSERT_EQ(StringRef("&#x"), Toks[1].getText());
1625
1626 ASSERT_EQ(tok::text, Toks[2].getKind());
1627 ASSERT_EQ(StringRef("z"), Toks[2].getText());
1628
1629 ASSERT_EQ(tok::newline, Toks[3].getKind());
1630}
1631
1632TEST_F(CommentLexerTest, HTMLCharacterReferences11) {
1633 const char *Source = "// &#xab";
1634
1635 std::vector<Token> Toks;
1636
1637 lexString(Source, Toks);
1638
1639 ASSERT_EQ(3U, Toks.size());
1640
1641 ASSERT_EQ(tok::text, Toks[0].getKind());
1642 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1643
1644 ASSERT_EQ(tok::text, Toks[1].getKind());
1645 ASSERT_EQ(StringRef("&#xab"), Toks[1].getText());
1646
1647 ASSERT_EQ(tok::newline, Toks[2].getKind());
1648}
1649
1650TEST_F(CommentLexerTest, HTMLCharacterReferences12) {
1651 const char *Source = "// &#xaBz";
1652
1653 std::vector<Token> Toks;
1654
1655 lexString(Source, Toks);
1656
1657 ASSERT_EQ(4U, Toks.size());
1658
1659 ASSERT_EQ(tok::text, Toks[0].getKind());
1660 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1661
1662 ASSERT_EQ(tok::text, Toks[1].getKind());
1663 ASSERT_EQ(StringRef("&#xaB"), Toks[1].getText());
1664
1665 ASSERT_EQ(tok::text, Toks[2].getKind());
1666 ASSERT_EQ(StringRef("z"), Toks[2].getText());
1667
1668 ASSERT_EQ(tok::newline, Toks[3].getKind());
1669}
1670
1671TEST_F(CommentLexerTest, HTMLCharacterReferences13) {
1672 const char *Source = "// &amp;";
1673
1674 std::vector<Token> Toks;
1675
1676 lexString(Source, Toks);
1677
1678 ASSERT_EQ(3U, Toks.size());
1679
1680 ASSERT_EQ(tok::text, Toks[0].getKind());
1681 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1682
1683 ASSERT_EQ(tok::text, Toks[1].getKind());
1684 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1685
1686 ASSERT_EQ(tok::newline, Toks[2].getKind());
1687}
1688
1689TEST_F(CommentLexerTest, HTMLCharacterReferences14) {
1690 const char *Source = "// &amp;&lt;";
1691
1692 std::vector<Token> Toks;
1693
1694 lexString(Source, Toks);
1695
1696 ASSERT_EQ(4U, Toks.size());
1697
1698 ASSERT_EQ(tok::text, Toks[0].getKind());
1699 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1700
1701 ASSERT_EQ(tok::text, Toks[1].getKind());
1702 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1703
1704 ASSERT_EQ(tok::text, Toks[2].getKind());
1705 ASSERT_EQ(StringRef("<"), Toks[2].getText());
1706
1707 ASSERT_EQ(tok::newline, Toks[3].getKind());
1708}
1709
1710TEST_F(CommentLexerTest, HTMLCharacterReferences15) {
1711 const char *Source = "// &amp; meow";
1712
1713 std::vector<Token> Toks;
1714
1715 lexString(Source, Toks);
1716
1717 ASSERT_EQ(4U, Toks.size());
1718
1719 ASSERT_EQ(tok::text, Toks[0].getKind());
1720 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1721
1722 ASSERT_EQ(tok::text, Toks[1].getKind());
1723 ASSERT_EQ(StringRef("&"), Toks[1].getText());
1724
1725 ASSERT_EQ(tok::text, Toks[2].getKind());
1726 ASSERT_EQ(StringRef(" meow"), Toks[2].getText());
1727
1728 ASSERT_EQ(tok::newline, Toks[3].getKind());
1729}
1730
1731TEST_F(CommentLexerTest, HTMLCharacterReferences16) {
1732 const char *Sources[] = {
1733 "// &#61;",
1734 "// &#x3d;",
Dmitri Gribenko44a3ddb2013-01-19 22:04:44 +00001735 "// &#X3d;",
1736 "// &#X3D;"
Dmitri Gribenko477a9f52012-07-27 20:37:06 +00001737 };
1738
1739 for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1740 std::vector<Token> Toks;
1741
1742 lexString(Sources[i], Toks);
1743
1744 ASSERT_EQ(3U, Toks.size());
1745
1746 ASSERT_EQ(tok::text, Toks[0].getKind());
1747 ASSERT_EQ(StringRef(" "), Toks[0].getText());
1748
1749 ASSERT_EQ(tok::text, Toks[1].getKind());
1750 ASSERT_EQ(StringRef("="), Toks[1].getText());
1751
1752 ASSERT_EQ(tok::newline, Toks[2].getKind());
1753 }
1754}
1755
Dmitri Gribenko2d44d772012-06-26 20:39:18 +00001756TEST_F(CommentLexerTest, MultipleComments) {
1757 const char *Source =
1758 "// Aaa\n"
1759 "/// Bbb\n"
1760 "/* Ccc\n"
1761 " * Ddd*/\n"
1762 "/** Eee*/";
1763
1764 std::vector<Token> Toks;
1765
1766 lexString(Source, Toks);
1767
1768 ASSERT_EQ(12U, Toks.size());
1769
1770 ASSERT_EQ(tok::text, Toks[0].getKind());
1771 ASSERT_EQ(StringRef(" Aaa"), Toks[0].getText());
1772 ASSERT_EQ(tok::newline, Toks[1].getKind());
1773
1774 ASSERT_EQ(tok::text, Toks[2].getKind());
1775 ASSERT_EQ(StringRef(" Bbb"), Toks[2].getText());
1776 ASSERT_EQ(tok::newline, Toks[3].getKind());
1777
1778 ASSERT_EQ(tok::text, Toks[4].getKind());
1779 ASSERT_EQ(StringRef(" Ccc"), Toks[4].getText());
1780 ASSERT_EQ(tok::newline, Toks[5].getKind());
1781
1782 ASSERT_EQ(tok::text, Toks[6].getKind());
1783 ASSERT_EQ(StringRef(" Ddd"), Toks[6].getText());
1784 ASSERT_EQ(tok::newline, Toks[7].getKind());
1785 ASSERT_EQ(tok::newline, Toks[8].getKind());
1786
1787 ASSERT_EQ(tok::text, Toks[9].getKind());
1788 ASSERT_EQ(StringRef(" Eee"), Toks[9].getText());
1789
1790 ASSERT_EQ(tok::newline, Toks[10].getKind());
1791 ASSERT_EQ(tok::newline, Toks[11].getKind());
1792}
1793
1794} // end namespace comments
1795} // end namespace clang
1796