← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kdevelop-php/utopic

« back to all changes in this revision

Viewing changes to parser/test/lexertest.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Fathi Boudra
  • Date: 2010-01-17 17:10:22 UTC
  • Revision ID: james.westby@ubuntu.com-20100117171022-q2xlgd9ekewo2ijx
Tags: upstream-1.0.0~beta2
Import upstream version 1.0.0~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
parser/test/lexertest.cpp
 
1
/* This file is part of KDevelop
 
2
    Copyright 2006 Hamish Rodda <rodda@kde.org>
 
3
    Copyright 2008 Niko Sams <niko.sams@gmail.com>
 
4
 
 
5
   This library is free software; you can redistribute it and/or
 
6
   modify it under the terms of the GNU Library General Public
 
7
   License version 2 as published by the Free Software Foundation.
 
8
 
 
9
   This library is distributed in the hope that it will be useful,
 
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
   Library General Public License for more details.
 
13
 
 
14
   You should have received a copy of the GNU Library General Public License
 
15
   along with this library; see the file COPYING.LIB.  If not, write to
 
16
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
17
   Boston, MA 02110-1301, USA.
 
18
*/
 
19
 
 
20
#include "lexertest.h"
 
21
 
 
22
#include <QtTest/QtTest>
 
23
 
 
24
#include "parsesession.h"
 
25
#include "phplexer.h"
 
26
#include "phptokentext.h"
 
27
 
 
28
QTEST_MAIN(Php::LexerTest)
 
29
namespace Php
 
