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 "SourceCode.h"
  30 #include "collector.h"
  31 #include "interpreter.h"
  32 #include "nodes.h"
  33 #include "object.h"
  34 #include "protect.h"
  35 #include <math.h>
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <wtf/Assertions.h>
  39 #include <wtf/HashTraits.h>
  40
  41 #if HAVE(SYS_TIME_H)
  42 #include <sys/time.h>
  43 #endif
  44
  45 #if PLATFORM(WIN_OS)
  46 #include <crtdbg.h>
  47 #include <windows.h>
  48 #endif
  49
  50 #if PLATFORM(QT)
  51 #include <QDateTime>
  52 #endif
  53
  54 using namespace KJS;
  55 using namespace WTF;
  56
  57 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer);
  58
  59 class StopWatch
  60 {
  61 public:
  62     void start();
  63     void stop();
  64     long getElapsedMS(); // call stop() first
  65
  66 private:
  67 #if PLATFORM(QT)
  68     uint m_startTime;
  69     uint m_stopTime;
  70 #elif PLATFORM(WIN_OS)
  71     DWORD m_startTime;
  72     DWORD m_stopTime;
  73 #else
  74     // Windows does not have timeval, disabling this class for now (bug 7399)
  75     timeval m_startTime;
  76     timeval m_stopTime;
  77 #endif
  78 };
  79
  80 void StopWatch::start()
  81 {
  82 #if PLATFORM(QT)
  83     QDateTime t = QDateTime::currentDateTime();
  84     m_startTime = t.toTime_t() * 1000 + t.time().msec();
  85 #elif PLATFORM(WIN_OS)
  86     m_startTime = timeGetTime();
  87 #else
  88     gettimeofday(&m_startTime, 0);
  89 #endif
  90 }
  91
  92 void StopWatch::stop()
  93 {
  94 #if PLATFORM(QT)
  95     QDateTime t = QDateTime::currentDateTime();
  96     m_stopTime = t.toTime_t() * 1000 + t.time().msec();
  97 #elif PLATFORM(WIN_OS)
  98     m_stopTime = timeGetTime();
  99 #else
 100     gettimeofday(&m_stopTime, 0);
 101 #endif
 102 }
 103
 104 long StopWatch::getElapsedMS()
 105 {
 106 #if PLATFORM(WIN_OS) || PLATFORM(QT)
 107     return m_stopTime - m_startTime;
 108 #else
 109     timeval elapsedTime;
 110     timersub(&m_stopTime, &m_startTime, &elapsedTime);
 111
 112     return elapsedTime.tv_sec * 1000 + lroundf(elapsedTime.tv_usec / 1000.0f);
 113 #endif
 114 }
 115
 116 class GlobalImp : public JSGlobalObject {
 117 public:
 118   virtual UString className() const { return "global"; }
 119 };
 120 COMPILE_ASSERT(!IsInteger<GlobalImp>::value, WTF_IsInteger_GlobalImp_false);
 121
 122 class TestFunctionImp : public JSObject {
 123 public:
 124   enum TestFunctionType { Print, Debug, Quit, GC, Version, Run, Load };
 125
 126   TestFunctionImp(TestFunctionType i, int length);
 127   virtual bool implementsCall() const { return true; }
 128   virtual JSValue* callAsFunction(ExecState* exec, JSObject* thisObj, const List &args);
 129
 130 private:
 131   TestFunctionType m_type;
 132 };
 133
 134 TestFunctionImp::TestFunctionImp(TestFunctionType i, int length)
 135   : JSObject()
 136   , m_type(i)
 137 {
 138   putDirect(Identifier("length"), length, DontDelete | ReadOnly | DontEnum);
 139 }
 140
 141 JSValue* TestFunctionImp::callAsFunction(ExecState* exec, JSObject*, const List &args)
 142 {
 143   switch (m_type) {
 144     case Print:
 145       printf("%s\n", args[0]->toString(exec).UTF8String().c_str());
 146       return jsUndefined();
 147     case Debug:
 148       fprintf(stderr, "--> %s\n", args[0]->toString(exec).UTF8String().c_str());
 149       return jsUndefined();
 150     case GC:
 151     {
 152       JSLock lock;
 153       Collector::collect();
 154       return jsUndefined();
 155     }
 156     case Version:
 157       // We need this function for compatibility with the Mozilla JS tests but for now
 158       // we don't actually do any version-specific handling
 159       return jsUndefined();
 160     case Run:
 161     {
 162       StopWatch stopWatch;
 163       UString fileName = args[0]->toString(exec);
 164       Vector<char> script;
 165       if (!fillBufferWithContentsOfFile(fileName, script))
 166         return throwError(exec, GeneralError, "Could not open file.");
 167
 168       stopWatch.start();
 169
 170       Interpreter::evaluate(exec->dynamicGlobalObject()->globalExec(), makeSource(script.data(), fileName));
 171       stopWatch.stop();
 172
 173       return jsNumber(stopWatch.getElapsedMS());
 174     }
 175     case Load:
 176     {
 177       UString fileName = args[0]->toString(exec);
 178       Vector<char> script;
 179       if (!fillBufferWithContentsOfFile(fileName, script))
 180         return throwError(exec, GeneralError, "Could not open file.");
 181
 182       Interpreter::evaluate(exec->dynamicGlobalObject()->globalExec(), makeSource(script.data(), fileName));
 183
 184       return jsUndefined();
 185     }
 186     case Quit:
 187       exit(0);
 188     default:
 189       abort();
 190   }
 191   return 0;
 192 }
 193
 194 // Use SEH for Release builds only to get rid of the crash report dialog
 195 // (luckily the same tests fail in Release and Debug builds so far). Need to
 196 // be in a separate main function because the kjsmain function requires object
 197 // unwinding.
 198
 199 #if PLATFORM(WIN_OS) && !defined(_DEBUG)
 200 #define TRY       __try {
 201 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
 202 #else
 203 #define TRY
 204 #define EXCEPT(x)
 205 #endif
 206
 207 int kjsmain(int argc, char** argv);
 208
 209 int main(int argc, char** argv)
 210 {
 211 #if defined(_DEBUG) && PLATFORM(WIN_OS)
 212     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
 213     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
 214     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
 215     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
 216     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 217     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
 218 #endif
 219
 220     int res = 0;
 221     TRY
 222         res = kjsmain(argc, argv);
 223     EXCEPT(res = 3)
 224     return res;
 225 }
 226
 227 static GlobalImp* createGlobalObject()
 228 {
 229   GlobalImp* global = new GlobalImp;
 230
 231   // add debug() function
 232   global->put(global->globalExec(), "debug", new TestFunctionImp(TestFunctionImp::Debug, 1));
 233   // add "print" for compatibility with the mozilla js shell
 234   global->put(global->globalExec(), "print", new TestFunctionImp(TestFunctionImp::Print, 1));
 235   // add "quit" for compatibility with the mozilla js shell
 236   global->put(global->globalExec(), "quit", new TestFunctionImp(TestFunctionImp::Quit, 0));
 237   // add "gc" for compatibility with the mozilla js shell
 238   global->put(global->globalExec(), "gc", new TestFunctionImp(TestFunctionImp::GC, 0));
 239   // add "version" for compatibility with the mozilla js shell
 240   global->put(global->globalExec(), "version", new TestFunctionImp(TestFunctionImp::Version, 1));
 241   global->put(global->globalExec(), "run", new TestFunctionImp(TestFunctionImp::Run, 1));
 242   global->put(global->globalExec(), "load", new TestFunctionImp(TestFunctionImp::Load, 1));
 243
 244   Interpreter::setShouldPrintExceptions(true);
 245   return global;
 246 }
 247
 248 static bool prettyPrintScript(const UString& fileName, const Vector<char>& script)
 249 {
 250   int errLine = 0;
 251   UString errMsg;
 252
 253   RefPtr<ProgramNode> programNode = parser().parse<ProgramNode>(makeSource(script.data(), fileName), &errLine, &errMsg);
 254   if (!programNode) {
 255     fprintf(stderr, "%s:%d: %s.\n", fileName.UTF8String().c_str(), errLine, errMsg.UTF8String().c_str());
 256     return false;
 257   }
 258
 259   printf("%s\n", programNode->toString().UTF8String().c_str());
 260   return true;
 261 }
 262
 263 static bool runWithScripts(const Vector<UString>& fileNames, bool prettyPrint)
 264 {
 265   GlobalImp* globalObject = createGlobalObject();
 266   Vector<char> script;
 267
 268   bool success = true;
 269
 270   for (size_t i = 0; i < fileNames.size(); i++) {
 271     UString fileName = fileNames[i];
 272
 273     if (!fillBufferWithContentsOfFile(fileName, script))
 274       return false; // fail early so we can catch missing files
 275
 276     if (prettyPrint)
 277       prettyPrintScript(fileName, script);
 278     else {
 279       Completion completion = Interpreter::evaluate(globalObject->globalExec(), makeSource(script.data(), fileName));
 280       success = success && completion.complType() != Throw;
 281     }
 282   }
 283   return success;
 284 }
 285
 286 static void parseArguments(int argc, char** argv, Vector<UString>& fileNames, bool& prettyPrint)
 287 {
 288   if (argc < 2) {
 289     fprintf(stderr, "Usage: testkjs file1 [file2...]\n");
 290     exit(-1);
 291   }
 292
 293   for (int i = 1; i < argc; i++) {
 294     const char* fileName = argv[i];
 295     if (strcmp(fileName, "-f") == 0) // mozilla test driver script uses "-f" prefix for files
 296       continue;
 297     if (strcmp(fileName, "-p") == 0) {
 298       prettyPrint = true;
 299       continue;
 300     }
 301     fileNames.append(fileName);
 302   }
 303 }
 304
 305 int kjsmain(int argc, char** argv)
 306 {
 307   JSLock lock;
 308
 309   bool prettyPrint = false;
 310   Vector<UString> fileNames;
 311   parseArguments(argc, argv, fileNames, prettyPrint);
 312
 313   bool success = runWithScripts(fileNames, prettyPrint);
 314
 315 #ifndef NDEBUG
 316   Collector::collect();
 317 #endif
 318
 319   return success ? 0 : 3;
 320 }
 321
 322 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer)
 323 {
 324   FILE* f = fopen(fileName.UTF8String().c_str(), "r");
 325   if (!f) {
 326     fprintf(stderr, "Could not open file: %s\n", fileName.UTF8String().c_str());
 327     return false;
 328   }
 329
 330   size_t buffer_size = 0;
 331   size_t buffer_capacity = 1024;
 332
 333   buffer.resize(buffer_capacity);
 334
 335   while (!feof(f) && !ferror(f)) {
 336     buffer_size += fread(buffer.data() + buffer_size, 1, buffer_capacity - buffer_size, f);
 337     if (buffer_size == buffer_capacity) { // guarantees space for trailing '\0'
 338       buffer_capacity *= 2;
 339       buffer.resize(buffer_capacity);
 340     }
 341   }
 342   fclose(f);
 343   buffer[buffer_size] = '\0';
 344
 345   return true;
 346 }