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