Source/JavaScriptCore/testRegExp.cpp

   1 /*
   2  *  Copyright (C) 2011 Apple Inc. All rights reserved.
   3  *
   4  *  This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   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
  21 #include "config.h"
  22 #include "RegExp.h"
  23
  24 #include "APIShims.h"
  25 #include <wtf/CurrentTime.h>
  26 #include "InitializeThreading.h"
  27 #include "JSGlobalObject.h"
  28 #include "Operations.h"
  29 #include <errno.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <wtf/text/StringBuilder.h>
  34
  35 #if !OS(WINDOWS)
  36 #include <unistd.h>
  37 #endif
  38
  39 #if HAVE(SYS_TIME_H)
  40 #include <sys/time.h>
  41 #endif
  42
  43 #if COMPILER(MSVC) && !OS(WINCE)
  44 #include <crtdbg.h>
  45 #include <mmsystem.h>
  46 #include <windows.h>
  47 #endif
  48
  49 #if PLATFORM(QT)
  50 #include <QCoreApplication>
  51 #include <QDateTime>
  52 #endif
  53
  54 const int MaxLineLength = 100 * 1024;
  55
  56 using namespace JSC;
  57 using namespace WTF;
  58
  59 struct CommandLine {
  60     CommandLine()
  61         : interactive(false)
  62         , verbose(false)
  63     {
  64     }
  65
  66     bool interactive;
  67     bool verbose;
  68     Vector<String> arguments;
  69     Vector<String> files;
  70 };
  71
  72 class StopWatch {
  73 public:
  74     void start();
  75     void stop();
  76     long getElapsedMS(); // call stop() first
  77
  78 private:
  79     double m_startTime;
  80     double m_stopTime;
  81 };
  82
  83 void StopWatch::start()
  84 {
  85     m_startTime = monotonicallyIncreasingTime();
  86 }
  87
  88 void StopWatch::stop()
  89 {
  90     m_stopTime = monotonicallyIncreasingTime();
  91 }
  92
  93 long StopWatch::getElapsedMS()
  94 {
  95     return static_cast<long>((m_stopTime - m_startTime) * 1000);
  96 }
  97
  98 struct RegExpTest {
  99     RegExpTest()
 100         : offset(0)
 101         , result(0)
 102     {
 103     }
 104
 105     String subject;
 106     int offset;
 107     int result;
 108     Vector<int, 32> expectVector;
 109 };
 110
 111 class GlobalObject : public JSGlobalObject {
 112 private:
 113     GlobalObject(VM&, Structure*, const Vector<String>& arguments);
 114
 115 public:
 116     typedef JSGlobalObject Base;
 117
 118     static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)
 119     {
 120         GlobalObject* globalObject = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure, arguments);
 121         vm.heap.addFinalizer(globalObject, destroy);
 122         return globalObject;
 123     }
 124
 125     DECLARE_INFO;
 126
 127     static const bool needsDestructor = false;
 128
 129     static Structure* createStructure(VM& vm, JSValue prototype)
 130     {
 131         return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
 132     }
 133
 134 protected:
 135     void finishCreation(VM& vm, const Vector<String>& arguments)
 136     {
 137         Base::finishCreation(vm);
 138         UNUSED_PARAM(arguments);
 139     }
 140 };
 141
 142 const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, 0, ExecState::globalObjectTable, CREATE_METHOD_TABLE(GlobalObject) };
 143
 144 GlobalObject::GlobalObject(VM& vm, Structure* structure, const Vector<String>& arguments)
 145     : JSGlobalObject(vm, structure)
 146 {
 147     finishCreation(vm, arguments);
 148 }
 149
 150 // Use SEH for Release builds only to get rid of the crash report dialog
 151 // (luckily the same tests fail in Release and Debug builds so far). Need to
 152 // be in a separate main function because the realMain function requires object
 153 // unwinding.
 154
 155 #if COMPILER(MSVC) && !COMPILER(INTEL) && !defined(_DEBUG) && !OS(WINCE)
 156 #define TRY       __try {
 157 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
 158 #else
 159 #define TRY
 160 #define EXCEPT(x)
 161 #endif
 162
 163 int realMain(int argc, char** argv);
 164
 165 int main(int argc, char** argv)
 166 {
 167 #if OS(WINDOWS)
 168 #if !OS(WINCE)
 169     // Cygwin calls ::SetErrorMode(SEM_FAILCRITICALERRORS), which we will inherit. This is bad for
 170     // testing/debugging, as it causes the post-mortem debugger not to be invoked. We reset the
 171     // error mode here to work around Cygwin's behavior. See <http://webkit.org/b/55222>.
 172     ::SetErrorMode(0);
 173 #endif
 174
 175 #if defined(_DEBUG)
 176     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
 177     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
 178     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
 179     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
 180     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 181     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
 182 #endif
 183
 184     timeBeginPeriod(1);
 185 #endif
 186
 187 #if PLATFORM(QT)
 188     QCoreApplication app(argc, argv);
 189 #endif
 190
 191     // Initialize JSC before getting VM.
 192     JSC::initializeThreading();
 193
 194     // We can't use destructors in the following code because it uses Windows
 195     // Structured Exception Handling
 196     int res = 0;
 197     TRY
 198         res = realMain(argc, argv);
 199     EXCEPT(res = 3)
 200     return res;
 201 }
 202
 203 static bool testOneRegExp(VM& vm, RegExp* regexp, RegExpTest* regExpTest, bool verbose, unsigned int lineNumber)
 204 {
 205     bool result = true;
 206     Vector<int, 32> outVector;
 207     outVector.resize(regExpTest->expectVector.size());
 208     int matchResult = regexp->match(vm, regExpTest->subject, regExpTest->offset, outVector);
 209
 210     if (matchResult != regExpTest->result) {
 211         result = false;
 212         if (verbose)
 213             printf("Line %d: results mismatch - expected %d got %d\n", lineNumber, regExpTest->result, matchResult);
 214     } else if (matchResult != -1) {
 215         if (outVector.size() != regExpTest->expectVector.size()) {
 216             result = false;
 217             if (verbose)
 218                 printf("Line %d: output vector size mismatch - expected %lu got %lu\n", lineNumber, regExpTest->expectVector.size(), outVector.size());
 219         } else if (outVector.size() % 2) {
 220             result = false;
 221             if (verbose)
 222                 printf("Line %d: output vector size is odd (%lu), should be even\n", lineNumber, outVector.size());
 223         } else {
 224             // Check in pairs since the first value of the pair could be -1 in which case the second doesn't matter.
 225             size_t pairCount = outVector.size() / 2;
 226             for (size_t i = 0; i < pairCount; ++i) {
 227                 size_t startIndex = i*2;
 228                 if (outVector[startIndex] != regExpTest->expectVector[startIndex]) {
 229                     result = false;
 230                     if (verbose)
 231                         printf("Line %d: output vector mismatch at index %lu - expected %d got %d\n", lineNumber, startIndex, regExpTest->expectVector[startIndex], outVector[startIndex]);
 232                 }
 233                 if ((i > 0) && (regExpTest->expectVector[startIndex] != -1) && (outVector[startIndex+1] != regExpTest->expectVector[startIndex+1])) {
 234                     result = false;
 235                     if (verbose)
 236                         printf("Line %d: output vector mismatch at index %lu - expected %d got %d\n", lineNumber, startIndex+1, regExpTest->expectVector[startIndex+1], outVector[startIndex+1]);
 237                 }
 238             }
 239         }
 240     }
 241
 242     return result;
 243 }
 244
 245 static int scanString(char* buffer, int bufferLength, StringBuilder& builder, char termChar)
 246 {
 247     bool escape = false;
 248
 249     for (int i = 0; i < bufferLength; ++i) {
 250         UChar c = buffer[i];
 251
 252         if (escape) {
 253             switch (c) {
 254             case '0':
 255                 c = '\0';
 256                 break;
 257             case 'a':
 258                 c = '\a';
 259                 break;
 260             case 'b':
 261                 c = '\b';
 262                 break;
 263             case 'f':
 264                 c = '\f';
 265                 break;
 266             case 'n':
 267                 c = '\n';
 268                 break;
 269             case 'r':
 270                 c = '\r';
 271                 break;
 272             case 't':
 273                 c = '\t';
 274                 break;
 275             case 'v':
 276                 c = '\v';
 277                 break;
 278             case '\\':
 279                 c = '\\';
 280                 break;
 281             case '?':
 282                 c = '\?';
 283                 break;
 284             case 'u':
 285                 if ((i + 4) >= bufferLength)
 286                     return -1;
 287                 unsigned int charValue;
 288                 if (sscanf(buffer+i+1, "%04x", &charValue) != 1)
 289                     return -1;
 290                 c = static_cast<UChar>(charValue);
 291                 i += 4;
 292                 break;
 293             }
 294
 295             builder.append(c);
 296             escape = false;
 297         } else {
 298             if (c == termChar)
 299                 return i;
 300
 301             if (c == '\\')
 302                 escape = true;
 303             else
 304                 builder.append(c);
 305         }
 306     }
 307
 308     return -1;
 309 }
 310
 311 static RegExp* parseRegExpLine(VM& vm, char* line, int lineLength)
 312 {
 313     StringBuilder pattern;
 314
 315     if (line[0] != '/')
 316         return 0;
 317
 318     int i = scanString(line + 1, lineLength - 1, pattern, '/') + 1;
 319
 320     if ((i >= lineLength) || (line[i] != '/'))
 321         return 0;
 322
 323     ++i;
 324
 325     return RegExp::create(vm, pattern.toString(), regExpFlags(line + i));
 326 }
 327
 328 static RegExpTest* parseTestLine(char* line, int lineLength)
 329 {
 330     StringBuilder subjectString;
 331
 332     if ((line[0] != ' ') || (line[1] != '"'))
 333         return 0;
 334
 335     int i = scanString(line + 2, lineLength - 2, subjectString, '"') + 2;
 336
 337     if ((i >= (lineLength - 2)) || (line[i] != '"') || (line[i+1] != ',') || (line[i+2] != ' '))
 338         return 0;
 339
 340     i += 3;
 341
 342     int offset;
 343
 344     if (sscanf(line + i, "%d, ", &offset) != 1)
 345         return 0;
 346
 347     while (line[i] && line[i] != ' ')
 348         ++i;
 349
 350     ++i;
 351
 352     int matchResult;
 353
 354     if (sscanf(line + i, "%d, ", &matchResult) != 1)
 355         return 0;
 356
 357     while (line[i] && line[i] != ' ')
 358         ++i;
 359
 360     ++i;
 361
 362     if (line[i++] != '(')
 363         return 0;
 364
 365     int start, end;
 366
 367     RegExpTest* result = new RegExpTest();
 368
 369     result->subject = subjectString.toString();
 370     result->offset = offset;
 371     result->result = matchResult;
 372
 373     while (line[i] && line[i] != ')') {
 374         if (sscanf(line + i, "%d, %d", &start, &end) != 2) {
 375             delete result;
 376             return 0;
 377         }
 378
 379         result->expectVector.append(start);
 380         result->expectVector.append(end);
 381
 382         while (line[i] && (line[i] != ',') && (line[i] != ')'))
 383             i++;
 384         i++;
 385         while (line[i] && (line[i] != ',') && (line[i] != ')'))
 386             i++;
 387
 388         if (line[i] == ')')
 389             break;
 390         if (!line[i] || (line[i] != ',')) {
 391             delete result;
 392             return 0;
 393         }
 394         i++;
 395     }
 396
 397     return result;
 398 }
 399
 400 static bool runFromFiles(GlobalObject* globalObject, const Vector<String>& files, bool verbose)
 401 {
 402     String script;
 403     String fileName;
 404     Vector<char> scriptBuffer;
 405     unsigned tests = 0;
 406     unsigned failures = 0;
 407     char* lineBuffer = new char[MaxLineLength + 1];
 408
 409     VM& vm = globalObject->vm();
 410
 411     bool success = true;
 412     for (size_t i = 0; i < files.size(); i++) {
 413         FILE* testCasesFile = fopen(files[i].utf8().data(), "rb");
 414
 415         if (!testCasesFile) {
 416             printf("Unable to open test data file \"%s\"\n", files[i].utf8().data());
 417             continue;
 418         }
 419
 420         RegExp* regexp = 0;
 421         size_t lineLength = 0;
 422         char* linePtr = 0;
 423         unsigned int lineNumber = 0;
 424
 425         while ((linePtr = fgets(&lineBuffer[0], MaxLineLength, testCasesFile))) {
 426             lineLength = strlen(linePtr);
 427             if (linePtr[lineLength - 1] == '\n') {
 428                 linePtr[lineLength - 1] = '\0';
 429                 --lineLength;
 430             }
 431             ++lineNumber;
 432
 433             if (linePtr[0] == '#')
 434                 continue;
 435
 436             if (linePtr[0] == '/') {
 437                 regexp = parseRegExpLine(vm, linePtr, lineLength);
 438             } else if (linePtr[0] == ' ') {
 439                 RegExpTest* regExpTest = parseTestLine(linePtr, lineLength);
 440
 441                 if (regexp && regExpTest) {
 442                     ++tests;
 443                     if (!testOneRegExp(vm, regexp, regExpTest, verbose, lineNumber)) {
 444                         failures++;
 445                         printf("Failure on line %u\n", lineNumber);
 446                     }
 447                 }
 448
 449                 if (regExpTest)
 450                     delete regExpTest;
 451             }
 452         }
 453
 454         fclose(testCasesFile);
 455     }
 456
 457     if (failures)
 458         printf("%u tests run, %u failures\n", tests, failures);
 459     else
 460         printf("%u tests passed\n", tests);
 461
 462     delete[] lineBuffer;
 463
 464     vm.dumpSampleData(globalObject->globalExec());
 465 #if ENABLE(REGEXP_TRACING)
 466     vm.dumpRegExpTrace();
 467 #endif
 468     return success;
 469 }
 470
 471 #define RUNNING_FROM_XCODE 0
 472
 473 static NO_RETURN void printUsageStatement(bool help = false)
 474 {
 475     fprintf(stderr, "Usage: regexp_test [options] file\n");
 476     fprintf(stderr, "  -h|--help  Prints this help message\n");
 477     fprintf(stderr, "  -v|--verbose  Verbose output\n");
 478
 479     exit(help ? EXIT_SUCCESS : EXIT_FAILURE);
 480 }
 481
 482 static void parseArguments(int argc, char** argv, CommandLine& options)
 483 {
 484     int i = 1;
 485     for (; i < argc; ++i) {
 486         const char* arg = argv[i];
 487         if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
 488             printUsageStatement(true);
 489         if (!strcmp(arg, "-v") || !strcmp(arg, "--verbose"))
 490             options.verbose = true;
 491         else
 492             options.files.append(argv[i]);
 493     }
 494
 495     for (; i < argc; ++i)
 496         options.arguments.append(argv[i]);
 497 }
 498
 499 int realMain(int argc, char** argv)
 500 {
 501     VM* vm = VM::create(LargeHeap).leakRef();
 502     APIEntryShim shim(vm);
 503
 504     CommandLine options;
 505     parseArguments(argc, argv, options);
 506
 507     GlobalObject* globalObject = GlobalObject::create(*vm, GlobalObject::createStructure(*vm, jsNull()), options.arguments);
 508     bool success = runFromFiles(globalObject, options.files, options.verbose);
 509
 510     return success ? 0 : 3;
 511 }