JavaScriptCore:
[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 #include "collector.h"
26
27 #include <wtf/HashTraits.h>
28 #include "JSLock.h"
29 #include "object.h"
30 #include "Parser.h"
31
32 #include <math.h>
33 #include <stdio.h>
34
35 #include <string.h>
36 #if HAVE(SYS_TIME_H)
37 #include <sys/time.h>
38 #endif
39
40 #include "protect.h"
41
42 #if PLATFORM(WIN)
43 #include <WebKitInitializer/WebKitInitializer.h>
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 char* createStringWithContentsOfFile(const char* fileName);
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 JSObject {
116 public:
117   virtual UString className() const { return "global"; }
118 };
119
120 class TestFunctionImp : public JSObject {
121 public:
122   TestFunctionImp(int i, int length);
123   virtual bool implementsCall() const { return true; }
124   virtual JSValue* callAsFunction(ExecState* exec, JSObject* thisObj, const List &args);
125
126   enum { Print, Debug, Quit, GC, Version, Run, Load };
127
128 private:
129   int id;
130 };
131
132 TestFunctionImp::TestFunctionImp(int i, int length) : JSObject(), id(i)
133 {
134   putDirect(Identifier("length"), length, DontDelete | ReadOnly | DontEnum);
135 }
136
137 JSValue* TestFunctionImp::callAsFunction(ExecState* exec, JSObject*, const List &args)
138 {
139   switch (id) {
140     case Print:
141       printf("%s\n", args[0]->toString(exec).UTF8String().c_str());
142       return jsUndefined();
143     case Debug:
144       fprintf(stderr, "--> %s\n", args[0]->toString(exec).UTF8String().c_str());
145       return jsUndefined();
146     case GC:
147     {
148       JSLock lock;
149       Collector::collect();
150       return jsUndefined();
151     }
152     case Version:
153       // We need this function for compatibility with the Mozilla JS tests but for now
154       // we don't actually do any version-specific handling
155       return jsUndefined();
156     case Run:
157     {
158       StopWatch stopWatch;
159       char* fileName = strdup(args[0]->toString(exec).UTF8String().c_str());
160       char* script = createStringWithContentsOfFile(fileName);
161       if (!script) {
162         free(fileName);
163         return throwError(exec, GeneralError, "Could not open file.");
164       }
165
166       stopWatch.start();
167       exec->dynamicInterpreter()->evaluate(fileName, 0, script);
168       stopWatch.stop();
169
170       free(script);
171       free(fileName);
172       
173       return jsNumber(stopWatch.getElapsedMS());
174     }
175     case Load:
176     {
177       char* fileName = strdup(args[0]->toString(exec).UTF8String().c_str());
178       char* script = createStringWithContentsOfFile(fileName);
179       if (!script) {
180         free(fileName);
181         return throwError(exec, GeneralError, "Could not open file.");
182       }
183
184       exec->dynamicInterpreter()->evaluate(fileName, 0, script);
185
186       free(script);
187       free(fileName);
188       
189       return jsUndefined();
190     }
191     case Quit:
192       exit(0);
193     default:
194       abort();
195   }
196   return 0;
197 }
198
199 #if PLATFORM(WIN_OS)
200
201 // Use SEH for Release builds only to get rid of the crash report dialog
202 // (luckyly the same tests fail in Release and Debug builds so far). Need to
203 // be in a separate main function because the kjsmain function requires object
204 // unwinding.
205
206 #if defined(_DEBUG)
207 #define TRY
208 #define EXCEPT(x)
209 #else
210 #define TRY       __try {
211 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
212 #endif
213
214 #else
215
216 #define TRY
217 #define EXCEPT(x)
218
219 #endif
220
221 int kjsmain(int argc, char** argv);
222
223 int main(int argc, char** argv)
224 {
225 #if PLATFORM(WIN)
226     if (!initializeWebKit()) {
227         fprintf(stderr, "Failed to initialize WebKit\n");
228         abort();
229     }
230 #endif
231 #if defined(_DEBUG) && PLATFORM(WIN_OS)
232     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
233     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
234     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
235     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
236     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
237     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
238 #endif
239
240     int res = 0;
241     TRY
242         res = kjsmain(argc, argv);
243     EXCEPT(res = 3)
244     return res;
245 }
246
247
248 bool doIt(int argc, char** argv)
249 {
250   bool success = true;
251   bool prettyPrint = false;
252   GlobalImp* global = new GlobalImp();
253
254   // create interpreter
255   RefPtr<Interpreter> interp = new Interpreter(global);
256   // add debug() function
257   global->put(interp->globalExec(), "debug", new TestFunctionImp(TestFunctionImp::Debug, 1));
258   // add "print" for compatibility with the mozilla js shell
259   global->put(interp->globalExec(), "print", new TestFunctionImp(TestFunctionImp::Print, 1));
260   // add "quit" for compatibility with the mozilla js shell
261   global->put(interp->globalExec(), "quit", new TestFunctionImp(TestFunctionImp::Quit, 0));
262   // add "gc" for compatibility with the mozilla js shell
263   global->put(interp->globalExec(), "gc", new TestFunctionImp(TestFunctionImp::GC, 0));
264   // add "version" for compatibility with the mozilla js shell 
265   global->put(interp->globalExec(), "version", new TestFunctionImp(TestFunctionImp::Version, 1));
266   global->put(interp->globalExec(), "run", new TestFunctionImp(TestFunctionImp::Run, 1));
267   global->put(interp->globalExec(), "load", new TestFunctionImp(TestFunctionImp::Load, 1));
268   
269   Interpreter::setShouldPrintExceptions(true);
270   
271   for (int i = 1; i < argc; i++) {
272     const char* fileName = argv[i];
273     if (strcmp(fileName, "-f") == 0) // mozilla test driver script uses "-f" prefix for files
274       continue;
275     if (strcmp(fileName, "-p") == 0) {
276       prettyPrint = true;
277       continue;
278     }
279     
280     char* script = createStringWithContentsOfFile(fileName);
281     if (!script) {
282       success = false;
283       break; // fail early so we can catch missing files
284     }
285     
286     if (prettyPrint) {
287       int errLine = 0;
288       UString errMsg;
289       UString s = Parser::prettyPrint(script, &errLine, &errMsg);
290       if (s.isNull()) {
291         fprintf(stderr, "%s:%d: %s.\n", fileName, errLine, errMsg.UTF8String().c_str());
292         success = false;
293         free(script);
294         break;
295       }
296       
297       printf("%s\n", s.UTF8String().c_str());
298       
299     } else {
300       Completion completion = interp->evaluate(fileName, 0, script);
301       success = success && completion.complType() != Throw;
302     }
303     
304     free(script);
305   }
306
307   return success;
308 }
309
310
311 int kjsmain(int argc, char** argv)
312 {
313   if (argc < 2) {
314     fprintf(stderr, "Usage: testkjs file1 [file2...]\n");
315     return -1;
316   }
317
318   testIsInteger();
319
320   JSLock lock;
321
322   bool success = doIt(argc, argv);
323
324 #ifndef NDEBUG
325   Collector::collect();
326 #endif
327
328 #ifdef KJS_DEBUG_MEM
329   Interpreter::finalCheck();
330 #endif
331   return success ? 0 : 3;
332 }
333
334 static void testIsInteger()
335 {
336   // Unit tests for WTF::IsInteger. Don't have a better place for them now.
337   // FIXME: move these once we create a unit test directory for WTF.
338
339   assert(IsInteger<bool>::value);
340   assert(IsInteger<char>::value);
341   assert(IsInteger<signed char>::value);
342   assert(IsInteger<unsigned char>::value);
343   assert(IsInteger<short>::value);
344   assert(IsInteger<unsigned short>::value);
345   assert(IsInteger<int>::value);
346   assert(IsInteger<unsigned int>::value);
347   assert(IsInteger<long>::value);
348   assert(IsInteger<unsigned long>::value);
349   assert(IsInteger<long long>::value);
350   assert(IsInteger<unsigned long long>::value);
351
352   assert(!IsInteger<char*>::value);
353   assert(!IsInteger<const char* >::value);
354   assert(!IsInteger<volatile char* >::value);
355   assert(!IsInteger<double>::value);
356   assert(!IsInteger<float>::value);
357   assert(!IsInteger<GlobalImp>::value);
358 }
359
360 static char* createStringWithContentsOfFile(const char* fileName)
361 {
362   char* buffer;
363   
364   size_t buffer_size = 0;
365   size_t buffer_capacity = 1024;
366   buffer = (char*)malloc(buffer_capacity);
367   
368   FILE* f = fopen(fileName, "r");
369   if (!f) {
370     fprintf(stderr, "Could not open file: %s\n", fileName);
371     free(buffer);
372     return 0;
373   }
374   
375   while (!feof(f) && !ferror(f)) {
376     buffer_size += fread(buffer + buffer_size, 1, buffer_capacity - buffer_size, f);
377     if (buffer_size == buffer_capacity) { // guarantees space for trailing '\0'
378       buffer_capacity *= 2;
379       buffer = (char*)realloc(buffer, buffer_capacity);
380       assert(buffer);
381     }
382     
383     assert(buffer_size < buffer_capacity);
384   }
385   fclose(f);
386   buffer[buffer_size] = '\0';
387   
388   return buffer;
389 }