firefox-main/js/src/jsapi-tests/tests.cpp (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "jsapi-tests/tests.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/Sprintf.h"
#include "mozilla/Utf8.h" // mozilla::Utf8Unit
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "js/CharacterEncoding.h"
#include "js/CompilationAndEvaluation.h" // JS::Evaluate
#include "js/Conversions.h"
#include "js/Equality.h" // JS::SameValue
#include "js/GlobalObject.h" // JS::DefaultGlobalClassOps, JS_NewGlobalObject
#include "js/Initialization.h"
#include "js/Prefs.h"
#include "js/PropertyAndElement.h" // JS_DefineFunction
#include "js/RootingAPI.h"
#include "js/SourceText.h" // JS::Source{Ownership,Text}
#include "js/Warnings.h" // JS::SetWarningReporter
using namespace jsapitest;
// A singly linked list of tests which doesn't require runtime intialization.
//
// We rely on the runtime initialization of global variables containing test
// instances to add themselves to these lists, which depends on them already
// being in a valid state.
template <typename T>
class TestList {
T* first = nullptr;
T* last = nullptr;
public:
T* getFirst() const { return first; }
void pushBack(T* element) {
MOZ_ASSERT(!element->next);
MOZ_ASSERT(bool(first) == bool(last));
if (!first) {
first = element;
last = element;
return;
}
last->next = element;
last = element;
}
};
static TestList<TestBase> testList;
TestBase::TestBase(TestKind kind) : kind(kind) { testList.pushBack(this); }
[[noreturn]] static void Die(const char* format, ...) {
fprintf(stderr, "TEST-UNEXPECTED-FAIL | jsapi-tests | ");
va_list ap;
va_start(ap, format);
vfprintf(stderr, format, ap);
va_end(ap);
fprintf(stderr, "\n");
exit(1);
}
bool TestBase::fail(const std::string& msg, const char* filename, int lineno) {
char location[256];
SprintfLiteral(location, "%s:%d:", filename, lineno);
std::string message(location);
message += msg;
maybeAppendException(message);
fprintf(stderr, "%s\n", message.c_str());
if (msgs.length() != 0) {
msgs += " | ";
}
msgs += message;
return false;
}
/* static */
RuntimeTest* RuntimeTest::From(TestBase* test) {
MOZ_ASSERT(test->isRuntimeTest());
return static_cast<RuntimeTest*>(test);
}
RuntimeTest::RuntimeTest() : TestBase(TestKind::Runtime) {}
RuntimeTest::~RuntimeTest() {
MOZ_RELEASE_ASSERT(!cx);
MOZ_RELEASE_ASSERT(!global);
}
bool RuntimeTest::initContext(JSContext* maybeReusableContext) {
if (maybeReusableContext && reuseGlobal) {
cx = maybeReusableContext;
global.init(cx, JS::CurrentGlobalOrNull(cx));
return true;
}
MaybeFreeContext(maybeReusableContext);
cx = createContext();
if (!cx) {
return false;
}
js::UseInternalJobQueues(cx);
if (!JS::InitSelfHostedCode(cx)) {
return false;
}
global.init(cx);
createGlobal();
if (!global) {
return false;
}
JS::EnterRealm(cx, global);
return true;
}
JSContext* RuntimeTest::maybeForgetContext() {
if (!reuseGlobal) {
return nullptr;
}
JSContext* reusableCx = cx;
global.reset();
cx = nullptr;
return reusableCx;
}
/* static */
void RuntimeTest::MaybeFreeContext(JSContext* maybeCx) {
if (maybeCx) {
JS::LeaveRealm(maybeCx, nullptr);
JS_DestroyContext(maybeCx);
}
}
void RuntimeTest::uninit() {
global.reset();
MaybeFreeContext(cx);
cx = nullptr;
msgs.clear();
}
bool RuntimeTest::exec(const char* utf8, const char* filename, int lineno) {
JS::CompileOptions opts(cx);
opts.setFileAndLine(filename, lineno);
JS::SourceText<mozilla::Utf8Unit> srcBuf;
JS::RootedValue v(cx);
return (srcBuf.init(cx, utf8, strlen(utf8), JS::SourceOwnership::Borrowed) &&
JS::Evaluate(cx, opts, srcBuf, &v)) ||
fail(utf8, filename, lineno);
}
bool RuntimeTest::execDontReport(const char* utf8, const char* filename,
int lineno) {
JS::CompileOptions opts(cx);
opts.setFileAndLine(filename, lineno);
JS::SourceText<mozilla::Utf8Unit> srcBuf;
JS::RootedValue v(cx);
return srcBuf.init(cx, utf8, strlen(utf8), JS::SourceOwnership::Borrowed) &&
JS::Evaluate(cx, opts, srcBuf, &v);
}
bool RuntimeTest::evaluate(const char* utf8, const char* filename, int lineno,
JS::MutableHandleValue vp) {
JS::CompileOptions opts(cx);
opts.setFileAndLine(filename, lineno);
JS::SourceText<mozilla::Utf8Unit> srcBuf;
return (srcBuf.init(cx, utf8, strlen(utf8), JS::SourceOwnership::Borrowed) &&
JS::Evaluate(cx, opts, srcBuf, vp)) ||
fail(utf8, filename, lineno);
}
std::string RuntimeTest::jsvalToSource(JS::HandleValue v) {
JS::Rooted<JSString*> str(cx, JS_ValueToSource(cx, v));
if (str) {
if (JS::UniqueChars bytes = JS_EncodeStringToUTF8(cx, str)) {
return bytes.get();
}
}
JS_ClearPendingException(cx);
return "<<error converting value to string>>";
}
std::string RuntimeTest::toSource(char c) {
char buf[2] = {c, '\0'};
return buf;
}
std::string RuntimeTest::toSource(long v) {
char buf[40];
SprintfLiteral(buf, "%ld", v);
return buf;
}
std::string RuntimeTest::toSource(unsigned long v) {
char buf[40];
SprintfLiteral(buf, "%lu", v);
return buf;
}
std::string RuntimeTest::toSource(long long v) {
char buf[40];
SprintfLiteral(buf, "%lld", v);
return buf;
}
std::string RuntimeTest::toSource(unsigned long long v) {
char buf[40];
SprintfLiteral(buf, "%llu", v);
return buf;
}
std::string RuntimeTest::toSource(double d) {
char buf[40];
SprintfLiteral(buf, "%17lg", d);
return buf;
}
std::string RuntimeTest::toSource(unsigned int v) {
return toSource((unsigned long)v);
}
std::string RuntimeTest::toSource(int v) { return toSource((long)v); }
std::string RuntimeTest::toSource(bool v) { return v ? "true" : "false"; }
std::string RuntimeTest::toSource(JS::RegExpFlags flags) {
std::string str;
if (flags.hasIndices()) {
str += "d";
}
if (flags.global()) {
str += "g";
}
if (flags.ignoreCase()) {
str += "i";
}
if (flags.multiline()) {
str += "m";
}
if (flags.dotAll()) {
str += "s";
}
if (flags.unicode()) {
str += "u";
}
if (flags.unicodeSets()) {
str += "v";
}
if (flags.sticky()) {
str += "y";
}
return str;
}
std::string RuntimeTest::toSource(JSAtom* v) {
JS::RootedValue val(cx, JS::StringValue((JSString*)v));
return jsvalToSource(val);
}
bool RuntimeTest::checkSame(const JS::Value& actualArg,
const JS::Value& expectedArg,
const char* actualExpr, const char* expectedExpr,
const char* filename, int lineno) {
bool same = false;
JS::RootedValue actual(cx, actualArg);
JS::RootedValue expected(cx, expectedArg);
if (JS::SameValue(cx, actual, expected, &same) && same) {
return true;
}
return false;
}
void RuntimeTest::maybeAppendException(std::string& message) {
if (JS_IsExceptionPending(cx)) {
message += " -- ";
js::gc::AutoSuppressGC gcoff(cx);
JS::RootedValue v(cx);
JS_GetPendingException(cx, &v);
JS_ClearPendingException(cx);
JS::Rooted<JSString*> s(cx, JS::ToString(cx, v));
if (s) {
if (JS::UniqueChars bytes = JS_EncodeStringToLatin1(cx, s)) {
message += bytes.get();
}
}
}
}
/* static */
const JSClass* RuntimeTest::basicGlobalClass() {
static const JSClass c = {
"global",
JSCLASS_GLOBAL_FLAGS,
&JS::DefaultGlobalClassOps,
};
return &c;
}
/* static */
void RuntimeTest::reportWarning(JSContext* cx, JSErrorReport* report) {
MOZ_RELEASE_ASSERT(report->isWarning());
fprintf(stderr, "%s:%u:%s\n",
report->filename ? report->filename.c_str() : "<no filename>",
(unsigned int)report->lineno, report->message().c_str());
}
/* static */
bool RuntimeTest::print(JSContext* cx, unsigned argc, JS::Value* vp) {
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::Rooted<JSString*> str(cx);
for (unsigned i = 0; i < args.length(); i++) {
str = JS::ToString(cx, args[i]);
if (!str) {
return false;
}
JS::UniqueChars bytes = JS_EncodeStringToUTF8(cx, str);
if (!bytes) {
return false;
}
printf("%s%s", i ? " " : "", bytes.get());
}
putchar('\n');
fflush(stdout);
args.rval().setUndefined();
return true;
}
bool RuntimeTest::definePrint() {
return JS_DefineFunction(cx, global, "print", (JSNative)print, 0, 0);
}
JSContext* RuntimeTest::createContext() {
JSContext* cx = JS_NewContext(8L * 1024 * 1024);
if (!cx) {
return nullptr;
}
JS::SetWarningReporter(cx, &reportWarning);
return cx;
}
JSObject* RuntimeTest::createGlobal(JSPrincipals* principals) {
/* Create the global object. */
JS::RootedObject newGlobal(cx);
JS::RealmOptions options;
options.creationOptions().setSharedMemoryAndAtomicsEnabled(true);
newGlobal = JS_NewGlobalObject(cx, getGlobalClass(), principals,
JS::FireOnNewGlobalHook, options);
if (!newGlobal) {
return nullptr;
}
global = newGlobal;
return newGlobal;
}
FrontendTest::FrontendTest() : TestBase(TestKind::Frontend) {}
TempFile::TempFile() : name(), stream() {}
TempFile::~TempFile() {
if (stream) {
close();
}
if (name) {
remove();
}
}
FILE* TempFile::open(const char* fileName) {
stream = fopen(fileName, "wb+");
if (!stream) {
Die("error opening temporary file '%s': %s", fileName, strerror(errno));
}
name = fileName;
return stream;
}
void TempFile::close() {
if (fclose(stream) == EOF) {
Die("error closing temporary file '%s': %s", name, strerror(errno));
}
stream = nullptr;
}
void TempFile::remove() {
if (::remove(name) != 0) {
Die("error deleting temporary file '%s': %s", name, strerror(errno));
}
name = nullptr;
}
TestJSPrincipals::TestJSPrincipals(int rc) { refcount = rc; }
bool TestJSPrincipals::write(JSContext* cx, JSStructuredCloneWriter* writer) {
MOZ_CRASH("TestJSPrincipals::write not implemented");
}
ExternalData::ExternalData(const char* str)
: contents_(strdup(str)), len_(strlen(str) + 1) {}
void ExternalData::free() {
MOZ_ASSERT(!wasFreed());
::free(contents_);
contents_ = nullptr;
}
mozilla::UniquePtr<void, JS::BufferContentsDeleter> ExternalData::pointer() {
MOZ_ASSERT(!uniquePointerCreated_,
"Not allowed to create multiple unique pointers to contents");
uniquePointerCreated_ = true;
return {contents_, {ExternalData::freeCallback, this}};
}
/* static */
void ExternalData::freeCallback(void* contents, void* userData) {
auto self = static_cast<ExternalData*>(userData);
MOZ_ASSERT(self->contents() == contents);
self->free();
}
AutoGCParameter::AutoGCParameter(JSContext* cx, JSGCParamKey key,
uint32_t value)
: cx_(cx), key_(key), value_() {
value_ = JS_GetGCParameter(cx, key);
JS_SetGCParameter(cx, key, value);
}
AutoGCParameter::~AutoGCParameter() { JS_SetGCParameter(cx_, key_, value_); }
#ifdef JS_GC_ZEAL
AutoLeaveZeal::AutoLeaveZeal(JSContext* cx)
: cx_(cx), zealBits_(0), frequency_(0) {
uint32_t dummy;
JS::GetGCZealBits(cx_, &zealBits_, &frequency_, &dummy);
JS::SetGCZeal(cx_, 0, 0);
JS::PrepareForFullGC(cx_);
JS::NonIncrementalGC(cx_, JS::GCOptions::Normal, JS::GCReason::DEBUG_GC);
}
AutoLeaveZeal::~AutoLeaveZeal() {
JS::SetGCZeal(cx_, 0, 0);
for (size_t i = 0; i < sizeof(zealBits_) * 8; i++) {
if (zealBits_ & (1 << i)) {
JS::SetGCZeal(cx_, i, frequency_);
}
}
# ifdef DEBUG
uint32_t zealBitsAfter, frequencyAfter, dummy;
JS::GetGCZealBits(cx_, &zealBitsAfter, &frequencyAfter, &dummy);
MOZ_ASSERT(zealBitsAfter == zealBits_);
MOZ_ASSERT(frequencyAfter == frequency_);
# endif
}
#else
AutoLeaveZeal::AutoLeaveZeal(JSContext* cx) {}
AutoLeaveZeal::~AutoLeaveZeal() {}
#endif
struct CommandOptions {
bool list = false;
bool runRuntimeTests = true;
bool runFrontendTests = true;
bool help = false;
const char* filter = nullptr;
};
static void PrintUsage() {
printf("Usage: jsapi-tests [OPTIONS] [FILTER]\n");
printf("\n");
printf("Options:\n");
printf(" -h, --help Display this message\n");
printf(" --list List all tests\n");
printf(
" --frontend-only Run tests for frontend-only APIs, with "
"light-weight entry point\n");
}
static void ParseArgs(int argc, char* argv[], CommandOptions& options) {
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
options.help = true;
continue;
}
if (strcmp(argv[i], "--list") == 0) {
options.list = true;
continue;
}
if (strcmp(argv[i], "--frontend-only") == 0) {
options.runRuntimeTests = false;
continue;
}
if (!options.filter) {
options.filter = argv[i];
continue;
}
printf("error: Unrecognized option: %s\n", argv[i]);
options.help = true;
}
}
static void NewHandler() {
std::set_new_handler(nullptr);
Die("Out of memory.");
}
template <typename TestT>
void PrintTests(TestList<TestT> list) {
for (TestT* test = list.getFirst(); test; test = test->next) {
printf("%s\n", test->name());
}
}
void RunTests(int& total, int& failures, CommandOptions& options,
TestList<TestBase> list) {
// Reinitializing the global for every test is quite slow, due to having to
// recompile all self-hosted builtins. Allow tests to opt-in to reusing the
// context and global.
JSContext* maybeReusedContext = nullptr;
auto guard = mozilla::MakeScopeExit(
[&]() { RuntimeTest::MaybeFreeContext(maybeReusedContext); });
for (TestBase* test = list.getFirst(); test; test = test->next) {
if ((test->isRuntimeTest() && !options.runRuntimeTests) ||
(!test->isRuntimeTest() && !options.runFrontendTests)) {
continue;
}
const char* name = test->name();
if (options.filter && strstr(name, options.filter) == nullptr) {
continue;
}
total += 1;
printf("%s\n", name);
// Make sure the test name is printed before we enter the test that can
// crash on failure.
fflush(stdout);
if (test->isRuntimeTest() &&
!RuntimeTest::From(test)->initContext(maybeReusedContext)) {
printf("TEST-UNEXPECTED-FAIL | %s | Failed to set context.\n", name);
failures++;
continue;
}
if (!test->init()) {
printf("TEST-UNEXPECTED-FAIL | %s | Failed to initialize.\n", name);
failures++;
test->uninit();
continue;
}
if (test->run()) {
printf("TEST-PASS | %s | ok\n", name);
} else {
std::string messages = test->messages();
printf("%s | %s | %s\n",
(test->knownFail ? "TEST-KNOWN-FAIL" : "TEST-UNEXPECTED-FAIL"),
name, messages.c_str());
if (!test->knownFail) {
failures++;
}
}
if (test->isRuntimeTest()) {
// Return a non-nullptr pointer if the context & global can safely be
// reused for the next test.
maybeReusedContext = RuntimeTest::From(test)->maybeForgetContext();
}
test->uninit();
}
}
int main(int argc, char* argv[]) {
int total = 0;
int failures = 0;
CommandOptions options;
ParseArgs(argc, argv, options);
if (options.help) {
PrintUsage();
return 0;
}
// Ensure allocation failure in std::string gets reported as test failure.
std::set_new_handler(NewHandler);
// Override prefs for jsapi-tests.
JS::Prefs::setAtStartup_experimental_weakrefs_expose_cleanupSome(true);
JS::Prefs::setAtStartup_experimental_symbols_as_weakmap_keys(true);
if (options.runRuntimeTests) {
if (!JS_Init()) {
Die("JS_Init() failed.");
}
} else if (options.runFrontendTests) {
if (!JS_FrontendOnlyInit()) {
Die("JS_FrontendOnlyInit() failed.");
}
}
if (options.list) {
PrintTests(testList);
return 0;
}
RunTests(total, failures, options, testList);
MOZ_RELEASE_ASSERT(!JSRuntime::hasLiveRuntimes());
if (options.runRuntimeTests) {
JS_ShutDown();
} else if (options.runFrontendTests) {
JS_FrontendOnlyShutDown();
}
if (failures) {
printf("\n%d unexpected failure%s.\n", failures,
(failures == 1 ? "" : "s"));
return 1;
}
printf("\nPassed: ran %d tests.\n", total);
return 0;
}