tests/auto/generichighlighter/specificrules/tst_specificrules.cpp

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (qt-info@nokia.com)
   8 **
   9 ** No Commercial Usage
  10 **
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 **
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Nokia gives you certain additional
  26 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** If you have questions regarding the use of this file, please contact
  30 ** Nokia at qt-info@nokia.com.
  31 **
  32 **************************************************************************/
  33
  34 #include <texteditor/generichighlighter/highlightdefinition.h>
  35 #include <texteditor/generichighlighter/keywordlist.h>
  36 #include <texteditor/generichighlighter/specificrules.h>
  37 #include <texteditor/generichighlighter/progressdata.h>
  38
  39 #include <QtTest/QtTest>
  40
  41 //TESTED_COMPONENT=src/plugins/texteditor/generichighlighter
  42 using namespace TextEditor;
  43 using namespace Internal;
  44
  45 class tst_SpecificRules : public QObject
  46 {
  47     Q_OBJECT
  48 public:
  49     tst_SpecificRules() : m_definition(new HighlightDefinition) {}
  50
  51 private slots:
  52     void initTestCase();
  53
  54     void testDetectChar();
  55     void testDetectChar_data();
  56
  57     void testDetect2Char();
  58     void testDetect2Char_data();
  59
  60     void testAnyChar();
  61     void testAnyChar_data();
  62
  63     void testStringDetect();
  64     void testStringDetect_data();
  65
  66     void testRegExpr();
  67     void testRegExpr_data();
  68     void testRegExprOffsetIncremented();
  69     void testRegExprOffsetIncremented_data();
  70
  71     void testKeywordGlobalSensitiveLocalSensitive();
  72     void testKeywordGlobalSensitiveLocalSensitive_data();
  73     void testKeywordGlobalSensitiveLocalInsensitive();
  74     void testKeywordGlobalSensitiveLocalInsensitive_data();
  75     void testKeywordGlobalInsensitiveLocalInsensitive();
  76     void testKeywordGlobalInsensitiveLocalInsensitive_data();
  77     void testKeywordGlobalInsensitiveLocalSensitive();
  78     void testKeywordGlobalInsensitiveLocalSensitive_data();
  79
  80     void testInt();
  81     void testInt_data();
  82
  83     void testFloat();
  84     void testFloat_data();
  85
  86     void testCOctal();
  87     void testCOctal_data();
  88
  89     void testCHex();
  90     void testCHex_data();
  91
  92     void testCString();
  93     void testCString_data();
  94
  95     void testCChar();
  96     void testCChar_data();
  97
  98     void testRangeDetect();
  99     void testRangeDetect_data();
 100
 101     void testLineContinue();
 102     void testLineContinue_data();
 103
 104     void testDetectSpaces();
 105     void testDetectSpaces_data();
 106
 107     void testDetectIdentifier();
 108     void testDetectIdentifier_data();
 109
 110 private:
 111     void addCommonColumns() const;
 112     void testMatch(Rule *rule);
 113     void testMatch(Rule *rule, ProgressData *progress);
 114
 115     void noMatchForInt() const;
 116     void noMatchForFloat() const;
 117     void noMatchForCOctal() const;
 118     void noMatchForCHex() const;
 119     void noMatchForNumber() const;
 120
 121     void commonCasesForKeywords() const;
 122
 123     QSharedPointer<HighlightDefinition> m_definition;
 124 };
 125
 126 void tst_SpecificRules::initTestCase()
 127 {
 128     QSharedPointer<KeywordList> list = m_definition->createKeywordList("keywords");
 129     list->addKeyword("for");
 130     list->addKeyword("while");
 131     list->addKeyword("BEGIN");
 132     list->addKeyword("END");
 133     list->addKeyword("WeIrD");
 134 }
 135
 136 void tst_SpecificRules::addCommonColumns() const
 137 {
 138     QTest::addColumn<QString>("s");
 139     QTest::addColumn<bool>("match");
 140     QTest::addColumn<int>("offset");
 141     QTest::addColumn<bool>("only spaces");
 142     QTest::addColumn<bool>("will continue");
 143 }
 144
 145 void tst_SpecificRules::testMatch(Rule *rule)
 146 {
 147     ProgressData progress;
 148     testMatch(rule, &progress);
 149 }
 150
 151 void tst_SpecificRules::testMatch(Rule *rule, ProgressData *progress)
 152 {
 153     QFETCH(QString, s);
 154
 155     QTEST(rule->matchSucceed(s, s.length(), progress), "match");
 156     QTEST(progress->offset(), "offset");
 157     QTEST(progress->isOnlySpacesSoFar(), "only spaces");
 158     QTEST(progress->isWillContinueLine(), "will continue");
 159 }
 160
 161 void tst_SpecificRules::testDetectChar()
 162 {
 163     QFETCH(QString, c);
 164     DetectCharRule rule;
 165     rule.setChar(c);
 166
 167     testMatch(&rule);
 168 }
 169
 170 void tst_SpecificRules::testDetectChar_data()
 171 {
 172     QTest::addColumn<QString>("c");
 173     addCommonColumns();
 174
 175     QTest::newRow("[#] against [#]") << "#" << "#" << true << 1 << false << false;
 176     QTest::newRow("[#] against [##]") << "#" << "##" << true << 1 << false << false;
 177     QTest::newRow("[#] against [ ]") << "#" << " " << false << 0 << true << false;
 178     QTest::newRow("[#] against [a]") << "#" << "a" << false << 0 << true << false;
 179     QTest::newRow("[#] against [abc]") << "#" << "abc" << false << 0 << true << false;
 180     QTest::newRow("[#] against [x#]") << "#" << "x#" << false << 0 << true << false;
 181     QTest::newRow("[ ] against [a]") << " " << "a" << false << 0 << true << false;
 182     //QTest::newRow("[ ] against [ ]") << " " << " " << true << 1 << true << false;
 183 }
 184
 185 void tst_SpecificRules::testDetect2Char()
 186 {
 187     QFETCH(QString, c);
 188     QFETCH(QString, c1);
 189     Detect2CharsRule rule;
 190     rule.setChar(c);
 191     rule.setChar1(c1);
 192
 193     testMatch(&rule);
 194 }
 195
 196 void tst_SpecificRules::testDetect2Char_data()
 197 {
 198     QTest::addColumn<QString>("c");
 199     QTest::addColumn<QString>("c1");
 200     addCommonColumns();
 201
 202     QTest::newRow("[//] against [//]") << "/" << "/" << "//" << true << 2 << false << false;
 203     QTest::newRow("[//] against [///]") << "/" << "/" << "///" << true << 2 << false << false;
 204     QTest::newRow("[//] against [// ]") << "/" << "/" << "// " << true << 2 << false << false;
 205     QTest::newRow("[//] against [ //]") << "/" << "/" << " //" << false << 0 << true << false;
 206     QTest::newRow("[//] against [a]") << "/" << "/" << "a" << false << 0 << true << false;
 207     QTest::newRow("[//] against [ a]") << "/" << "/" << " a" << false << 0 << true << false;
 208     QTest::newRow("[//] against [abc]") << "/" << "/" << "abc" << false << 0 << true << false;
 209     QTest::newRow("[//] against [/a]") << "/" << "/" << "/a" << false << 0 << true << false;
 210     QTest::newRow("[//] against [a/]") << "/" << "/" << "a/" << false << 0 << true << false;
 211     QTest::newRow("[  ] against [xx]") << " " << " " << "xx" << false << 0 << true << false;
 212     //QTest::newRow("[  ] against [  ]") << " " << " " << " " << true << 3 << true << false;
 213 }
 214
 215 void tst_SpecificRules::testAnyChar()
 216 {
 217     QFETCH(QString, chars);
 218     AnyCharRule rule;
 219     rule.setCharacterSet(chars);
 220
 221     testMatch(&rule);
 222 }
 223
 224 void tst_SpecificRules::testAnyChar_data()
 225 {
 226     QTest::addColumn<QString>("chars");
 227     addCommonColumns();
 228
 229     QTest::newRow("[:!<>?] against [:]") << ":!<>?" << ":" << true << 1 << false << false;
 230     QTest::newRow("[:!<>?] against [!]") << ":!<>?" << "!" << true << 1 << false << false;
 231     QTest::newRow("[:!<>?] against [<]") << ":!<>?" << "<" << true << 1 << false << false;
 232     QTest::newRow("[:!<>?] against [>]") << ":!<>?" << ">" << true << 1 << false << false;
 233     QTest::newRow("[:!<>?] against [?]") << ":!<>?" << "?" << true << 1 << false << false;
 234     QTest::newRow("[:!<>?] against [:]") << ":!<>?" << ":" << true << 1 << false << false;
 235     QTest::newRow("[:!<>?] against [ ]") << ":!<>?" << " " << false << 0 << true << false;
 236     QTest::newRow("[:!<>?] against [#]") << ":!<>?" << "#" << false << 0 << true << false;
 237     QTest::newRow("[:!<>?] against [!#]") << ":!<>?" << "!#" << true << 1 << false << false;
 238     QTest::newRow("[:!<>?] against [#!]") << ":!<>?" << "#!" << false << 0 << true << false;
 239     QTest::newRow("[:] against [:]") << ":" << ":" << true << 1 << false << false;
 240     QTest::newRow("[:] against [#]") << ":" << "#" << false << 0 << true << false;
 241     //QTest::newRow("[   ] against [ ]") << "   " << " " << true << 1 << true << false;
 242 }
 243
 244 void tst_SpecificRules::testStringDetect()
 245 {
 246     QFETCH(QString, referenceString);
 247     QFETCH(QString, insensitive);
 248     StringDetectRule rule;
 249     rule.setString(referenceString);
 250     rule.setInsensitive(insensitive);
 251
 252     testMatch(&rule);
 253 }
 254
 255 void tst_SpecificRules::testStringDetect_data()
 256 {
 257     QTest::addColumn<QString>("referenceString");
 258     QTest::addColumn<QString>("insensitive");
 259     addCommonColumns();
 260
 261     QTest::newRow("[LL] against [LL]") << "LL" << "0" << "LL" << true << 2 << false << false;
 262     QTest::newRow("[LL] against [ll]") << "LL" << "0" << "ll" << false << 0 << true << false;
 263     QTest::newRow("[LL] against [ll] i") << "LL" << "1" << "ll" << true << 2 << false << false;
 264     QTest::newRow("[ll] against [ll] i") << "LL" << "1" << "LL" << true << 2 << false << false;
 265     QTest::newRow("[LL] against [5LL]") << "LL" << "0" << "5LL" << false << 0 << true << false;
 266     QTest::newRow("[LL] against [L]") << "LL" << "0" << "L" << false << 0 << true << false;
 267     QTest::newRow("[LL] against [LLL]") << "LL" << "0" << "LLL" << true << 2 << false << false;
 268     QTest::newRow("[LL] against [ ]") << "LL" << "0" << " " << false << 0 << true << false;
 269     QTest::newRow("[LL] against [xLLx]") << "LL" << "0" << "xLLx" << false << 0 << true << false;
 270     QTest::newRow("[\"\"\"] against [\"\"\"]") << "\"\"\"" << "0" << "\"\"\"" << true << 3
 271             << false << false;
 272 }
 273
 274 void tst_SpecificRules::testRegExpr()
 275 {
 276     QFETCH(QString, pattern);
 277     QFETCH(QString, insensitive);
 278     QFETCH(QString, minimal);
 279     RegExprRule rule;
 280     rule.setPattern(pattern);
 281     rule.setInsensitive(insensitive);
 282     rule.setMinimal(minimal);
 283
 284     testMatch(&rule);
 285 }
 286
 287 void tst_SpecificRules::testRegExpr_data()
 288 {
 289     QTest::addColumn<QString>("pattern");
 290     QTest::addColumn<QString>("insensitive");
 291     QTest::addColumn<QString>("minimal");
 292     addCommonColumns();
 293
 294     QTest::newRow("[#[a-z]+\\s+\\d] against [#as 9]") << "#[a-z]+\\s+\\d" << "0" << "0"
 295             << "#as 9" << true << 5 << false << false;
 296     QTest::newRow("[#[a-z]+\\s+\\d] against [#As 9]") << "#[a-z]+\\s+\\d" << "0" << "0"
 297             << "#As 9" << false << 0 << true << false;
 298     QTest::newRow("[#[a-z]+\\s+\\d] against [#As 9] i") << "#[a-z]+\\s+\\d" << "1" << "0"
 299             << "#As 9" << true << 5 << false << false;
 300     QTest::newRow("[#[a-z]+\\s+\\d] against [as 9]") << "#[a-z]+\\s+\\d" << "0" << "0"
 301             << "as 9" << false << 0 << true << false;
 302     QTest::newRow("[#[a-z]+\\s+\\d] against [w#as 9]") << "#[a-z]+\\s+\\d" << "0" << "0"
 303             << "w#as 9" << false << 0 << true << false;
 304     QTest::newRow("[^\\s+[a-z]] against [x]") << "^\\s+[a-z]" << "0" << "0"
 305             << "x" << false << 0 << true << false;
 306     QTest::newRow("[^\\s+[a-z]] against [  x]") << "^\\s+[a-z]" << "0" << "0"
 307             << "  x" << true << 3 << false << false;
 308     QTest::newRow("[0+] against [1001]") << "0+" << "0" << "0"
 309             << "1001" << false << 0 << true << false;
 310     QTest::newRow("[0+] against [001]") << "0+" << "0" << "0"
 311             << "001" << true << 2 << false << false;
 312     QTest::newRow("[0+] against [001]") << "0+" << "0" << "1"
 313             << "001" << true << 1 << false << false;
 314     QTest::newRow("[\\s*] against []") << "\\s*" << "0" << "0"
 315             << "" << false << 0 << true << false;
 316     //QTest::newRow("[\\s*] against []") << "\\s*" << "0" << "0"
 317     //      << " " << true << 1 << true << false;
 318 }
 319
 320 void tst_SpecificRules::testRegExprOffsetIncremented()
 321 {
 322     QFETCH(QString, pattern);
 323     RegExprRule rule;
 324     rule.setPattern(pattern);
 325
 326     ProgressData progress;
 327     progress.setOffset(1);
 328
 329     testMatch(&rule, &progress);
 330 }
 331
 332 void tst_SpecificRules::testRegExprOffsetIncremented_data()
 333 {
 334     QTest::addColumn<QString>("pattern");
 335     addCommonColumns();
 336
 337     // To make sure that QRegExp::CaretAtZero is set.
 338     QTest::newRow("[^\\s+[a-z]] against [  x]") << "^\\s+[a-z]" << "  x" << false << 1
 339             << true << false;
 340 }
 341
 342 void tst_SpecificRules::commonCasesForKeywords() const
 343 {
 344     QTest::newRow("[for]") << "for" << true << 3 << false << false;
 345     QTest::newRow("[while]") << "while" << true << 5 << false << false;
 346     QTest::newRow("[BEGIN]") << "BEGIN" << true << 5 << false << false;
 347     QTest::newRow("[END]") << "END" << true << 3 << false << false;
 348     QTest::newRow("[WeIrD]") << "WeIrD" << true << 5 << false << false;
 349     QTest::newRow("[forr]") << "forr" << false << 0 << true << false;
 350     QTest::newRow("[for#]") << "for#" << false << 0 << true << false;
 351     QTest::newRow("[abc]") << "abc" << false << 0 << true << false;
 352     QTest::newRow("[ ]") << " " << false << 0 << true << false;
 353     QTest::newRow("[foe]") << "foe" << false << 0 << true << false;
 354     QTest::newRow("[sor]") << "sor" << false << 0 << true << false;
 355     QTest::newRow("[ffor]") << "ffor" << false << 0 << true << false;
 356
 357     // Valid default delimiters.
 358     QTest::newRow("[for ]") << "for " << true << 3 << false << false;
 359     QTest::newRow("[for.for]") << "for.for" << true << 3 << false << false;
 360     QTest::newRow("[for(]") << "for(" << true << 3 << false << false;
 361     QTest::newRow("[for)]") << "for)" << true << 3 << false << false;
 362     QTest::newRow("[for:]") << "for:" << true << 3 << false << false;
 363     QTest::newRow("[for!]") << "for!" << true << 3 << false << false;
 364     QTest::newRow("[for+]") << "for+" << true << 3 << false << false;
 365     QTest::newRow("[for,]") << "for," << true << 3 << false << false;
 366     QTest::newRow("[for-]") << "for-" << true << 3 << false << false;
 367     QTest::newRow("[for<]") << "for>" << true << 3 << false << false;
 368     QTest::newRow("[for=]") << "for=" << true << 3 << false << false;
 369     QTest::newRow("[for>]") << "for>" << true << 3 << false << false;
 370     QTest::newRow("[for%]") << "for%" << true << 3 << false << false;
 371     QTest::newRow("[for&]") << "for&" << true << 3 << false << false;
 372     QTest::newRow("[for/]") << "for/" << true << 3 << false << false;
 373     QTest::newRow("[for;]") << "for;" << true << 3 << false << false;
 374     QTest::newRow("[for?]") << "for?" << true << 3 << false << false;
 375     QTest::newRow("[for[]") << "for[" << true << 3 << false << false;
 376     QTest::newRow("[for]]") << "for]" << true << 3 << false << false;
 377     QTest::newRow("[for^]") << "for^" << true << 3 << false << false;
 378     QTest::newRow("[for{]") << "for{" << true << 3 << false << false;
 379     QTest::newRow("[for|]") << "for|" << true << 3 << false << false;
 380     QTest::newRow("[for}]") << "for}" << true << 3 << false << false;
 381     QTest::newRow("[for~]") << "for~" << true << 3 << false << false;
 382     QTest::newRow("[for\\]") << "for\\" << true << 3 << false << false;
 383     QTest::newRow("[for*]") << "for*" << true << 3 << false << false;
 384     QTest::newRow("[for,for]") << "for,for" << true << 3 << false << false;
 385     QTest::newRow("[for\t]") << "for\t" << true << 3 << false << false;
 386 }
 387
 388 void tst_SpecificRules::testKeywordGlobalSensitiveLocalSensitive()
 389 {
 390     m_definition->setKeywordsSensitive("true");
 391     KeywordRule rule(m_definition);
 392     rule.setInsensitive("false");
 393     rule.setList("keywords");
 394
 395     testMatch(&rule);
 396 }
 397
 398 void tst_SpecificRules::testKeywordGlobalSensitiveLocalSensitive_data()
 399 {
 400     addCommonColumns();
 401
 402     commonCasesForKeywords();
 403     QTest::newRow("[fOr]") << "fOr" << false << 0 << true << false;
 404     QTest::newRow("[whilE") << "whilE" << false << 0 << true << false;
 405     QTest::newRow("[bEGIN]") << "bEGIN" << false << 0 << true << false;
 406     QTest::newRow("[end]") << "end" << false << 0 << true << false;
 407     QTest::newRow("[weird]") << "weird" << false << 0 << true << false;
 408 }
 409
 410 void tst_SpecificRules::testKeywordGlobalSensitiveLocalInsensitive()
 411 {
 412     m_definition->setKeywordsSensitive("true");
 413     KeywordRule rule(m_definition);
 414     rule.setInsensitive("true");
 415     rule.setList("keywords");
 416
 417     testMatch(&rule);
 418 }
 419
 420 void tst_SpecificRules::testKeywordGlobalSensitiveLocalInsensitive_data()
 421 {
 422     addCommonColumns();
 423
 424     commonCasesForKeywords();
 425     QTest::newRow("[fOr]") << "fOr" << true << 3 << false << false;
 426     QTest::newRow("[whilE") << "whilE" << true << 5 << false << false;
 427     QTest::newRow("[bEGIN]") << "bEGIN" << true << 5 << false << false;
 428     QTest::newRow("[end]") << "end" << true << 3 << false << false;
 429     QTest::newRow("[weird]") << "weird" << true << 5 << false << false;
 430 }
 431
 432 void tst_SpecificRules::testKeywordGlobalInsensitiveLocalInsensitive()
 433 {
 434     m_definition->setKeywordsSensitive("false");
 435     KeywordRule rule(m_definition);
 436     rule.setInsensitive("true");
 437     rule.setList("keywords");
 438
 439     testMatch(&rule);
 440 }
 441
 442 void tst_SpecificRules::testKeywordGlobalInsensitiveLocalInsensitive_data()
 443 {
 444     testKeywordGlobalSensitiveLocalInsensitive_data();
 445 }
 446
 447 void tst_SpecificRules::testKeywordGlobalInsensitiveLocalSensitive()
 448 {
 449     m_definition->setKeywordsSensitive("false");
 450     KeywordRule rule(m_definition);
 451     rule.setInsensitive("false");
 452     rule.setList("keywords");
 453
 454     testMatch(&rule);
 455 }
 456
 457 void tst_SpecificRules::testKeywordGlobalInsensitiveLocalSensitive_data()
 458 {
 459     testKeywordGlobalSensitiveLocalSensitive_data();
 460 }
 461
 462 void tst_SpecificRules::noMatchForInt() const
 463 {
 464     QTest::newRow("[1]") << "1" << false << 0 << true << false;
 465     QTest::newRow("[1299]") << "1299" << false << 0 << true << false;
 466     QTest::newRow("[10]") << "10" << false << 0 << true << false;
 467     QTest::newRow("[9]") << "9" << false << 0 << true << false;
 468 }
 469
 470 void tst_SpecificRules::noMatchForFloat() const
 471 {
 472     QTest::newRow("[4e-11]") << "4e-11" << false << 0 << true << false;
 473     QTest::newRow("[1e+5]") << "1e+5" << false << 0 << true << false;
 474     QTest::newRow("[7.321E-3]") << "7.321E-3" << false << 0 << true << false;
 475     QTest::newRow("[3.2E+4]") << "3.2E+4" << false << 0 << true << false;
 476     QTest::newRow("[0.5e-6]") << "0.5e-6" << false << 0 << true << false;
 477     QTest::newRow("[0.45]") << "0.45" << false << 0 << true << false;
 478     QTest::newRow("[6.e10]") << "6.e10" << false << 0 << true << false;
 479     QTest::newRow("[.2e23]") << ".2e23" << false << 0 << true << false;
 480     QTest::newRow("[23.]") << "23." << false << 0 << true << false;
 481     QTest::newRow("[2.e23]") << "2.e23" << false << 0 << true << false;
 482     QTest::newRow("[23e2]") << "23e2" << false << 0 << true << false;
 483     QTest::newRow("[4.3e]") << "4.3e" << false << 0 << true << false;
 484     QTest::newRow("[4.3ef]") << "4.3ef" << false << 0 << true << false;
 485 }
 486
 487 void tst_SpecificRules::noMatchForCOctal() const
 488 {
 489     QTest::newRow("[0]") << "0" << false << 0 << true << false;
 490     QTest::newRow("[07]") << "07" << false << 0 << true << false;
 491     QTest::newRow("[01234567]") << "01234567" << false << 0 << true << false;
 492 }
 493
 494 void tst_SpecificRules::noMatchForCHex() const
 495 {
 496     QTest::newRow("[0X934AF]") << "0X934AF" << false << 0 << true << false;
 497     QTest::newRow("[0x934af]") << "0x934af" << false << 0 << true << false;
 498 }
 499
 500 void tst_SpecificRules::noMatchForNumber() const
 501 {
 502     QTest::newRow("[a]") << "a" << false << 0 << true << false;
 503     QTest::newRow("[#]") << "#" << false << 0 << true << false;
 504     QTest::newRow("[ ]") << " " << false << 0 << true << false;
 505     QTest::newRow("[a1]") << "a1" << false << 0 << true << false;
 506     QTest::newRow("[.e23]") << ".e23" << false << 0 << true << false;
 507     QTest::newRow("[.e23]") << ".e23" << false << 0 << true << false;
 508
 509     // + and - are not directly matched by number rules.
 510     QTest::newRow("[+1]") << "+1" << false << 0 << true << false;
 511     QTest::newRow("[-1]") << "-1" << false << 0 << true << false;
 512 }
 513
 514 void tst_SpecificRules::testInt()
 515 {
 516     IntRule rule;
 517     testMatch(&rule);
 518 }
 519
 520 void tst_SpecificRules::testInt_data()
 521 {
 522     addCommonColumns();
 523
 524     noMatchForCOctal();
 525     noMatchForCHex();
 526     noMatchForNumber();
 527
 528     QTest::newRow("[1]") << "1" << true << 1 << false << false;
 529     QTest::newRow("[1299]") << "1299" << true << 4 << false << false;
 530     QTest::newRow("[10]") << "10" << true << 2 << false << false;
 531     QTest::newRow("[9]") << "9" << true << 1 << false << false;
 532
 533     // LL, U, and others are matched through child rules.
 534     QTest::newRow("[234U]") << "234U" << true << 3 << false << false;
 535     QTest::newRow("[234LL]") << "234LL" << true << 3 << false << false;
 536 }
 537
 538 void tst_SpecificRules::testFloat()
 539 {
 540     FloatRule rule;
 541     testMatch(&rule);
 542 }
 543
 544 void tst_SpecificRules::testFloat_data()
 545 {
 546     addCommonColumns();
 547
 548     noMatchForInt();
 549     noMatchForCOctal();
 550     noMatchForCHex();
 551     noMatchForNumber();
 552
 553     QTest::newRow("[4e-11]") << "4e-11" << true << 5 << false << false;
 554     QTest::newRow("[1e+5]") << "1e+5" << true << 4 << false << false;
 555     QTest::newRow("[7.321E-3]") << "7.321E-3" << true << 8 << false << false;
 556     QTest::newRow("[3.2E+4]") << "3.2E+4" << true << 6 << false << false;
 557     QTest::newRow("[0.5e-6]") << "0.5e-6" << true << 6 << false << false;
 558     QTest::newRow("[0.45]") << "0.45" << true << 4 << false << false;
 559     QTest::newRow("[6.e10]") << "6.e10" << true << 5 << false << false;
 560     QTest::newRow("[.2e23]") << ".2e23" << true << 5 << false << false;
 561     QTest::newRow("[23.]") << "23." << true << 3 << false << false;
 562     QTest::newRow("[2.e23]") << "2.e23" << true << 5 << false << false;
 563     QTest::newRow("[23e2]") << "23e2" << true << 4 << false << false;
 564
 565     // F, L, and others are matched through child rules.
 566     QTest::newRow("[6.e10f]") << "6.e10f" << true << 5 << false << false;
 567     QTest::newRow("[0.5e-6F]") << "0.5e-6F" << true << 6 << false << false;
 568     QTest::newRow("[23.f]") << "23.f" << true << 3 << false << false;
 569     QTest::newRow("[.2L]") << ".2L" << true << 2 << false << false;
 570 }
 571
 572 void tst_SpecificRules::testCOctal()
 573 {
 574     HlCOctRule rule;
 575     testMatch(&rule);
 576 }
 577
 578 void tst_SpecificRules::testCOctal_data()
 579 {
 580     addCommonColumns();
 581
 582     noMatchForInt();
 583     noMatchForCHex();
 584     noMatchForNumber();
 585
 586     QTest::newRow("[0]") << "0" << true << 1 << false << false;
 587     QTest::newRow("[07]") << "07" << true << 2 << false << false;
 588     QTest::newRow("[01234567]") << "01234567" << true << 8 << false << false;
 589     QTest::newRow("[012345678]") << "012345678" << true << 8 << false << false;
 590     QTest::newRow("[0888]") << "0888" << true << 1 << false << false;
 591 }
 592
 593 void tst_SpecificRules::testCHex()
 594 {
 595     HlCHexRule rule;
 596     testMatch(&rule);
 597 }
 598
 599 void tst_SpecificRules::testCHex_data()
 600 {
 601     addCommonColumns();
 602
 603     noMatchForInt();
 604     noMatchForFloat();
 605     noMatchForCOctal();
 606     noMatchForNumber();
 607
 608     QTest::newRow("[0X934AF]") << "0X934AF" << true << 7 << false << false;
 609     QTest::newRow("[0x934af]") << "0x934af" << true << 7 << false << false;
 610     QTest::newRow("[0x2ik]") << "0x2ik" << true << 3 << false << false;
 611 }
 612
 613 void tst_SpecificRules::testCString()
 614 {
 615     HlCStringCharRule rule;
 616     testMatch(&rule);
 617 }
 618
 619 void tst_SpecificRules::testCString_data()
 620 {
 621     addCommonColumns();
 622
 623     // Escape sequences
 624     QTest::newRow("[\\a]") << "\\a" << true << 2 << false << false;
 625     QTest::newRow("[\\b]") << "\\b" << true << 2 << false << false;
 626     QTest::newRow("[\\e]") << "\\e" << true << 2 << false << false;
 627     QTest::newRow("[\\f]") << "\\f" << true << 2 << false << false;
 628     QTest::newRow("[\\n]") << "\\n" << true << 2 << false << false;
 629     QTest::newRow("[\\r]") << "\\r" << true << 2 << false << false;
 630     QTest::newRow("[\\t]") << "\\t" << true << 2 << false << false;
 631     QTest::newRow("[\\v]") << "\\v" << true << 2 << false << false;
 632     QTest::newRow("[\\?]") << "\\?" << true << 2 << false << false;
 633     QTest::newRow("[\\']") << "\\'" << true << 2 << false << false;
 634     QTest::newRow("[\\\"]") << "\\\"" << true << 2 << false << false;
 635     QTest::newRow("[\\\\]") << "\\\\" << true << 2 << false << false;
 636     QTest::newRow("[\\c]") << "\\c" << false << 0 << true << false;
 637     QTest::newRow("[x]") << "x" << false << 0 << true << false;
 638     QTest::newRow("[ ]") << " " << false << 0 << true << false;
 639     QTest::newRow("[a]") << "x" << false << 0 << true << false;
 640     QTest::newRow("[r]") << "r" << false << 0 << true << false;
 641     QTest::newRow("[//]") << "//" << false << 0 << true << false;
 642
 643     // Octal values
 644     QTest::newRow("[\\1]") << "\\1" << true << 2 << false << false;
 645     QTest::newRow("[\\12]") << "\\12" << true << 3 << false << false;
 646     QTest::newRow("[\\123]") << "\\123" << true << 4 << false << false;
 647     QTest::newRow("[\\1234]") << "\\1234" << true << 4 << false << false;
 648     QTest::newRow("[\\123x]") << "\\123x" << true << 4 << false << false;
 649
 650     // Hex values
 651     QTest::newRow("[\\xa]") << "\\xa" << true << 3 << false << false;
 652     QTest::newRow("[\\xA]") << "\\xA" << true << 3 << false << false;
 653     QTest::newRow("[\\Xa]") << "\\Xa" << false << 0 << true << false;
 654     QTest::newRow("[\\xA10]") << "\\xA10" << true << 5 << false << false;
 655     QTest::newRow("[\\xA0123456789]") << "\\xA0123456789" << true << 13 << false << false;
 656     QTest::newRow("[\\xABCDEF]") << "\\xABCDEF" << true << 8 << false << false;
 657     QTest::newRow("[\\xABCDEFGHI]") << "\\xABCDEFGHI" << true << 8 << false << false;
 658 }
 659
 660 void tst_SpecificRules::testCChar()
 661 {
 662     HlCCharRule rule;
 663     testMatch(&rule);
 664 }
 665
 666 void tst_SpecificRules::testCChar_data()
 667 {
 668     addCommonColumns();
 669
 670     // Escape sequences
 671     QTest::newRow("[\'\\a\']") << "\'\\a\'" << true << 4 << false << false;
 672     QTest::newRow("[\'\\b\']") << "\'\\b\'" << true << 4 << false << false;
 673     QTest::newRow("[\'\\e\']") << "\'\\e\'" << true << 4 << false << false;
 674     QTest::newRow("[\'\\f\']") << "\'\\f\'" << true << 4 << false << false;
 675     QTest::newRow("[\'\\n\']") << "\'\\n\'" << true << 4 << false << false;
 676     QTest::newRow("[\'\\r\']") << "\'\\r\'" << true << 4 << false << false;
 677     QTest::newRow("[\'\\t\']") << "\'\\t\'" << true << 4 << false << false;
 678     QTest::newRow("[\'\\v\']") << "\'\\v\'" << true << 4 << false << false;
 679     QTest::newRow("[\'\\?\']") << "\'\\?\'" << true << 4 << false << false;
 680     QTest::newRow("[\'\\'\']") << "\'\\'\'" << true << 4 << false << false;
 681     QTest::newRow("[\'\\\"\']") << "\'\\\"\'" << true << 4 << false << false;
 682     QTest::newRow("[\'\\\\\']") << "\'\\\\\'" << true << 4 << false << false;
 683     QTest::newRow("[\'\\c\']") << "\'\\c\'" << false << 0 << true << false;
 684     QTest::newRow("[x]") << "x" << false << 0 << true << false;
 685     QTest::newRow("[ ]") << " " << false << 0 << true << false;
 686     QTest::newRow("[a]") << "x" << false << 0 << true << false;
 687     QTest::newRow("[r]") << "r" << false << 0 << true << false;
 688     QTest::newRow("[//]") << "//" << false << 0 << true << false;
 689 }
 690
 691 void tst_SpecificRules::testRangeDetect()
 692 {
 693     QFETCH(QString, c);
 694     QFETCH(QString, c1);
 695     RangeDetectRule rule;
 696     rule.setChar(c);
 697     rule.setChar1(c1);
 698
 699     testMatch(&rule);
 700 }
 701
 702 void tst_SpecificRules::testRangeDetect_data()
 703 {
 704     QTest::addColumn<QString>("c");
 705     QTest::addColumn<QString>("c1");
 706     addCommonColumns();
 707
 708     QTest::newRow("[<>] against [<QString>]") << "<" << ">" << "<QString>"
 709             << true << 9 << false << false;
 710     QTest::newRow("[<>] against <x>") << "<" << ">" << "<x>" << true << 3 << false << false;
 711     QTest::newRow("[<>] against <   >") << "<" << ">" << "<   >" << true << 5 << false << false;
 712     QTest::newRow("[<>] against <x>abc") << "<" << ">" << "<x>abc" << true << 3 << false << false;
 713     QTest::newRow("[<>] against <x> ") << "<" << ">" << "<x> " << true << 3 << false << false;
 714     QTest::newRow("[<>] against abc") << "<" << ">" << "abc" << false << 0 << true << false;
 715     QTest::newRow("[<>] against <abc") << "<" << ">" << "<abc" << false << 0 << true << false;
 716     QTest::newRow("[<>] against abc<") << "<" << ">" << "abc<" << false << 0 << true << false;
 717     QTest::newRow("[<>] against a<bc") << "<" << ">" << "a<bc" << false << 0 << true << false;
 718     QTest::newRow("[<>] against abc<") << "<" << ">" << "abc<" << false << 0 << true << false;
 719     QTest::newRow("[\"\"] against \"test.h\"") << "\"" << "\"" << "\"test.h\""
 720             << true << 8 << false << false;
 721 }
 722
 723 void tst_SpecificRules::testLineContinue()
 724 {
 725     LineContinueRule rule;
 726     testMatch(&rule);
 727 }
 728
 729 void tst_SpecificRules::testLineContinue_data()
 730 {
 731     addCommonColumns();
 732
 733     QTest::newRow("\\") << "\\" << true << 1 << false << true;
 734     QTest::newRow("\\\\") << "\\\\" << false << 0 << true << false;
 735     QTest::newRow("\\x") << "\\x" << false << 0 << true << false;
 736     QTest::newRow("x\\") << "x\\" << false << 0 << true << false;
 737     QTest::newRow("x") << "x" << false << 0 << true << false;
 738     QTest::newRow("/") << "/" << false << 0 << true << false;
 739 }
 740
 741 void tst_SpecificRules::testDetectSpaces()
 742 {
 743     DetectSpacesRule rule;
 744     testMatch(&rule);
 745 }
 746
 747 void tst_SpecificRules::testDetectSpaces_data()
 748 {
 749     addCommonColumns();
 750
 751     QTest::newRow(" ") << " " << true << 1 << true << false;
 752     QTest::newRow("    ") << "    " << true << 4 << true << false;
 753     QTest::newRow("\t") << "\t" << true << 1 << true << false;
 754     QTest::newRow("x") << "x" << false << 0 << true << false;
 755     QTest::newRow("#") << "#" << false << 0 << true << false;
 756 }
 757
 758 void tst_SpecificRules::testDetectIdentifier()
 759 {
 760     DetectIdentifierRule rule;
 761     testMatch(&rule);
 762 }
 763
 764 void tst_SpecificRules::testDetectIdentifier_data()
 765 {
 766     addCommonColumns();
 767
 768     QTest::newRow("name") << "name" << true << 4 << false << false;
 769     QTest::newRow("x") << "x" << true << 1 << false << false;
 770     QTest::newRow("x1") << "x1" << true << 2 << false << false;
 771     QTest::newRow("1x") << "1x" << false << 0 << true << false;
 772     QTest::newRow("_x") << "_x" << true << 2 << false << false;
 773     QTest::newRow("___x") << "___x" << true << 4 << false << false;
 774     QTest::newRow("-x") << "-x" << false << 0 << true << false;
 775     QTest::newRow("@x") << "@x" << false << 0 << true << false;
 776     QTest::newRow("+x") << "+x" << false << 0 << true << false;
 777     QTest::newRow("#x") << "#x" << false << 0 << true << false;
 778     QTest::newRow("x_x") << "x_x" << true << 3 << false << false;
 779     QTest::newRow("x1x") << "x1x" << true << 3 << false << false;
 780     QTest::newRow("x#x") << "x#x" << true << 1 << false << false;
 781     QTest::newRow("x-x") << "x-x" << true << 1 << false << false;
 782     QTest::newRow("abc_") << "abc_" << true << 4 << false << false;
 783     QTest::newRow("abc____") << "abc____" << true << 7 << false << false;
 784     QTest::newRow("abc-") << "abc-" << true << 3 << false << false;
 785     QTest::newRow("abc$") << "abc$" << true << 3 << false << false;
 786 }
 787
 788 QTEST_MAIN(tst_SpecificRules)
 789 #include "tst_specificrules.moc"