js/src/jsapi-tests/testFrontendErrors.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/RefPtr.h"  // RefPtr
   8 #include "mozilla/Utf8.h"    // mozilla::Utf8Unit
   9
  10 #include <string.h>  // strcmp
  11
  12 #include "frontend/FrontendContext.h"  // js::FrontendContext
  13 #include "js/AllocPolicy.h"            // js::ReportOutOfMemory
  14 #include "js/CompileOptions.h"  // JS::PrefableCompileOptions, JS::CompileOptions
  15 #include "js/Exception.h"  // JS_IsExceptionPending, JS_IsThrowingOutOfMemory, JS_GetPendingException, JS_ClearPendingException, JS_ErrorFromException
  16 #include "js/experimental/CompileScript.h"  // JS::NewFrontendContext, JS::DestroyFrontendContext, JS::SetNativeStackQuota, JS::CompileGlobalScriptToStencil, JS::ConvertFrontendErrorsToRuntimeErrors, JS::HadFrontendErrors, JS::HadFrontendOverRecursed, JS::HadFrontendOutOfMemory, JS::HadFrontendAllocationOverflow, JS::GetFrontendWarningCount, JS::GetFrontendWarningAt
  17 #include "js/friend/ErrorMessages.h"        // JSMSG_*
  18 #include "js/friend/StackLimits.h"          // js::ReportOverRecursed
  19 #include "js/RootingAPI.h"                  // JS::Rooted
  20 #include "js/SourceText.h"                  // JS::SourceText
  21 #include "js/Stack.h"                       // JS::NativeStackSize
  22 #include "js/Warnings.h"                    // JS::SetWarningReporter
  23 #include "jsapi-tests/tests.h"
  24 #include "util/NativeStack.h"  // js::GetNativeStackBase
  25 #include "vm/ErrorObject.h"    // js::ErrorObject
  26 #include "vm/JSContext.h"      // JSContext
  27 #include "vm/JSObject.h"       // JSObject
  28 #include "vm/NativeObject.h"   // js::NativeObject
  29 #include "vm/Runtime.h"        // js::ReportAllocationOverflow
  30
  31 using namespace JS;
  32
  33 BEGIN_TEST(testFrontendErrors_error) {
  34   JS::FrontendContext* fc = JS::NewFrontendContext();
  35   CHECK(fc);
  36
  37   static constexpr JS::NativeStackSize stackSize = 128 * sizeof(size_t) * 1024;
  38
  39   JS::SetNativeStackQuota(fc, stackSize);
  40
  41   JS::PrefableCompileOptions prefableOptions;
  42   JS::CompileOptions options(prefableOptions);
  43   const char* filename = "testFrontendErrors_error.js";
  44   options.setFile(filename);
  45
  46   CHECK(!JS::HadFrontendErrors(fc));
  47
  48   {
  49     const char source[] = "syntax error";
  50
  51     JS::SourceText<mozilla::Utf8Unit> srcBuf;
  52     CHECK(
  53         srcBuf.init(fc, source, strlen(source), JS::SourceOwnership::Borrowed));
  54     JS::CompilationStorage compileStorage;
  55     RefPtr<JS::Stencil> stencil =
  56         JS::CompileGlobalScriptToStencil(fc, options, srcBuf, compileStorage);
  57     CHECK(!stencil);
  58   }
  59
  60   CHECK(JS::HadFrontendErrors(fc));
  61   CHECK(!JS::HadFrontendOverRecursed(fc));
  62   CHECK(!JS::HadFrontendOutOfMemory(fc));
  63   CHECK(!JS::HadFrontendAllocationOverflow(fc));
  64   CHECK(JS::GetFrontendWarningCount(fc) == 0);
  65
  66   {
  67     const JSErrorReport* report = JS::GetFrontendErrorReport(fc, options);
  68     CHECK(report);
  69
  70     CHECK(report->errorNumber == JSMSG_UNEXPECTED_TOKEN_NO_EXPECT);
  71     // FrontendContext's error report borrows the filename.
  72     CHECK(report->filename.c_str() == filename);
  73   }
  74
  75   CHECK(!JS_IsExceptionPending(cx));
  76
  77   JS::SetWarningReporter(cx, warningReporter);
  78
  79   bool result = JS::ConvertFrontendErrorsToRuntimeErrors(cx, fc, options);
  80   CHECK(result);
  81
  82   CHECK(JS_IsExceptionPending(cx));
  83   CHECK(!warningReporterCalled);
  84   CHECK(!JS_IsThrowingOutOfMemory(cx));
  85
  86   {
  87     JS::Rooted<JS::Value> exception(cx);
  88     CHECK(JS_GetPendingException(cx, &exception));
  89
  90     CHECK(exception.isObject());
  91     JS::Rooted<JSObject*> exceptionObj(cx, &exception.toObject());
  92
  93     const JSErrorReport* report = JS_ErrorFromException(cx, exceptionObj);
  94     CHECK(report);
  95
  96     CHECK(report->errorNumber == JSMSG_UNEXPECTED_TOKEN_NO_EXPECT);
  97     // Runtime's error report doesn't borrow the filename.
  98     CHECK(report->filename.c_str() != filename);
  99     CHECK(strcmp(report->filename.c_str(), filename) == 0);
 100   }
 101
 102   JS_ClearPendingException(cx);
 103
 104   JS::DestroyFrontendContext(fc);
 105
 106   return true;
 107 }
 108
 109 static bool warningReporterCalled;
 110
 111 static void warningReporter(JSContext* cx, JSErrorReport* report) {
 112   warningReporterCalled = true;
 113 }
 114 END_TEST(testFrontendErrors_error)
 115
 116 /* static */ bool cls_testFrontendErrors_error::warningReporterCalled = false;
 117
 118 BEGIN_TEST(testFrontendErrors_warning) {
 119   JS::FrontendContext* fc = JS::NewFrontendContext();
 120   CHECK(fc);
 121
 122   static constexpr JS::NativeStackSize stackSize = 128 * sizeof(size_t) * 1024;
 123
 124   JS::SetNativeStackQuota(fc, stackSize);
 125
 126   JS::PrefableCompileOptions prefableOptions;
 127   JS::CompileOptions options(prefableOptions);
 128   options.setFile(filename);
 129
 130   {
 131     const char source[] = "function f() { return; f(); }";
 132
 133     JS::SourceText<mozilla::Utf8Unit> srcBuf;
 134     CHECK(
 135         srcBuf.init(fc, source, strlen(source), JS::SourceOwnership::Borrowed));
 136     JS::CompilationStorage compileStorage;
 137     RefPtr<JS::Stencil> stencil =
 138         JS::CompileGlobalScriptToStencil(fc, options, srcBuf, compileStorage);
 139     CHECK(stencil);
 140   }
 141
 142   CHECK(!JS::HadFrontendErrors(fc));
 143   CHECK(!JS::HadFrontendOverRecursed(fc));
 144   CHECK(!JS::HadFrontendOutOfMemory(fc));
 145   CHECK(!JS::HadFrontendAllocationOverflow(fc));
 146   CHECK(JS::GetFrontendWarningCount(fc) == 1);
 147
 148   {
 149     const JSErrorReport* report = JS::GetFrontendWarningAt(fc, 0, options);
 150     CHECK(report);
 151
 152     CHECK(report->errorNumber == JSMSG_STMT_AFTER_RETURN);
 153     // FrontendContext's error report borrows the filename.
 154     CHECK(report->filename.c_str() == filename);
 155   }
 156
 157   CHECK(!JS_IsExceptionPending(cx));
 158
 159   JS::SetWarningReporter(cx, warningReporter);
 160
 161   bool result = JS::ConvertFrontendErrorsToRuntimeErrors(cx, fc, options);
 162   CHECK(result);
 163
 164   CHECK(!JS_IsExceptionPending(cx));
 165   CHECK(warningReporterCalled);
 166   CHECK(!JS_IsThrowingOutOfMemory(cx));
 167
 168   CHECK(errorNumberMatches);
 169   CHECK(filenameMatches);
 170
 171   JS::DestroyFrontendContext(fc);
 172
 173   return true;
 174 }
 175
 176 static const char* filename;
 177 static bool warningReporterCalled;
 178 static bool errorNumberMatches;
 179 static bool filenameMatches;
 180
 181 static void warningReporter(JSContext* cx, JSErrorReport* report) {
 182   warningReporterCalled = true;
 183
 184   errorNumberMatches = report->errorNumber == JSMSG_STMT_AFTER_RETURN;
 185   filenameMatches = report->filename.c_str() == filename;
 186 }
 187 END_TEST(testFrontendErrors_warning)
 188
 189 /* static */ const char* cls_testFrontendErrors_warning::filename =
 190     "testFrontendErrors_warning.js";
 191 /* static */ bool cls_testFrontendErrors_warning::warningReporterCalled = false;
 192 /* static */ bool cls_testFrontendErrors_warning::errorNumberMatches = false;
 193 /* static */ bool cls_testFrontendErrors_warning::filenameMatches = false;
 194
 195 BEGIN_TEST(testFrontendErrors_oom) {
 196   JS::FrontendContext* fc = JS::NewFrontendContext();
 197   CHECK(fc);
 198
 199   JS::PrefableCompileOptions prefableOptions;
 200   JS::CompileOptions options(prefableOptions);
 201
 202   CHECK(!JS::HadFrontendErrors(fc));
 203
 204   js::ReportOutOfMemory(fc);
 205
 206   CHECK(JS::HadFrontendErrors(fc));
 207   CHECK(!JS::HadFrontendOverRecursed(fc));
 208   CHECK(JS::HadFrontendOutOfMemory(fc));
 209   CHECK(!JS::HadFrontendAllocationOverflow(fc));
 210   CHECK(JS::GetFrontendWarningCount(fc) == 0);
 211
 212   CHECK(!JS_IsExceptionPending(cx));
 213
 214   JS::SetWarningReporter(cx, warningReporter);
 215
 216   bool result = JS::ConvertFrontendErrorsToRuntimeErrors(cx, fc, options);
 217   CHECK(!result);
 218
 219   CHECK(JS_IsExceptionPending(cx));
 220   CHECK(!warningReporterCalled);
 221   CHECK(JS_IsThrowingOutOfMemory(cx));
 222
 223   JS_ClearPendingException(cx);
 224
 225   JS::DestroyFrontendContext(fc);
 226
 227   return true;
 228 }
 229
 230 static bool warningReporterCalled;
 231
 232 static void warningReporter(JSContext* cx, JSErrorReport* report) {
 233   warningReporterCalled = true;
 234 }
 235 END_TEST(testFrontendErrors_oom)
 236
 237 /* static */ bool cls_testFrontendErrors_oom::warningReporterCalled = false;
 238
 239 BEGIN_TEST(testFrontendErrors_overRecursed) {
 240   JS::FrontendContext* fc = JS::NewFrontendContext();
 241   CHECK(fc);
 242
 243   JS::PrefableCompileOptions prefableOptions;
 244   JS::CompileOptions options(prefableOptions);
 245
 246   CHECK(!JS::HadFrontendErrors(fc));
 247
 248   js::ReportOverRecursed(fc);
 249
 250   CHECK(JS::HadFrontendErrors(fc));
 251   CHECK(JS::HadFrontendOverRecursed(fc));
 252   CHECK(!JS::HadFrontendOutOfMemory(fc));
 253   CHECK(!JS::HadFrontendAllocationOverflow(fc));
 254   CHECK(JS::GetFrontendWarningCount(fc) == 0);
 255
 256   CHECK(!JS_IsExceptionPending(cx));
 257
 258   JS::SetWarningReporter(cx, warningReporter);
 259
 260   bool result = JS::ConvertFrontendErrorsToRuntimeErrors(cx, fc, options);
 261   CHECK(result);
 262
 263   CHECK(JS_IsExceptionPending(cx));
 264   CHECK(!warningReporterCalled);
 265   CHECK(!JS_IsThrowingOutOfMemory(cx));
 266
 267   {
 268     JS::Rooted<JS::Value> exception(cx);
 269     CHECK(JS_GetPendingException(cx, &exception));
 270
 271     CHECK(exception.isObject());
 272     JS::Rooted<JSObject*> exceptionObj(cx, &exception.toObject());
 273
 274     const JSErrorReport* report = JS_ErrorFromException(cx, exceptionObj);
 275     CHECK(report);
 276
 277     CHECK(report->errorNumber == JSMSG_OVER_RECURSED);
 278   }
 279
 280   JS_ClearPendingException(cx);
 281
 282   JS::DestroyFrontendContext(fc);
 283
 284   return true;
 285 }
 286
 287 static bool warningReporterCalled;
 288
 289 static void warningReporter(JSContext* cx, JSErrorReport* report) {
 290   warningReporterCalled = true;
 291 }
 292 END_TEST(testFrontendErrors_overRecursed)
 293
 294 /* static */ bool cls_testFrontendErrors_overRecursed::warningReporterCalled =
 295     false;
 296
 297 BEGIN_TEST(testFrontendErrors_allocationOverflow) {
 298   JS::FrontendContext* fc = JS::NewFrontendContext();
 299   CHECK(fc);
 300
 301   JS::PrefableCompileOptions prefableOptions;
 302   JS::CompileOptions options(prefableOptions);
 303
 304   CHECK(!JS::HadFrontendErrors(fc));
 305
 306   js::ReportAllocationOverflow(fc);
 307
 308   CHECK(JS::HadFrontendErrors(fc));
 309   CHECK(!JS::HadFrontendOverRecursed(fc));
 310   CHECK(!JS::HadFrontendOutOfMemory(fc));
 311   CHECK(JS::HadFrontendAllocationOverflow(fc));
 312   CHECK(JS::GetFrontendWarningCount(fc) == 0);
 313
 314   CHECK(!JS_IsExceptionPending(cx));
 315
 316   JS::SetWarningReporter(cx, warningReporter);
 317
 318   bool result = JS::ConvertFrontendErrorsToRuntimeErrors(cx, fc, options);
 319   CHECK(result);
 320
 321   CHECK(JS_IsExceptionPending(cx));
 322   CHECK(!warningReporterCalled);
 323   CHECK(!JS_IsThrowingOutOfMemory(cx));
 324
 325   {
 326     JS::Rooted<JS::Value> exception(cx);
 327     CHECK(JS_GetPendingException(cx, &exception));
 328
 329     CHECK(exception.isObject());
 330     JS::Rooted<JSObject*> exceptionObj(cx, &exception.toObject());
 331
 332     const JSErrorReport* report = JS_ErrorFromException(cx, exceptionObj);
 333     CHECK(report);
 334
 335     CHECK(report->errorNumber == JSMSG_ALLOC_OVERFLOW);
 336   }
 337
 338   JS_ClearPendingException(cx);
 339
 340   JS::DestroyFrontendContext(fc);
 341
 342   return true;
 343 }
 344
 345 static bool warningReporterCalled;
 346
 347 static void warningReporter(JSContext* cx, JSErrorReport* report) {
 348   warningReporterCalled = true;
 349 }
 350 END_TEST(testFrontendErrors_allocationOverflow)
 351
 352 /* static */ bool
 353     cls_testFrontendErrors_allocationOverflow::warningReporterCalled = false;