30
{
 
31
 
 
32
void compareEndPosition(TokenStream* tokenStream, qint64 index, qint64 expectedLine, qint64 expectedColumn)
 
33
{
 
34
    qint64 line;
 
35
    qint64 column;
 
36
    tokenStream->endPosition(index, &line, &column);
 
37
    kDebug() << "  end" << index << ": actual" << line << column << "expected" << expectedLine << expectedColumn;
 
38
    QCOMPARE(line, expectedLine);
 
39
    QCOMPARE(column, expectedColumn);
 
40
}
 
41
 
 
42
void compareStartPosition(TokenStream* tokenStream, qint64 index, qint64 expectedLine, qint64 expectedColumn)
 
43
{
 
44
    qint64 line;
 
45
    qint64 column;
 
46
    tokenStream->startPosition(index, &line, &column);
 
47
    kDebug() << "start" << index << ": actual" << line << column << "expected" << expectedLine << expectedColumn;
 
48
    QCOMPARE(line, expectedLine);
 
49
    QCOMPARE(column, expectedColumn);
 
50
}
 
51
 
 
52
LexerTest::LexerTest()
 
53
{
 
54
}
 
55
 
 
56
void LexerTest::testOpenTagWithNewline()
 
57
{
 
58
    TokenStream* ts = tokenize("<?php\nfoo;");
 
59
    QVERIFY(ts->size() == 3);
 
60
 
 
61
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
62
    compareStartPosition(ts, 0, 0, 0);
 
63
    compareEndPosition(ts, 0, 0, 5);
 
64
 
 
65
    QVERIFY(ts->token(1).kind == Parser::Token_STRING);
 
66
    compareStartPosition(ts, 1, 1, 0);
 
67
    compareEndPosition(ts, 1, 1, 2);
 
68
 
 
69
    QVERIFY(ts->token(2).kind == Parser::Token_SEMICOLON);
 
70
    compareStartPosition(ts, 2, 1, 3);
 
71
    compareEndPosition(ts, 2, 1, 3);
 
72
    delete ts;
 
73
}
 
74
 
 
75
void LexerTest::testOpenTagWithSpace()
 
76
{
 
77
    TokenStream* ts = tokenize("<?php foo;");
 
78
    QVERIFY(ts->size() == 3);
 
79
 
 
80
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
81
    compareStartPosition(ts, 0, 0, 0);
 
82
    compareEndPosition(ts, 0, 0, 5);
 
83
 
 
84
    QVERIFY(ts->token(1).kind == Parser::Token_STRING);
 
85
    compareStartPosition(ts, 1, 0, 6);
 
86
    compareEndPosition(ts, 1, 0, 8);
 
87
 
 
88
    QVERIFY(ts->token(2).kind == Parser::Token_SEMICOLON);
 
89
    compareStartPosition(ts, 2, 0, 9);
 
90
    compareEndPosition(ts, 2, 0, 9);
 
91
    delete ts;
 
92
}
 
93
 
 
94
void LexerTest::testCommentOneLine()
 
95
{
 
96
    TokenStream* ts = tokenize("<?php\n//comment\nfoo;");
 
97
    QVERIFY(ts->size() == 4);
 
98
 
 
99
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
100
    compareStartPosition(ts, 0, 0, 0);
 
101
    compareEndPosition(ts, 0, 0, 5);
 
102
 
 
103
    QVERIFY(ts->token(1).kind == Parser::Token_COMMENT);
 
104
    compareStartPosition(ts, 1, 1, 0);
 
105
    compareEndPosition(ts, 1, 1, 9);
 
106
 
 
107
    QVERIFY(ts->token(2).kind == Parser::Token_STRING);
 
108
    compareStartPosition(ts, 2, 2, 0);
 
109
    compareEndPosition(ts, 2, 2, 2);
 
110
 
 
111
    QVERIFY(ts->token(3).kind == Parser::Token_SEMICOLON);
 
112
    compareStartPosition(ts, 3, 2, 3);
 
113
    compareEndPosition(ts, 3, 2, 3);
 
114
    delete ts;
 
115
}
 
116
 
 
117
void LexerTest::testCommentOneLine2()
 
118
{
 
119
    TokenStream* ts = tokenize("<?php\n#comment\nfoo;");
 
120
    QVERIFY(ts->size() == 4);
 
121
 
 
122
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
123
    compareStartPosition(ts, 0, 0, 0);
 
124
    compareEndPosition(ts, 0, 0, 5);
 
125
 
 
126
    QVERIFY(ts->token(1).kind == Parser::Token_COMMENT);
 
127
    compareStartPosition(ts, 1, 1, 0);
 
128
    compareEndPosition(ts, 1, 1, 8);
 
129
 
 
130
    QVERIFY(ts->token(2).kind == Parser::Token_STRING);
 
131
    compareStartPosition(ts, 2, 2, 0);
 
132
    compareEndPosition(ts, 2, 2, 2);
 
133
 
 
134
    QVERIFY(ts->token(3).kind == Parser::Token_SEMICOLON);
 
135
    compareStartPosition(ts, 3, 2, 3);
 
136
    compareEndPosition(ts, 3, 2, 3);
 
137
    delete ts;
 
138
}
 
139
 
 
140
void LexerTest::testCommentMultiLine()
 
141
{
 
142
    TokenStream* ts = tokenize("<?php\n/*com\nment*/\nfoo;", true);
 
143
    QVERIFY(ts->size() == 5);
 
144
 
 
145
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
146
    compareStartPosition(ts, 0, 0, 0);
 
147
    compareEndPosition(ts, 0, 0, 5);
 
148
 
 
149
    QVERIFY(ts->token(1).kind == Parser::Token_COMMENT);
 
150
    compareStartPosition(ts, 1, 1, 0);
 
151
    compareEndPosition(ts, 1, 2, 5);
 
152
 
 
153
    QVERIFY(ts->token(2).kind == Parser::Token_WHITESPACE);
 
154
    compareStartPosition(ts, 2, 2, 6);
 
155
    compareEndPosition(ts, 2, 2, 6);
 
156
 
 
157
    QVERIFY(ts->token(3).kind == Parser::Token_STRING);
 
158
    compareStartPosition(ts, 3, 3, 0);
 
159
    compareEndPosition(ts, 3, 3, 2);
 
160
 
 
161
    QVERIFY(ts->token(4).kind == Parser::Token_SEMICOLON);
 
162
    compareStartPosition(ts, 4, 3, 3);
 
163
    compareEndPosition(ts, 4, 3, 3);
 
164
    delete ts;
 
165
}
 
166
 
 
167
void LexerTest::testCommentMultiLine2()
 
168
{
 
169
    TokenStream* ts = tokenize("<?php\n/*\nment*/\nfoo;", true);
 
170
    QVERIFY(ts->size() == 5);
 
171
 
 
172
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
173
    compareStartPosition(ts, 0, 0, 0);
 
174
    compareEndPosition(ts, 0, 0, 5);
 
175
 
 
176
    QVERIFY(ts->token(1).kind == Parser::Token_COMMENT);
 
177
    compareStartPosition(ts, 1, 1, 0);
 
178
    compareEndPosition(ts, 1, 2, 5);
 
179
 
 
180
    QVERIFY(ts->token(2).kind == Parser::Token_WHITESPACE);
 
181
    compareStartPosition(ts, 2, 2, 6);
 
182
    compareEndPosition(ts, 2, 2, 6);
 
183
 
 
184
    QVERIFY(ts->token(3).kind == Parser::Token_STRING);
 
185
    compareStartPosition(ts, 3, 3, 0);
 
186
    compareEndPosition(ts, 3, 3, 2);
 
187
 
 
188
    QVERIFY(ts->token(4).kind == Parser::Token_SEMICOLON);
 
189
    compareStartPosition(ts, 4, 3, 3);
 
190
    compareEndPosition(ts, 4, 3, 3);
 
191
    delete ts;
 
192
}
 
193
 
 
194
void LexerTest::testEndTag()
 
195
{
 
196
    TokenStream* ts = tokenize("<?\n':\n'?>\n>", true, Lexer::DefaultState);
 
197
    //don't crash and we are fine
 
198
    delete ts;
 
199
}
 
200
 
 
201
void LexerTest::testNewlineInString()
 
202
{
 
203
    //0            1
 
204
    //012345 6 7 890123456789
 
205
    TokenStream* ts = tokenize("<?php \"\n\";", true);
 
206
    QVERIFY(ts->size() == 3);
 
207
 
 
208
    QVERIFY(ts->token(1).kind == Parser::Token_CONSTANT_ENCAPSED_STRING);
 
209
    compareStartPosition(ts, 1, 0, 6);
 
210
    compareEndPosition(ts, 1, 1, 0);
 
211
 
 
212
    QVERIFY(ts->token(2).kind == Parser::Token_SEMICOLON);
 
213
    compareStartPosition(ts, 2, 1, 1);
 
214
    compareEndPosition(ts, 2, 1, 1);
 
215
    delete ts;
 
216
}
 
217
 
 
218
void LexerTest::testNewlineInString2()
 
219
{
 
220
    //0
 
221
    //0123 4567
 
222
    TokenStream* ts = tokenize("<?php '\n';", true);
 
223
    QCOMPARE((int)ts->size(), 3);
 
224
 
 
225
    QVERIFY(ts->token(1).kind == Parser::Token_CONSTANT_ENCAPSED_STRING);
 
226
    compareStartPosition(ts, 1, 0, 6);
 
227
    compareEndPosition(ts, 1, 1, 0);
 
228
 
 
229
    QVERIFY(ts->token(2).kind == Parser::Token_SEMICOLON);
 
230
    compareStartPosition(ts, 2, 1, 1);
 
231
    compareEndPosition(ts, 2, 1, 1);
 
232
    delete ts;
 
233
}
 
234
 
 
235
void LexerTest::testNewlineInStringWithVar()
 
236
{
 
237
    TokenStream* ts = tokenize("<?php \"$a\n\";", true);
 
238
    QCOMPARE((int)ts->size(), 6);
 
239
 
 
240
    QVERIFY(ts->token(1).kind == Parser::Token_DOUBLE_QUOTE);
 
241
    compareStartPosition(ts, 1, 0, 6);
 
242
    compareEndPosition(ts, 1, 0, 6);
 
243
 
 
244
    QVERIFY(ts->token(2).kind == Parser::Token_VARIABLE);
 
245
    compareStartPosition(ts, 2, 0, 7);
 
246
    compareEndPosition(ts, 2, 0, 8);
 
247
 
 
248
    QVERIFY(ts->token(3).kind == Parser::Token_ENCAPSED_AND_WHITESPACE);
 
249
    compareStartPosition(ts, 3, 0, 9);
 
250
    compareEndPosition(ts, 3, 0, 9);
 
251
 
 
252
    QVERIFY(ts->token(4).kind == Parser::Token_DOUBLE_QUOTE);
 
253
    compareStartPosition(ts, 4, 1, 0);
 
254
    compareEndPosition(ts, 4, 1, 0);
 
255
 
 
256
    QVERIFY(ts->token(5).kind == Parser::Token_SEMICOLON);
 
257
    compareStartPosition(ts, 5, 1, 1);
 
258
    compareEndPosition(ts, 5, 1, 1);
 
259
    delete ts;
 
260
}
 
261
 
 
262
void LexerTest::testNewlineInStringWithVar2()
 
263
{
 
264
    //0            1
 
265
    //012345 6 789 0123456789
 
266
    TokenStream* ts = tokenize("<?php \"\n$a\n\";", true);
 
267
    QCOMPARE((int)ts->size(), 7);
 
268
 
 
269
    QVERIFY(ts->token(1).kind == Parser::Token_DOUBLE_QUOTE);
 
270
    compareStartPosition(ts, 1, 0, 6);
 
271
    compareEndPosition(ts, 1, 0, 6);
 
272
 
 
273
    QVERIFY(ts->token(2).kind == Parser::Token_ENCAPSED_AND_WHITESPACE);
 
274
    compareStartPosition(ts, 2, 0, 7);
 
275
    compareEndPosition(ts, 2, 0, 7);
 
276
 
 
277
    QVERIFY(ts->token(3).kind == Parser::Token_VARIABLE);
 
278
    compareStartPosition(ts, 3, 1, 0);
 
279
    compareEndPosition(ts, 3, 1, 1);
 
280
 
 
281
    QVERIFY(ts->token(4).kind == Parser::Token_ENCAPSED_AND_WHITESPACE);
 
282
    compareStartPosition(ts, 4, 1, 2);
 
283
    compareEndPosition(ts, 4, 1, 2);
 
284
 
 
285
    QVERIFY(ts->token(5).kind == Parser::Token_DOUBLE_QUOTE);
 
286
    compareStartPosition(ts, 5, 2, 0);
 
287
    compareEndPosition(ts, 5, 2, 0);
 
288
 
 
289
    QVERIFY(ts->token(6).kind == Parser::Token_SEMICOLON);
 
290
    compareStartPosition(ts, 6, 2, 1);
 
291
    compareEndPosition(ts, 6, 2, 1);
 
292
    delete ts;
 
293
}
 
294
 
 
295
void LexerTest::testNewlineInStringWithVar3()
 
296
{
 
297
    //0            1
 
298
    //012345 6 789 0123456789
 
299
    TokenStream* ts = tokenize("<?php \"{$$a}\";", true);
 
300
    QCOMPARE((int)ts->size(), 7);
 
301
 
 
302
    QVERIFY(ts->token(1).kind == Parser::Token_DOUBLE_QUOTE);
 
303
    compareStartPosition(ts, 1, 0, 6);
 
304
    compareEndPosition(ts, 1, 0, 6);
 
305
 
 
306
    QVERIFY(ts->token(2).kind == Parser::Token_ENCAPSED_AND_WHITESPACE);
 
307
    compareStartPosition(ts, 2, 0, 7);
 
308
    compareEndPosition(ts, 2, 0, 8);
 
309
 
 
310
    QVERIFY(ts->token(3).kind == Parser::Token_VARIABLE);
 
311
    compareStartPosition(ts, 3, 0, 9);
 
312
    compareEndPosition(ts, 3, 0, 10);
 
313
 
 
314
    QVERIFY(ts->token(4).kind == Parser::Token_ENCAPSED_AND_WHITESPACE);
 
315
    compareStartPosition(ts, 4, 0, 11);
 
316
    compareEndPosition(ts, 4, 0, 11);
 
317
 
 
318
    QVERIFY(ts->token(5).kind == Parser::Token_DOUBLE_QUOTE);
 
319
    compareStartPosition(ts, 5, 0, 12);
 
320
    compareEndPosition(ts, 5, 0, 12);
 
321
 
 
322
    QVERIFY(ts->token(6).kind == Parser::Token_SEMICOLON);
 
323
    compareStartPosition(ts, 6, 0, 13);
 
324
    compareEndPosition(ts, 6, 0, 13);
 
325
    delete ts;
 
326
}
 
327
 
 
328
void LexerTest::testMultiplePhpSections()
 
329
{
 
330
 
 
331
    //0            1
 
332
    //012345 6 789 0123456789
 
333
    TokenStream* ts = tokenize("<?php $a;?>\n<html>\n<?php $a;?>", true);
 
334
    QCOMPARE((int)ts->size(), 9);
 
335
 
 
336
    qint64 index = 0;
 
337
    for (qint64 line = 0; line <= 2; ++line) {
 
338
        if (line == 1) {
 
339
            // the html stuff in the middle
 
340
            QVERIFY(ts->token(index).kind == Parser::Token_INLINE_HTML);
 
341
            compareStartPosition(ts, index, 0, 11);
 
342
            compareEndPosition(ts, index, 1, 6);
 
343
            ++index;
 
344
        } else {
 
345
            // the php stuff (symmetric) at the start and end
 
346
            QVERIFY(ts->token(index).kind == Parser::Token_OPEN_TAG);
 
347
            compareStartPosition(ts, index, line, 0);
 
348
            compareEndPosition(ts, index, line, 5);
 
349
            ++index;
 
350
 
 
351
            QVERIFY(ts->token(index).kind == Parser::Token_VARIABLE);
 
352
            compareStartPosition(ts, index, line, 6);
 
353
            compareEndPosition(ts, index, line, 7);
 
354
            ++index;
 
355
 
 
356
            QVERIFY(ts->token(index).kind == Parser::Token_SEMICOLON);
 
357
            compareStartPosition(ts, index, line, 8);
 
358
            compareEndPosition(ts, index, line, 8);
 
359
            ++index;
 
360
 
 
361
            QVERIFY(ts->token(index).kind == Parser::Token_CLOSE_TAG);
 
362
            compareStartPosition(ts, index, line, 9);
 
363
            compareEndPosition(ts, index, line, 10);
 
364
            ++index;
 
365
        }
 
366
    }
 
367
    delete ts;
 
368
}
 
369
 
 
370
void LexerTest::testHereDoc()
 
371
{
 
372
    TokenStream* ts = tokenize("<?php\necho <<<EOD1\nstart $text\nend\nEOD1;\n$extern;", true);
 
373
    QCOMPARE((int)ts->size(), 12);
 
374
 
 
375
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
376
    compareStartPosition(ts, 0, 0, 0);
 
377
    compareEndPosition(ts, 0, 0, 5);
 
378
 
 
379
    QVERIFY(ts->token(1).kind == Parser::Token_ECHO);
 
380
    compareStartPosition(ts, 1, 1, 0);
 
381
    compareEndPosition(ts, 1, 1, 3);
 
382
 
 
383
    QVERIFY(ts->token(3).kind == Parser::Token_START_HEREDOC);
 
384
    compareStartPosition(ts, 3, 1, 5);
 
385
    compareEndPosition(ts, 3, 1, 12);
 
386
 
 
387
    QVERIFY(ts->token(4).kind == Parser::Token_ENCAPSED_AND_WHITESPACE);
 
388
    compareStartPosition(ts, 4, 2, 0);
 
389
    compareEndPosition(ts, 4, 2, 5);
 
390
 
 
391
    QVERIFY(ts->token(5).kind == Parser::Token_VARIABLE);
 
392
    compareStartPosition(ts, 5, 2, 6);
 
393
    compareEndPosition(ts, 5, 2, 10);
 
394
 
 
395
    QVERIFY(ts->token(6).kind == Parser::Token_ENCAPSED_AND_WHITESPACE);
 
396
    compareStartPosition(ts, 6, 2, 11);
 
397
    compareEndPosition(ts, 6, 3, 3);
 
398
 
 
399
    QVERIFY(ts->token(7).kind == Parser::Token_END_HEREDOC);
 
400
    compareStartPosition(ts, 7, 4, 0);
 
401
    compareEndPosition(ts, 7, 4, 3);
 
402
 
 
403
    QVERIFY(ts->token(8).kind == Parser::Token_SEMICOLON);
 
404
    compareStartPosition(ts, 8, 4, 4);
 
405
    compareEndPosition(ts, 8, 4, 4);
 
406
 
 
407
    QVERIFY(ts->token(10).kind == Parser::Token_VARIABLE);
 
408
    compareStartPosition(ts, 10, 5, 0);
 
409
    compareEndPosition(ts, 10, 5, 6);
 
410
 
 
411
    QVERIFY(ts->token(11).kind == Parser::Token_SEMICOLON);
 
412
    compareStartPosition(ts, 11, 5, 7);
 
413
    compareEndPosition(ts, 11, 5, 7);
 
414
    delete ts;
 
415
}
 
416
 
 
417
void LexerTest::testCommonStringTokens()
 
418
{
 
419
    // all these should have open_tag followed by constant encapsed string
 
420
    foreach ( const QString& code, QStringList() << "<?php ''" << "<?php \"\"" << "<?php '" << "<?php \"" ) {
 
421
        kDebug() << code;
 
422
        TokenStream* ts = tokenize(code, true);
 
423
 
 
424
        QCOMPARE((int)ts->size(), 2);
 
425
 
 
426
        QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
427
        compareStartPosition(ts, 0, 0, 0);
 
428
        compareEndPosition(ts, 0, 0, 5);
 
429
 
 
430
        QVERIFY(ts->token(1).kind == Parser::Token_CONSTANT_ENCAPSED_STRING);
 
431
        compareStartPosition(ts, 1, 0, 6);
 
432
        compareEndPosition(ts, 1, 0, code.size() - 1);
 
433
 
 
434
        delete ts;
 
435
    }
 
436
}
 
437
 
 
438
void LexerTest::testNonTerminatedStringWithVar()
 
439
{
 
440
    TokenStream* ts = tokenize("<?php \"$a", true);
 
441
 
 
442
    QCOMPARE((int)ts->size(), 3);
 
443
 
 
444
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
445
    compareStartPosition(ts, 0, 0, 0);
 
446
    compareEndPosition(ts, 0, 0, 5);
 
447
 
 
448
    QVERIFY(ts->token(1).kind == Parser::Token_DOUBLE_QUOTE);
 
449
    compareStartPosition(ts, 1, 0, 6);
 
450
    compareEndPosition(ts, 1, 0, 6);
 
451
 
 
452
    QVERIFY(ts->token(2).kind == Parser::Token_VARIABLE);
 
453
    compareStartPosition(ts, 2, 0, 7);
 
454
    compareEndPosition(ts, 2, 0, 8);
 
455
 
 
456
    delete ts;
 
457
}
 
458
 
 
459
void LexerTest::testPhpBlockWithComment()
 
460
{
 
461
    TokenStream* ts = tokenize(
 
462
        "<?php\n"
 
463
        "//asdf\n"
 
464
        "?>\n"
 
465
        "<?php\n"
 
466
    , true);
 
467
 
 
468
    QCOMPARE((int)ts->size(), 5);
 
469
 
 
470
    QVERIFY(ts->token(0).kind == Parser::Token_OPEN_TAG);
 
471
    compareStartPosition(ts, 0, 0, 0);
 
472
    compareEndPosition(ts, 0, 0, 5);
 
473
 
 
474
    QVERIFY(ts->token(1).kind == Parser::Token_COMMENT);
 
475
    compareStartPosition(ts, 1, 1, 0);
 
476
    compareEndPosition(ts, 1, 1, 6);
 
477
 
 
478
    QVERIFY(ts->token(2).kind == Parser::Token_CLOSE_TAG);
 
479
    compareStartPosition(ts, 2, 2, 0);
 
480
    compareEndPosition(ts, 2, 2, 1);
 
481
 
 
482
    QVERIFY(ts->token(3).kind == Parser::Token_INLINE_HTML);
 
483
    compareStartPosition(ts, 3, 2, 2);
 
484
    compareEndPosition(ts, 3, 2, 2);
 
485
 
 
486
    QVERIFY(ts->token(4).kind == Parser::Token_OPEN_TAG);
 
487
    compareStartPosition(ts, 4, 3, 0);
 
488
    compareEndPosition(ts, 4, 3, 5);
 
489
}
 
490
 
 
491
TokenStream* LexerTest::tokenize(const QString& unit, bool debug, int initialState)
 
492
{
 
493
    TokenStream* tokenStream = new TokenStream;
 
494
    Lexer lexer(tokenStream, unit, initialState);
 
495
    int token;
 
496
    int i = 0;
 
497
    QList<Parser::Token> tokens;
 
498
    while ((token = lexer.nextTokenKind())) {
 
499
        Parser::Token &t = tokenStream->next();
 
500
        t.begin = lexer.tokenBegin();
 
501
        t.end = lexer.tokenEnd();
 
502
        t.kind = token;
 
503
        tokens << t;
 
504
    }
 
505
    if (debug) {
 
506
        foreach(const Parser::Token &t, tokens) {
 
507
            qint64 beginLine;
 
508
            qint64 beginColumn;
 
509
            tokenStream->startPosition(i, &beginLine, &beginColumn);
 
510
            qint64 endLine;
 
511
            qint64 endColumn;
 
512
            tokenStream->endPosition(i, &endLine, &endColumn);
 
513
            kDebug() << tokenText(t.kind)
 
514
            << unit.mid(t.begin, t.end - t.begin + 1).replace('\n', "\\n")
 
515
            << QString("[%0-%1] - [%2-%3]").arg(beginLine).arg(beginColumn).arg(endLine).arg(endColumn);
 
516
            ++i;
 
517
        }
 
518
    }
 
519
    return tokenStream;
 
520
}
 
521
}
 
522
 
 
523
#include "lexertest.moc"