Reviewed by Eric Seidel.
[WebKit-https.git] / JavaScriptCore / kjs / testkjs.cpp
1 // -*- c-basic-offset: 2 -*-
2 /*
3  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
4  *  Copyright (C) 2004-2007 Apple Inc.
5  *  Copyright (C) 2006 Bjoern Graf (bjoern.graf@gmail.com)
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Library General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Library General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Library General Public License
18  *  along with this library; see the file COPYING.LIB.  If not, write to
19  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  *  Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #include "config.h"
25
26 #include "JSGlobalObject.h"
27 #include "JSLock.h"
28 #include "Parser.h"
29 #include "collector.h"
30 #include "nodes.h"
31 #include "object.h"
32 #include "protect.h"
33 #include <math.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <wtf/Assertions.h>
37 #include <wtf/HashTraits.h>
38
39 #if HAVE(SYS_TIME_H)
40 #include <sys/time.h>
41 #endif
42
43 #if PLATFORM(WIN_OS)
44 #include <crtdbg.h>
45 #include <windows.h>
46 #endif
47
48 #if PLATFORM(QT)
49 #include <QDateTime>
50 #endif
51
52 using namespace KJS;
53 using namespace WTF;
54
55 static void testIsInteger();
56 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer);
57
58 class StopWatch
59 {
60 public:
61     void start();
62     void stop();
63     long getElapsedMS(); // call stop() first
64     
65 private:
66 #if PLATFORM(QT)
67     uint m_startTime;
68     uint m_stopTime;
69 #elif PLATFORM(WIN_OS)
70     DWORD m_startTime;
71     DWORD m_stopTime;
72 #else
73     // Windows does not have timeval, disabling this class for now (bug 7399)
74     timeval m_startTime;
75     timeval m_stopTime;
76 #endif
77 };
78
79 void StopWatch::start()
80 {
81 #if PLATFORM(QT)
82     QDateTime t = QDateTime::currentDateTime();
83     m_startTime = t.toTime_t() * 1000 + t.time().msec();
84 #elif PLATFORM(WIN_OS)
85     m_startTime = timeGetTime();
86 #else
87     gettimeofday(&m_startTime, 0);
88 #endif
89 }
90
91 void StopWatch::stop()
92 {
93 #if PLATFORM(QT)
94     QDateTime t = QDateTime::currentDateTime();
95     m_stopTime = t.toTime_t() * 1000 + t.time().msec();
96 #elif PLATFORM(WIN_OS)
97     m_stopTime = timeGetTime();
98 #else
99     gettimeofday(&m_stopTime, 0);
100 #endif
101 }
102
103 long StopWatch::getElapsedMS()
104 {
105 #if PLATFORM(WIN_OS) || PLATFORM(QT)
106     return m_stopTime - m_startTime;
107 #else
108     timeval elapsedTime;
109     timersub(&m_stopTime, &m_startTime, &elapsedTime);
110     
111     return elapsedTime.tv_sec * 1000 + lroundf(elapsedTime.tv_usec / 1000.0f);
112 #endif
113 }
114
115 class GlobalImp : public JSGlobalObject {
116 public:
117   virtual UString className() const { return "global"; }
118 };
119
120 class TestFunctionImp : public JSObject {
121 public:
122   enum TestFunctionType { Print, Debug, Quit, GC, Version, Run, Load };
123
124   TestFunctionImp(TestFunctionType i, int length);
125   virtual bool implementsCall() const { return true; }
126   virtual JSValue* callAsFunction(ExecState* exec, JSObject* thisObj, const List &args);
127
128 private:
129   TestFunctionType m_type;
130 };
131
132 TestFunctionImp::TestFunctionImp(TestFunctionType i, int length)
133   : JSObject()
134   , m_type(i)
135 {
136   putDirect(Identifier("length"), length, DontDelete | ReadOnly | DontEnum);
137 }
138
139 JSValue* TestFunctionImp::callAsFunction(ExecState* exec, JSObject*, const List &args)
140 {
141   switch (m_type) {
142     case Print:
143       printf("%s\n", args[0]->toString(exec).UTF8String().c_str());
144       return jsUndefined();
145     case Debug:
146       fprintf(stderr, "--> %s\n", args[0]->toString(exec).UTF8String().c_str());
147       return jsUndefined();
148     case GC:
149     {
150       JSLock lock;
151       Collector::collect();
152       return jsUndefined();
153     }
154     case Version:
155       // We need this function for compatibility with the Mozilla JS tests but for now
156       // we don't actually do any version-specific handling
157       return jsUndefined();
158     case Run:
159     {
160       StopWatch stopWatch;
161       UString fileName = args[0]->toString(exec);
162       Vector<char> script;
163       if (!fillBufferWithContentsOfFile(fileName, script))
164         return throwError(exec, GeneralError, "Could not open file.");
165
166       stopWatch.start();
167       exec->dynamicInterpreter()->evaluate(fileName, 0, script.data());
168       stopWatch.stop();
169       
170       return jsNumber(stopWatch.getElapsedMS());
171     }
172     case Load:
173     {
174       UString fileName = args[0]->toString(exec);
175       Vector<char> script;
176       if (!fillBufferWithContentsOfFile(fileName, script))
177         return throwError(exec, GeneralError, "Could not open file.");
178
179       exec->dynamicInterpreter()->evaluate(fileName, 0, script.data());
180
181       return jsUndefined();
182     }
183     case Quit:
184       exit(0);
185     default:
186       abort();
187   }
188   return 0;
189 }
190
191 // Use SEH for Release builds only to get rid of the crash report dialog
192 // (luckily the same tests fail in Release and Debug builds so far). Need to
193 // be in a separate main function because the kjsmain function requires object
194 // unwinding.
195
196 #if PLATFORM(WIN_OS) && !defined(_DEBUG)
197 #define TRY       __try {
198 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
199 #else
200 #define TRY
201 #define EXCEPT(x)
202 #endif
203
204 int kjsmain(int argc, char** argv);
205
206 int main(int argc, char** argv)
207 {
208 #if defined(_DEBUG) && PLATFORM(WIN_OS)
209     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
210     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
211     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
212     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
213     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
214     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
215 #endif
216
217     int res = 0;
218     TRY
219         res = kjsmain(argc, argv);
220     EXCEPT(res = 3)
221     return res;
222 }
223
224 static PassRefPtr<Interpreter> setupInterpreter()
225 {
226   GlobalImp* global = new GlobalImp();
227   RefPtr<Interpreter> interp = new Interpreter(global);
228   // add debug() function
229   global->put(interp->globalExec(), "debug", new TestFunctionImp(TestFunctionImp::Debug, 1));
230   // add "print" for compatibility with the mozilla js shell
231   global->put(interp->globalExec(), "print", new TestFunctionImp(TestFunctionImp::Print, 1));
232   // add "quit" for compatibility with the mozilla js shell
233   global->put(interp->globalExec(), "quit", new TestFunctionImp(TestFunctionImp::Quit, 0));
234   // add "gc" for compatibility with the mozilla js shell
235   global->put(interp->globalExec(), "gc", new TestFunctionImp(TestFunctionImp::GC, 0));
236   // add "version" for compatibility with the mozilla js shell 
237   global->put(interp->globalExec(), "version", new TestFunctionImp(TestFunctionImp::Version, 1));
238   global->put(interp->globalExec(), "run", new TestFunctionImp(TestFunctionImp::Run, 1));
239   global->put(interp->globalExec(), "load", new TestFunctionImp(TestFunctionImp::Load, 1));
240
241   Interpreter::setShouldPrintExceptions(true);
242   return interp.release();
243 }
244
245 static bool prettyPrintScript(const UString& fileName, const Vector<char>& script)
246 {
247   int errLine = 0;
248   UString errMsg;
249   UString scriptUString(script.data());
250   RefPtr<ProgramNode> programNode = parser().parseProgram(fileName, 0, scriptUString.data(), scriptUString.size(), 0, &errLine, &errMsg);
251   if (!programNode) {
252     fprintf(stderr, "%s:%d: %s.\n", fileName.UTF8String().c_str(), errLine, errMsg.UTF8String().c_str());
253     return false;
254   }
255   
256   printf("%s\n", programNode->toString().UTF8String().c_str());
257   return true;
258 }
259
260 static bool runWithScripts(const Vector<UString>& fileNames, bool prettyPrint)
261 {
262   RefPtr<Interpreter> interp = setupInterpreter();
263   Vector<char> script;
264   
265   bool success = true;
266   
267   for (size_t i = 0; i < fileNames.size(); i++) {
268     UString fileName = fileNames[i];
269     
270     if (!fillBufferWithContentsOfFile(fileName, script))
271       return false; // fail early so we can catch missing files
272     
273     if (prettyPrint)
274       prettyPrintScript(fileName, script);
275     else {
276       Completion completion = interp->evaluate(fileName, 0, script.data());
277       success = success && completion.complType() != Throw;
278     }
279   }
280   return success;
281 }
282
283 static void parseArguments(int argc, char** argv, Vector<UString>& fileNames, bool& prettyPrint)
284 {
285   if (argc < 2) {
286     fprintf(stderr, "Usage: testkjs file1 [file2...]\n");
287     exit(-1);
288   }
289   
290   for (int i = 1; i < argc; i++) {
291     const char* fileName = argv[i];
292     if (strcmp(fileName, "-f") == 0) // mozilla test driver script uses "-f" prefix for files
293       continue;
294     if (strcmp(fileName, "-p") == 0) {
295       prettyPrint = true;
296       continue;
297     }
298     fileNames.append(fileName);
299   }
300 }
301
302 int kjsmain(int argc, char** argv)
303 {
304   testIsInteger();
305
306   JSLock lock;
307   
308   bool prettyPrint = false;
309   Vector<UString> fileNames;
310   parseArguments(argc, argv, fileNames, prettyPrint);
311   
312   bool success = runWithScripts(fileNames, prettyPrint);
313
314 #ifndef NDEBUG
315   Collector::collect();
316 #endif
317
318   return success ? 0 : 3;
319 }
320
321 static void testIsInteger()
322 {
323   // Unit tests for WTF::IsInteger. Don't have a better place for them now.
324   // FIXME: move these once we create a unit test directory for WTF.
325
326   ASSERT(IsInteger<bool>::value);
327   ASSERT(IsInteger<char>::value);
328   ASSERT(IsInteger<signed char>::value);
329   ASSERT(IsInteger<unsigned char>::value);
330   ASSERT(IsInteger<short>::value);
331   ASSERT(IsInteger<unsigned short>::value);
332   ASSERT(IsInteger<int>::value);
333   ASSERT(IsInteger<unsigned int>::value);
334   ASSERT(IsInteger<long>::value);
335   ASSERT(IsInteger<unsigned long>::value);
336   ASSERT(IsInteger<long long>::value);
337   ASSERT(IsInteger<unsigned long long>::value);
338
339   ASSERT(!IsInteger<char*>::value);
340   ASSERT(!IsInteger<const char* >::value);
341   ASSERT(!IsInteger<volatile char* >::value);
342   ASSERT(!IsInteger<double>::value);
343   ASSERT(!IsInteger<float>::value);
344   ASSERT(!IsInteger<GlobalImp>::value);
345 }
346
347 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer)
348 {
349   FILE* f = fopen(fileName.UTF8String().c_str(), "r");
350   if (!f) {
351     fprintf(stderr, "Could not open file: %s\n", fileName.UTF8String().c_str());
352     return false;
353   }
354   
355   size_t buffer_size = 0;
356   size_t buffer_capacity = 1024;
357   
358   buffer.resize(buffer_capacity);
359   
360   while (!feof(f) && !ferror(f)) {
361     buffer_size += fread(buffer.data() + buffer_size, 1, buffer_capacity - buffer_size, f);
362     if (buffer_size == buffer_capacity) { // guarantees space for trailing '\0'
363       buffer_capacity *= 2;
364       buffer.resize(buffer_capacity);
365     }
366   }
367   fclose(f);
368   buffer[buffer_size] = '\0';
369   
370   return true;
371 }