chromium/v8/test/cctest/test-api.cc

// Copyright 2012 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
//       copyright notice, this list of conditions and the following
//       disclaimer in the documentation and/or other materials provided
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "test/cctest/test-api.h"

#include <climits>
#include <csignal>
#include <map>
#include <memory>
#include <optional>
#include <sstream>
#include <string>

#include "test/cctest/cctest.h"

#if V8_OS_POSIX
#include <unistd.h>
#endif

#include "include/v8-date.h"
#include "include/v8-extension.h"
#include "include/v8-fast-api-calls.h"
#include "include/v8-function.h"
#include "include/v8-initialization.h"
#include "include/v8-json.h"
#include "include/v8-locker.h"
#include "include/v8-primitive-object.h"
#include "include/v8-regexp.h"
#include "include/v8-util.h"
#include "src/api/api-inl.h"
#include "src/base/bounds.h"
#include "src/base/overflowing-math.h"
#include "src/base/platform/platform.h"
#include "src/base/strings.h"
#include "src/codegen/compilation-cache.h"
#include "src/common/globals.h"
#include "src/compiler/globals.h"
#include "src/execution/execution.h"
#include "src/execution/futex-emulation.h"
#include "src/execution/protectors-inl.h"
#include "src/handles/global-handles.h"
#include "src/heap/heap-inl.h"
#include "src/heap/incremental-marking.h"
#include "src/logging/metrics.h"
#include "src/objects/feedback-vector-inl.h"
#include "src/objects/feedback-vector.h"
#include "src/objects/hash-table-inl.h"
#include "src/objects/js-array-inl.h"
#include "src/objects/js-promise-inl.h"
#include "src/objects/lookup.h"
#include "src/objects/map-updater.h"
#include "src/objects/objects-inl.h"
#include "src/objects/string-inl.h"
#include "src/objects/synthetic-module-inl.h"
#include "src/profiler/cpu-profiler.h"
#include "src/utils/utils.h"
#include "test/cctest/heap/heap-tester.h"
#include "test/cctest/heap/heap-utils.h"
#include "test/common/flag-utils.h"
#include "test/common/streaming-helper.h"

#if V8_ENABLE_WEBASSEMBLY
#include "src/wasm/wasm-engine.h"
#include "test/cctest/wasm/wasm-run-utils.h"
#include "test/common/wasm/test-signatures.h"
#include "test/common/wasm/wasm-macro-gen.h"
#endif  // V8_ENABLE_WEBASSEMBLY

static const bool kLogThreading = …;

Array;
Boolean;
BooleanObject;
Context;
Extension;
External;
FixedArray;
Function;
FunctionTemplate;
HandleScope;
Local;
Maybe;
Message;
MessageCallback;
Module;
Name;
None;
Object;
ObjectTemplate;
Persistent;
PropertyAttribute;
Script;
String;
Symbol;
TryCatch;
Undefined;
V8;
Value;


#define THREADED_PROFILED_TEST …

void RunWithProfiler(void (*test)()) { … }


static int signature_callback_count;
static v8::Global<Value> signature_expected_receiver_global;
static void IncrementingSignatureCallback(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

static void Returns42(const v8::FunctionCallbackInfo<v8::Value>& info) { … }

THREADED_TEST(Handles) { … }


THREADED_TEST(IsolateOfContext) { … }

static void TestSignatureLooped(const char* operation, Local<Value> receiver,
                                v8::Isolate* isolate) { … }

static void TestSignatureOptimized(const char* operation, Local<Value> receiver,
                                   v8::Isolate* isolate) { … }

static void TestSignature(const char* operation, Local<Value> receiver,
                          v8::Isolate* isolate) { … }

THREADED_TEST(ReceiverSignature) { … }

namespace {

void DoNothingCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { … }

}  // namespace

// Regression test for issue chromium:1188563.
THREADED_TEST(Regress1188563) { … }

THREADED_TEST(HulIgennem) { … }


THREADED_TEST(Access) { … }

THREADED_TEST(AccessWithReceiver) { … }

THREADED_TEST(AccessElement) { … }


THREADED_TEST(Script) { … }


class TestResource: public String::ExternalStringResource { … };


class TestOneByteResource : public String::ExternalOneByteStringResource { … };

TEST(ScriptUsingStringResource) { … }

TEST(ScriptUsingOneByteStringResource) { … }

TEST(ScriptMakingExternalString) { … }

TEST(ScriptMakingExternalOneByteString) { … }

TEST(MakingExternalStringConditions) { … }


TEST(MakingExternalOneByteStringConditions) { … }


TEST(MakingExternalUnalignedOneByteString) { … }

THREADED_TEST(UsingExternalString) { … }


THREADED_TEST(UsingExternalOneByteString) { … }


class RandomLengthResource : public v8::String::ExternalStringResource { … };


class RandomLengthOneByteResource
    : public v8::String::ExternalOneByteStringResource { … };


THREADED_TEST(NewExternalForVeryLongString) { … }

TEST(ScavengeExternalString) { … }

TEST(ScavengeExternalOneByteString) { … }


class TestOneByteResourceWithDisposeControl : public TestOneByteResource { … };


int TestOneByteResourceWithDisposeControl::dispose_count = …;
int TestOneByteResourceWithDisposeControl::dispose_calls = …;


TEST(ExternalStringWithDisposeHandling) { … }


THREADED_TEST(StringConcat) { … }


THREADED_TEST(GlobalProperties) { … }


static void handle_callback_impl(const v8::FunctionCallbackInfo<Value>& info,
                                 i::Address callback) { … }


static void handle_callback(const v8::FunctionCallbackInfo<Value>& info) { … }


static void handle_callback_2(const v8::FunctionCallbackInfo<Value>& info) { … }

static void construct_callback(
    const v8::FunctionCallbackInfo<Value>& info) { … }

static void Return239Callback(Local<Name> name,
                              const v8::PropertyCallbackInfo<Value>& info) { … }

template<typename Handler>
static void TestFunctionTemplateInitializer(Handler handler,
                                            Handler handler_2) { … }

template<typename Constructor, typename Accessor>
static void TestFunctionTemplateAccessor(Constructor constructor,
                                         Accessor accessor) { … }


THREADED_PROFILED_TEST(FunctionTemplate) { … }

static void FunctionCallbackForProxyTest(
    const v8::FunctionCallbackInfo<Value>& info) { … }

THREADED_TEST(FunctionTemplateWithProxy) { … }

static void SimpleCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { … }


template<typename Callback>
static void TestSimpleCallback(Callback callback) { … }


THREADED_PROFILED_TEST(SimpleCallback) { … }


template<typename T>
void FastReturnValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info);

// constant return values
static int32_t fast_return_value_int32 = …;
static uint32_t fast_return_value_uint32 = …;
static const double kFastReturnValueDouble = …;
// variable return values
static bool fast_return_value_bool = …;
enum ReturnValueOddball { … };
static ReturnValueOddball fast_return_value_void;
static bool fast_return_value_object_is_empty = …;

// Helper function to avoid compiler error: insufficient contextual information
// to determine type when applying FUNCTION_ADDR to a template function.
static i::Address address_of(v8::FunctionCallback callback) { … }

template<>
void FastReturnValueCallback<int32_t>(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

template<>
void FastReturnValueCallback<uint32_t>(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

template<>
void FastReturnValueCallback<double>(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

template<>
void FastReturnValueCallback<bool>(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

template<>
void FastReturnValueCallback<void>(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

template<>
void FastReturnValueCallback<Object>(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

template <typename T>
Local<Value> TestFastReturnValues() { … }


THREADED_PROFILED_TEST(FastReturnValues) { … }


THREADED_TEST(FunctionTemplateSetLength) { … }


static void* expected_ptr;
static void callback(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


static void TestExternalPointerWrapping() { … }


THREADED_TEST(ExternalWrap) { … }


THREADED_TEST(FindInstanceInPrototypeChain) { … }

THREADED_TEST(FindInstanceInPrototypeChainWithProxy) { … }

THREADED_TEST(TinyInteger) { … }


THREADED_TEST(BigSmiInteger) { … }


THREADED_TEST(BigInteger) { … }


THREADED_TEST(TinyUnsignedInteger) { … }


THREADED_TEST(BigUnsignedSmiInteger) { … }


THREADED_TEST(BigUnsignedInteger) { … }


THREADED_TEST(OutOfSignedRangeUnsignedInteger) { … }


THREADED_TEST(IsNativeError) { … }


THREADED_TEST(IsGeneratorFunctionOrObject) { … }

THREADED_TEST(IsAsyncFunction) { … }

THREADED_TEST(ArgumentsObject) { … }


THREADED_TEST(IsMapOrSet) { … }


THREADED_TEST(StringObject) { … }


TEST(StringObjectDelete) { … }


THREADED_TEST(NumberObject) { … }

THREADED_TEST(BigIntObject) { … }

THREADED_TEST(BooleanObject) { … }


THREADED_TEST(PrimitiveAndWrappedBooleans) { … }


THREADED_TEST(Number) { … }


THREADED_TEST(ToNumber) { … }


THREADED_TEST(Date) { … }


THREADED_TEST(Boolean) { … }

static void DummyCallHandler(const v8::FunctionCallbackInfo<v8::Value>& info) { … }

static void GetM(Local<Name> name,
                 const v8::PropertyCallbackInfo<v8::Value>& info) { … }

THREADED_TEST(GlobalPrototype) { … }


THREADED_TEST(ObjectTemplate) { … }

THREADED_TEST(IntegerValue) { … }

static void GetNirk(Local<Name> name,
                    const v8::PropertyCallbackInfo<v8::Value>& info) { … }

static void GetRino(Local<Name> name,
                    const v8::PropertyCallbackInfo<v8::Value>& info) { … }

enum ObjectInstantiationMode { … };

// Test object instance creation using a function template with an instance
// template inherited from another function template with accessors and data
// properties in prototype template.
static void TestObjectTemplateInheritedWithPrototype(
    ObjectInstantiationMode mode) { … }

THREADED_TEST(TestObjectTemplateInheritedWithAccessorsInPrototype1) { … }

THREADED_TEST(TestObjectTemplateInheritedWithAccessorsInPrototype2) { … }

THREADED_TEST(TestObjectTemplateInheritedWithAccessorsInPrototype3) { … }

// Test object instance creation using a function template without an instance
// template inherited from another function template.
static void TestObjectTemplateInheritedWithoutInstanceTemplate(
    ObjectInstantiationMode mode) { … }

THREADED_TEST(TestDataTypeChecks) { … }

THREADED_TEST(TestObjectTemplateInheritedWithPrototype1) { … }

THREADED_TEST(TestObjectTemplateInheritedWithPrototype2) { … }

THREADED_TEST(TestObjectTemplateClassInheritance) { … }

namespace {
v8::Intercepted NamedPropertyGetterWhichReturns42(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }
}  // namespace

THREADED_TEST(TestObjectTemplateReflectConstruct) { … }

static void GetFlabby(const v8::FunctionCallbackInfo<v8::Value>& info) { … }

static void GetKnurd(Local<Name> property,
                     const v8::PropertyCallbackInfo<v8::Value>& info) { … }

THREADED_TEST(DescriptorInheritance) { … }

THREADED_TEST(DescriptorInheritance2) { … }


// Helper functions for Interceptor/Accessor interaction tests

void SimpleAccessorGetter(Local<String> name,
                          const v8::PropertyCallbackInfo<v8::Value>& info) { … }

void SimpleAccessorSetter(Local<String> name, Local<Value> value,
                          const v8::PropertyCallbackInfo<void>& info) { … }

void SymbolAccessorGetter(Local<Name> name,
                          const v8::PropertyCallbackInfo<v8::Value>& info) { … }

void SymbolAccessorSetter(Local<Name> name, Local<Value> value,
                          const v8::PropertyCallbackInfo<void>& info) { … }

void SymbolAccessorGetterReturnsDefault(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }

static void ThrowingSymbolAccessorGetter(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }


THREADED_TEST(AccessorIsPreservedOnAttributeChange) { … }


THREADED_TEST(UndefinedIsNotEnumerable) { … }

v8::Global<Script> call_recursively_script_global;
static const int kTargetRecursionDepth = …;  // near maximum

static void CallScriptRecursivelyCall(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


static void CallFunctionRecursivelyCall(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(DeepCrossLanguageRecursion) { … }

namespace {
v8::Intercepted ThrowingPropertyHandlerGet(
    Local<Name> key, const v8::PropertyCallbackInfo<v8::Value>& info) { … }

v8::Intercepted ThrowingPropertyHandlerSet(
    Local<Name> key, Local<Value>, const v8::PropertyCallbackInfo<void>& info) { … }
}  // namespace

THREADED_TEST(CallbackExceptionRegression) { … }


THREADED_TEST(FunctionPrototype) { … }

bool internal_field_check_called = …;
void OnInternalFieldCheck(const char* location, const char* message) { … }

// The fatal error handler would call exit() so this should not be run in
// parallel.
TEST(InternalDataFields) { … }

THREADED_TEST(InternalFields) { … }

TEST(InternalFieldsSubclassing) { … }

THREADED_TEST(InternalFieldsOfRegularObjects) { … }

// Allow usages of v8::Object::GetPrototype() for now.
// TODO(https://crbug.com/333672197): remove.
START_ALLOW_USE_DEPRECATED(…)

THREADED_TEST(GlobalObjectInternalFields) { … }

// Allow usages of v8::Object::GetPrototype() for now.
// TODO(https://crbug.com/333672197): remove.
END_ALLOW_USE_DEPRECATED(…)

THREADED_TEST(GlobalObjectHasRealIndexedProperty) { … }

static void CheckAlignedPointerInInternalField(Local<v8::Object> obj,
                                               void* value) { … }

THREADED_TEST(InternalFieldsAlignedPointers) { … }

THREADED_TEST(SetAlignedPointerInInternalFields) { … }

static void CheckAlignedPointerInEmbedderData(LocalContext* env,
                                              v8::Local<v8::Object> some_obj,
                                              int index, void* value) { … }

static void* AlignedTestPointer(int i) { … }


THREADED_TEST(EmbedderDataAlignedPointers) { … }

static void CheckEmbedderData(LocalContext* env, int index,
                              v8::Local<Value> data) { … }


THREADED_TEST(EmbedderData) { … }


THREADED_TEST(IdentityHash) { … }


void GlobalProxyIdentityHash(bool set_in_js) { … }


THREADED_TEST(GlobalProxyIdentityHash) { … }


TEST(SymbolIdentityHash) { … }


TEST(StringIdentityHash) { … }


THREADED_TEST(SymbolProperties) { … }


THREADED_TEST(SymbolTemplateProperties) { … }


THREADED_TEST(PrivatePropertiesOnProxies) { … }


THREADED_TEST(PrivateProperties) { … }


THREADED_TEST(GlobalSymbols) { … }

THREADED_TEST(GlobalSymbolsNoContext) { … }

static void CheckWellKnownSymbol(v8::Local<v8::Symbol>(*getter)(v8::Isolate*),
                                 const char* name) { … }


THREADED_TEST(WellKnownSymbols) { … }


THREADED_TEST(GlobalPrivates) { … }

THREADED_TEST(HiddenProperties) { … }


THREADED_TEST(Regress97784) { … }


THREADED_TEST(External) { … }


THREADED_TEST(GlobalHandle) { … }


THREADED_TEST(ResettingGlobalHandle) { … }


THREADED_TEST(ResettingGlobalHandleToEmpty) { … }


template <class T>
static v8::Global<T> PassUnique(v8::Global<T> unique) { … }


template <class T>
static v8::Global<T> ReturnUnique(v8::Isolate* isolate,
                                  const v8::Persistent<T>& global) { … }


THREADED_TEST(Global) { … }


namespace {

class TwoPassCallbackData;
void FirstPassCallback(const v8::WeakCallbackInfo<TwoPassCallbackData>& data);
void SecondPassCallback(const v8::WeakCallbackInfo<TwoPassCallbackData>& data);

struct GCCallbackMetadata { … };

class TwoPassCallbackData { … };


void SecondPassCallback(const v8::WeakCallbackInfo<TwoPassCallbackData>& data) { … }


void FirstPassCallback(const v8::WeakCallbackInfo<TwoPassCallbackData>& data) { … }

}  // namespace


TEST(TwoPassPhantomCallbacks) { … }


TEST(TwoPassPhantomCallbacksNestedGc) { … }

// The string creation API methods forbid executing JS code while they are
// on the stack. Make sure that when such a string creation triggers GC,
// the second pass callback can still execute JS as per its API contract.
TEST(TwoPassPhantomCallbacksTriggeredByStringAlloc) { … }

namespace {

void* IntKeyToVoidPointer(int key) { … }


Local<v8::Object> NewObjectForIntKey(
    v8::Isolate* isolate, const v8::Global<v8::ObjectTemplate>& templ,
    int key) { … }


template <typename K, typename V>
class PhantomStdMapTraits : public v8::StdMapTraits<K, V> { … };


template <typename Map>
void TestGlobalValueMap() { … }

}  // namespace


TEST(GlobalValueMap) { … }

TEST(VectorOfGlobals) { … }

THREADED_TEST(GlobalHandleUpcast) { … }


THREADED_TEST(HandleEquality) { … }

THREADED_TEST(HandleEqualityPrimitives) { … }

THREADED_TEST(LocalHandle) { … }


class WeakCallCounter { … };


template <typename T>
struct WeakCallCounterAndPersistent { … };


template <typename T>
static void WeakPointerCallback(
    const v8::WeakCallbackInfo<WeakCallCounterAndPersistent<T>>& data) { … }

THREADED_TEST(ScriptException) { … }

bool message_received;


static void check_message_0(v8::Local<v8::Message> message,
                            v8::Local<Value> data) { … }


THREADED_TEST(MessageHandler0) { … }


static void check_message_1(v8::Local<v8::Message> message,
                            v8::Local<Value> data) { … }


TEST(MessageHandler1) { … }


static void check_message_2(v8::Local<v8::Message> message,
                            v8::Local<Value> data) { … }


TEST(MessageHandler2) { … }


static void check_message_3(v8::Local<v8::Message> message,
                            v8::Local<Value> data) { … }


TEST(MessageHandler3) { … }


static void check_message_4(v8::Local<v8::Message> message,
                            v8::Local<Value> data) { … }


TEST(MessageHandler4) { … }


static void check_message_5a(v8::Local<v8::Message> message,
                             v8::Local<Value> data) { … }


static void check_message_5b(v8::Local<v8::Message> message,
                             v8::Local<Value> data) { … }


TEST(MessageHandler5) { … }

namespace {

// Verifies that after throwing an exception the message object is set up in
// some particular way by calling the supplied |tester| function. The tests that
// use this purposely test only a single getter as the getter updates the cached
// state of the object which could affect the results of other functions.
const char message_attributes_script[] = …;

void CheckMessageAttributes(std::function<void(v8::Local<v8::Context> context,
                                               v8::Local<v8::Message> message)>
                                tester) { … }

}  // namespace

TEST(MessageGetLineNumber) { … }

TEST(MessageGetStartColumn) { … }

TEST(MessageGetEndColumn) { … }

TEST(MessageGetStartPosition) { … }

TEST(MessageGetEndPosition) { … }

TEST(MessageGetSource) { … }

TEST(MessageGetSourceLine) { … }

TEST(GetStackTraceLimit) { … }

TEST(GetStackTraceLimitSetFromJS) { … }

TEST(GetStackTraceLimitSetNegativeFromJS) { … }

void GetCurrentStackTrace(const v8::FunctionCallbackInfo<v8::Value>& args) { … }

THREADED_TEST(MessagePrintCurrentStackTrace) { … }

THREADED_TEST(GetSetProperty) { … }


THREADED_TEST(PropertyAttributes) { … }

void ExpectArrayValues(std::vector<int> expected_values,
                       v8::Local<v8::Context> context,
                       v8::Local<v8::Array> array) { … }

THREADED_TEST(Array_New_Basic) { … }

THREADED_TEST(Array_New_FromVector) { … }

struct CreateElementFactory { … };

// static
size_t CreateElementFactory::abort_index = …;
size_t CreateElementFactory::current_index = …;

THREADED_TEST(Array_New_FromCallback_Success) { … }

THREADED_TEST(Array_New_FromCallback_Exception) { … }

void HandleF(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(Vector) { … }


THREADED_TEST(FunctionCall) { … }


THREADED_TEST(ConstructCall) { … }


THREADED_TEST(ConversionNumber) { … }


THREADED_TEST(isNumberType) { … }

THREADED_TEST(IntegerType) { … }

static void CheckUncle(v8::Isolate* isolate, v8::TryCatch* try_catch) { … }

THREADED_TEST(ConversionException) { … }


void ThrowFromC(const v8::FunctionCallbackInfo<v8::Value>& args) { … }

THREADED_TEST(APICatch) { … }


THREADED_TEST(APIThrowTryCatch) { … }

static void check_custom_error_tostring(v8::Local<v8::Message> message,
                                        v8::Local<v8::Value> data) { … }


TEST(CustomErrorToString) { … }


static void check_custom_error_message(v8::Local<v8::Message> message,
                                       v8::Local<v8::Value> data) { … }


TEST(CustomErrorMessage) { … }


static void check_custom_rethrowing_message(v8::Local<v8::Message> message,
                                            v8::Local<v8::Value> data) { … }


TEST(CustomErrorRethrowsOnToString) { … }

TEST(CustomErrorRethrowsOnToStringInsideVerboseTryCatch) { … }


static void receive_message(v8::Local<v8::Message> message,
                            v8::Local<v8::Value> data) { … }


TEST(APIThrowMessage) { … }


TEST(APIThrowMessageAndVerboseTryCatch) { … }


TEST(APIStackOverflowAndVerboseTryCatch) { … }


THREADED_TEST(ExternalScriptException) { … }


void CThrowCountDown(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


void JSCheck(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(EvalInTryFinally) { … }


// This test works by making a stack of alternating JavaScript and C
// activations.  These activations set up exception handlers with regular
// intervals, one interval for C activations and another for JavaScript
// activations.  When enough activations have been created an exception is
// thrown and we check that the right activation catches the exception and that
// no other activations do.  The right activation is always the topmost one with
// a handler, regardless of whether it is in JavaScript or C.
//
// The notation used to describe a test case looks like this:
//
//    *JS[4] *C[3] @JS[2] C[1] JS[0]
//
// Each entry is an activation, either JS or C.  The index is the count at that
// level.  Stars identify activations with exception handlers, the @ identifies
// the exception handler that should catch the exception.
//
// BUG(271): Some of the exception propagation does not work on the
// ARM simulator because the simulator separates the C++ stack and the
// JS stack.  This test therefore fails on the simulator.  The test is
// not threaded to allow the threading tests to run on the simulator.
TEST(ExceptionOrder) { … }


void ThrowValue(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(ThrowValues) { … }


THREADED_TEST(CatchZero) { … }


THREADED_TEST(CatchExceptionFromWith) { … }


THREADED_TEST(TryCatchAndFinallyHidingException) { … }


void WithTryCatch(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(TryCatchAndFinally) { … }

void TryCatchMixedNestingCheck(v8::TryCatch* try_catch) { … }


void TryCatchMixedNestingHelper(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


// This test ensures that an outer TryCatch in the following situation:
//   C++/TryCatch -> JS -> C++/TryCatch -> JS w/ SyntaxError
// does not clobber the Message object generated for the inner TryCatch.
// This exercises the ability of TryCatch.ReThrow() to restore the
// inner pending Message before throwing the exception again.
TEST(TryCatchMixedNesting) { … }


void TryCatchNativeHelper(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


TEST(TryCatchNative) { … }


void TryCatchNativeResetHelper(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


TEST(TryCatchNativeReset) { … }


THREADED_TEST(Equality) { … }

THREADED_TEST(TypeOf) { … }

THREADED_TEST(InstanceOf) { … }

THREADED_TEST(MultiRun) { … }


static void GetXValue(Local<Name> name,
                      const v8::PropertyCallbackInfo<v8::Value>& info) { … }


THREADED_TEST(SimplePropertyRead) { … }


THREADED_TEST(DefinePropertyOnAPIAccessor) { … }


THREADED_TEST(DefinePropertyOnDefineGetterSetter) { … }


static v8::Local<v8::Object> GetGlobalProperty(LocalContext* context,
                                               char const* name) { … }


THREADED_TEST(DefineAPIAccessorOnObject) { … }


THREADED_TEST(DontDeleteAPIAccessorsCannotBeOverriden) { … }


static void Get239Value(Local<Name> name,
                        const v8::PropertyCallbackInfo<v8::Value>& info) { … }


THREADED_TEST(ElementAPIAccessor) { … }


v8::Persistent<Value> xValue;


static void SetXValue(Local<Name> name, Local<Value> value,
                      const v8::PropertyCallbackInfo<void>& info) { … }


THREADED_TEST(SimplePropertyWrite) { … }


THREADED_TEST(SetterOnly) { … }


THREADED_TEST(NoAccessors) { … }


THREADED_TEST(MultiContexts) { … }


THREADED_TEST(FunctionPrototypeAcrossContexts) { … }


THREADED_TEST(Regress892105) { … }

static void ReturnThis(const v8::FunctionCallbackInfo<v8::Value>& args) { … }

THREADED_TEST(UndetectableObject) { … }


THREADED_TEST(VoidLiteral) { … }


THREADED_TEST(ExtensibleOnUndetectable) { … }

THREADED_TEST(ConstructCallWithUndetectable) { … }

static int increment_callback_counter = …;

static void IncrementCounterConstructCallback(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }

THREADED_TEST(SetCallAsFunctionHandlerConstructor) { … }
// The point of this test is type checking. We run it only so compilers
// don't complain about an unused function.
TEST(PersistentHandles) { … }


static void HandleLogDelegator(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(GlobalObjectTemplate) { … }


static const char* kSimpleExtensionSource = …;


TEST(SimpleExtensions) { … }


static const char* kStackTraceFromExtensionSource = …;


TEST(StackTraceInExtension) { … }


TEST(NullExtensions) { … }

static const char* kEmbeddedExtensionSource = …;
static const int kEmbeddedExtensionSourceValidLen = …;


TEST(ExtensionMissingSourceLength) { … }


TEST(ExtensionWithSourceLength) { … }


static const char* kEvalExtensionSource1 = …;


static const char* kEvalExtensionSource2 = …;


TEST(UseEvalFromExtension) { … }


static const char* kWithExtensionSource1 = …;


static const char* kWithExtensionSource2 = …;


TEST(UseWithFromExtension) { … }


TEST(AutoExtensions) { … }


static const char* kSyntaxErrorInExtensionSource = …;


// Test that a syntax error in an extension does not cause a fatal
// error but results in an empty context.
TEST(SyntaxErrorExtensions) { … }


static const char* kExceptionInExtensionSource = …;


// Test that an exception when installing an extension does not cause
// a fatal error but results in an empty context.
TEST(ExceptionExtensions) { … }

static const char* kNativeCallInExtensionSource = …;

static const char* kNativeCallTest = …;

// Test that a native runtime calls are supported in extensions.
TEST(NativeCallInExtensions) { … }


class NativeFunctionExtension : public Extension { … };


TEST(NativeFunctionDeclaration) { … }


TEST(NativeFunctionDeclarationError) { … }


TEST(NativeFunctionDeclarationErrorEscape) { … }


static void CheckDependencies(const char* name, const char* expected) { … }


/*
 * Configuration:
 *
 *     /-- B <--\
 * A <-          -- D <-- E
 *     \-- C <--/
 */
THREADED_TEST(ExtensionDependency) { … }


static const char* kExtensionTestScript = …;


static void CallFun(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


class FunctionExtension : public Extension { … };


static int lookup_count = …;
v8::Local<v8::FunctionTemplate> FunctionExtension::GetNativeFunctionTemplate(
    v8::Isolate* isolate, v8::Local<String> name) { … }


THREADED_TEST(FunctionLookup) { … }


THREADED_TEST(NativeFunctionConstructCall) { … }


static const char* last_location;
static const char* last_message;
void StoringErrorCallback(const char* location, const char* message) { … }


// ErrorReporting creates a circular extensions configuration and
// tests that the fatal error handler gets called.  This renders V8
// unusable and therefore this test cannot be run in parallel.
TEST(ErrorReporting) { … }

static size_t dcheck_count;
void DcheckErrorCallback(const char* file, int line, const char* message) { … }

TEST(DcheckErrorHandler) { … }

static void MissingScriptInfoMessageListener(v8::Local<v8::Message> message,
                                             v8::Local<Value> data) { … }


THREADED_TEST(ErrorWithMissingScriptInfo) { … }


struct FlagAndPersistent { … };

static void SetFlag(const v8::WeakCallbackInfo<FlagAndPersistent>& data) { … }

static void IndependentWeakHandle(bool global_gc, bool interlinked) { … }

TEST(IndependentWeakHandle) { … }

class Trivial { … };


class Trivial2 { … };

void CheckInternalFields(
    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) { … }

void InternalFieldCallback(bool global_gc) { … }

TEST(InternalFieldCallback) { … }

static void ResetUseValueAndSetFlag(
    const v8::WeakCallbackInfo<FlagAndPersistent>& data) { … }

void i::heap::HeapTester::ResetWeakHandle(bool global_gc) { … }

TEST(ResetWeakHandle) { … }

static void ForceMinorGC2(const v8::WeakCallbackInfo<FlagAndPersistent>& data) { … }

static void ForceMinorGC1(const v8::WeakCallbackInfo<FlagAndPersistent>& data) { … }

static void ForceFullGC2(const v8::WeakCallbackInfo<FlagAndPersistent>& data) { … }

static void ForceFullGC1(const v8::WeakCallbackInfo<FlagAndPersistent>& data) { … }

TEST(GCFromWeakCallbacks) { … }

static void ArgumentsTestCallback(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(Arguments) { … }

namespace {
int p_getter_count;
int p_getter_count2;

void PGetter(Local<Name> name,
             const v8::PropertyCallbackInfo<v8::Value>& info) { … }

void RunHolderTest(v8::Local<v8::ObjectTemplate> obj) { … }

v8::Intercepted PGetter2(Local<Name> name,
                         const v8::PropertyCallbackInfo<v8::Value>& info) { … }
}  // namespace

THREADED_TEST(GetterHolders) { … }


THREADED_TEST(PreInterceptorHolders) { … }


THREADED_TEST(ObjectInstantiation) { … }


static int StrCmp16(uint16_t* a, uint16_t* b) { … }


static int StrNCmp16(uint16_t* a, uint16_t* b, int n) { … }

int GetUtf8Length(v8::Isolate* isolate, Local<String> str) { … }


THREADED_TEST(StringWrite) { … }

static void Utf16Helper(LocalContext& context, const char* name,
                        const char* lengths_name, int len) { … }

void TestUtf8DecodingAgainstReference(
    v8::Isolate* isolate, const char* cases[],
    const std::vector<std::vector<uint16_t>>& unicode_expected) { … }

THREADED_TEST(OverlongSequencesAndSurrogates) { … }

THREADED_TEST(Utf16) { … }


static bool SameSymbol(Local<String> s1, Local<String> s2) { … }


THREADED_TEST(Utf16Symbol) { … }


THREADED_TEST(Utf16MissingTrailing) { … }

START_ALLOW_USE_DEPRECATED(…)

THREADED_TEST(Utf16Trailing3Byte_Value) { … }

END_ALLOW_USE_DEPRECATED(…)

THREADED_TEST(Utf16Trailing3Byte_ValueView) { … }

THREADED_TEST(ToArrayIndex) { … }

THREADED_TEST(ErrorConstruction) { … }

THREADED_TEST(ExceptionCreateMessageLength) { … }

static void YGetter(Local<Name> name,
                    const v8::PropertyCallbackInfo<v8::Value>& info) { … }

static void YSetter(Local<Name> name, Local<Value> value,
                    const v8::PropertyCallbackInfo<void>& info) { … }

THREADED_TEST(DeleteAccessor) { … }


static int trouble_nesting = …;
static void TroubleCallback(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


static int report_count = …;
static void ApiUncaughtExceptionTestListener(v8::Local<v8::Message>,
                                             v8::Local<Value>) { … }


// Counts uncaught exceptions, but other tests running in parallel
// also have uncaught exceptions.
TEST(ApiUncaughtException) { … }


static const char* script_resource_name = …;
static void ExceptionInNativeScriptTestListener(v8::Local<v8::Message> message,
                                                v8::Local<Value>) { … }


TEST(ExceptionInNativeScript) { … }


TEST(CompilationErrorUsingTryCatchHandler) { … }

// For use within the TestSecurityHandler() test.
static bool g_security_callback_result = …;
static bool SecurityTestCallback(Local<v8::Context> accessing_context,
                                 Local<v8::Object> accessed_object,
                                 Local<v8::Value> data) { … }


// SecurityHandler can't be run twice
TEST(SecurityHandler) { … }


THREADED_TEST(SecurityChecks) { … }


// Regression test case for issue 1183439.
THREADED_TEST(SecurityChecksForPrototypeChain) { … }


static bool security_check_with_gc_called;

static bool SecurityTestCallbackWithGC(Local<v8::Context> accessing_context,
                                       Local<v8::Object> accessed_object,
                                       Local<v8::Value> data) { … }


TEST(SecurityTestGCAllowed) { … }


THREADED_TEST(CrossDomainDelete) { … }


THREADED_TEST(CrossDomainPropertyIsEnumerable) { … }


THREADED_TEST(CrossDomainFor) { … }


THREADED_TEST(CrossDomainForInOnPrototype) { … }


TEST(ContextDetachGlobal) { … }


TEST(DetachGlobal) { … }


void GetThisX(const v8::FunctionCallbackInfo<v8::Value>& info) { … }


TEST(DetachedAccesses) { … }


static bool allowed_access = …;
static bool AccessBlocker(Local<v8::Context> accessing_context,
                          Local<v8::Object> accessed_object,
                          Local<v8::Value> data) { … }

static void UnreachableGetter(Local<Name> name,
                              const v8::PropertyCallbackInfo<v8::Value>& info) { … }

static void UnreachableSetter(Local<Name>, Local<Value>,
                              const v8::PropertyCallbackInfo<void>&) { … }

static void UnreachableFunction(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }


TEST(AccessControl) { … }


TEST(AccessControlES5) { … }

static bool AccessAlwaysBlocked(Local<v8::Context> accessing_context,
                                Local<v8::Object> global,
                                Local<v8::Value> data) { … }

static bool AccessAlwaysAllowed(Local<v8::Context> accessing_context,
                                Local<v8::Object> global,
                                Local<v8::Value> data) { … }

TEST(Regress470113) { … }

THREADED_TEST(CrossDomainAccessors) { … }


static int access_count = …;

static bool AccessCounter(Local<v8::Context> accessing_context,
                          Local<v8::Object> accessed_object,
                          Local<v8::Value> data) { … }


// This one is too easily disturbed by other tests.
TEST(AccessControlIC) { … }


THREADED_TEST(Version) { … }


static void InstanceFunctionCallback(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(InstanceProperties) { … }

namespace {
v8::Intercepted GlobalObjectInstancePropertiesGet(
    Local<Name> key, const v8::PropertyCallbackInfo<v8::Value>& info) { … }

int script_execution_count = …;
void ScriptExecutionCallback(v8::Isolate* isolate, Local<Context> context) { … }
}  // namespace

THREADED_TEST(ContextScriptExecutionCallback) { … }

THREADED_TEST(GlobalObjectInstanceProperties) { … }

THREADED_TEST(ObjectGetOwnPropertyNames) { … }

THREADED_TEST(CallKnownGlobalReceiver) { … }

namespace {
void ShadowFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& args) { … }

int shadow_y;
int shadow_y_setter_call_count;
int shadow_y_getter_call_count;

void ShadowYSetter(Local<Name>, Local<Value>,
                   const v8::PropertyCallbackInfo<void>& info) { … }

void ShadowYGetter(Local<Name> name,
                   const v8::PropertyCallbackInfo<v8::Value>& info) { … }

v8::Intercepted ShadowIndexedGet(
    uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) { … }

v8::Intercepted ShadowNamedGet(
    Local<Name> key, const v8::PropertyCallbackInfo<v8::Value>& info) { … }
}  // namespace

THREADED_TEST(ShadowObject) { … }

THREADED_TEST(ShadowObjectAndDataProperty) { … }

THREADED_TEST(ShadowObjectAndDataPropertyTurbo) { … }

THREADED_TEST(SetPrototype) { … }


// Getting property names of an object with a prototype chain that
// triggers dictionary elements in GetOwnPropertyNames() shouldn't
// crash the runtime.
THREADED_TEST(Regress91517) { … }


THREADED_TEST(FunctionReadOnlyPrototype) { … }


THREADED_TEST(SetPrototypeThrows) { … }


THREADED_TEST(FunctionRemovePrototype) { … }


THREADED_TEST(GetterSetterExceptions) { … }


THREADED_TEST(Constructor) { … }


THREADED_TEST(FunctionDescriptorException) { … }


THREADED_TEST(EvalAliasedDynamic) { … }


THREADED_TEST(CrossEval) { … }


// Test that calling eval in a context which has been detached from
// its global proxy works.
THREADED_TEST(EvalInDetachedGlobal) { … }


THREADED_TEST(CrossLazyLoad) { … }


static void call_as_function(const v8::FunctionCallbackInfo<v8::Value>& args) { … }


// Test that a call handler can be set for objects which will allow
// non-function objects created through the API to be called as
// functions.
THREADED_TEST(CallAsFunction) { … }


// Check whether a non-function object is callable.
THREADED_TEST(CallableObject) { … }


THREADED_TEST(Regress567998) { … }


static int Recurse(v8::Isolate* isolate, int depth, int iterations) { … }


THREADED_TEST(HandleIteration) { … }

namespace {
v8::Intercepted InterceptorCallICFastApi(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }

void FastApiCallback_TrivialSignature(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

// Allow usages of v8::Object::GetPrototype() for now.
// TODO(https://crbug.com/333672197): remove.
START_ALLOW_USE_DEPRECATED(…)

void FastApiCallback_SimpleSignature(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

// Allow usages of v8::Object::GetPrototype() for now.
// TODO(https://crbug.com/333672197): remove.
END_ALLOW_USE_DEPRECATED(…)

// Helper to maximize the odds of object moving.
void GenerateSomeGarbage() { … }

void DirectApiCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { … }
}  // namespace

THREADED_TEST(CallICFastApi_DirectCall_GCMoveStub) { … }

void ThrowingDirectApiCallback(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }

THREADED_TEST(CallICFastApi_DirectCall_Throw) { … }

namespace {
int p_getter_count_3;

Local<Value> DoDirectGetter() { … }

void DirectGetterCallback(Local<Name> name,
                          const v8::PropertyCallbackInfo<v8::Value>& info) { … }

template <typename Accessor>
void LoadICFastApi_DirectCall_GCMoveStub(Accessor accessor) { … }
}  // namespace

THREADED_PROFILED_TEST(LoadICFastApi_DirectCall_GCMoveStub) { … }

void ThrowingDirectGetterCallback(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }

THREADED_TEST(LoadICFastApi_DirectCall_Throw) { … }

THREADED_PROFILED_TEST(InterceptorCallICFastApi_TrivialSignature) { … }

THREADED_PROFILED_TEST(CallICFastApi_TrivialSignature) { … }

static void ThrowingGetter(Local<Name> name,
                           const v8::PropertyCallbackInfo<v8::Value>& info) { … }

THREADED_TEST(VariousGetPropertiesAndThrowingCallbacks) { … }

THREADED_TEST(GetRealNamedPropertyAttributes_With_Proxy) { … }

static void ThrowingCallbackWithTryCatch(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


static int call_depth;


static void WithTryCatch(Local<Message> message, Local<Value> data) { … }


static void ThrowFromJS(Local<Message> message, Local<Value> data) { … }


static void ThrowViaApi(Local<Message> message, Local<Value> data) { … }


static void WebKitLike(Local<Message> message, Local<Value> data) { … }


THREADED_TEST(ExceptionsDoNotPropagatePastTryCatch) { … }

static void ParentGetter(Local<Name> name,
                         const v8::PropertyCallbackInfo<v8::Value>& info) { … }

static void ChildGetter(Local<Name> name,
                        const v8::PropertyCallbackInfo<v8::Value>& info) { … }

THREADED_TEST(Overriding) { … }

namespace {
void ShouldThrowOnErrorAccessorGetter(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }

void ShouldThrowOnErrorAccessorSetter(
    Local<Name> name, Local<v8::Value> value,
    const v8::PropertyCallbackInfo<void>& info) { … }
}  // namespace

THREADED_TEST(AccessorShouldThrowOnError) { … }

namespace {
v8::Intercepted ShouldThrowOnErrorGetter(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }

v8::Intercepted ShouldThrowOnErrorSetter(
    Local<Name> name, Local<v8::Value> value,
    const v8::PropertyCallbackInfo<void>& info) { … }

v8::Intercepted ShouldThrowOnErrorQuery(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Integer>& info) { … }

v8::Intercepted ShouldThrowOnErrorDeleter(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Boolean>& info) { … }

void ShouldThrowOnErrorPropertyEnumerator(
    const v8::PropertyCallbackInfo<v8::Array>& info) { … }
}  // namespace

THREADED_TEST(InterceptorShouldThrowOnError) { … }

static void EmptyHandler(const v8::FunctionCallbackInfo<v8::Value>& args) { … }

TEST(CallHandlerHasNoSideEffect) { … }

TEST(FunctionTemplateNewHasNoSideEffect) { … }

TEST(FunctionTemplateNewWithCacheHasNoSideEffect) { … }

TEST(FunctionNewHasNoSideEffect) { … }

// These handlers instantiate a function the embedder considers safe in some
// cases (e.g. "building object wrappers"), but those functions themselves were
// not explicitly marked as side-effect-free.
static void DefaultConstructHandler(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

static void NoSideEffectConstructHandler(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

static void NoSideEffectAndSideEffectConstructHandler(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }

TEST(FunctionNewInstanceHasNoSideEffect) { … }

TEST(CallHandlerAsFunctionHasNoSideEffectNotSupported) { … }

static void IsConstructHandler(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }


THREADED_TEST(IsConstructCall) { … }

static void NewTargetHandler(const v8::FunctionCallbackInfo<v8::Value>& args) { … }

THREADED_TEST(NewTargetHandler) { … }

THREADED_TEST(ObjectProtoToString) { … }


TEST(ObjectProtoToStringES6) { … }

namespace {

void CheckGetConstructorNameOfVar(LocalContext& context, const char* var_name,
                                  const char* constructor_name) { … }

}  // namespace

THREADED_TEST(ObjectGetConstructorName) { … }


THREADED_TEST(SubclassGetConstructorName) { … }

UNINITIALIZED_TEST(SharedObjectGetConstructorName) { … }

unsigned ApiTestFuzzer::linear_congruential_generator;
std::vector<std::unique_ptr<ApiTestFuzzer>> ApiTestFuzzer::fuzzers_;
bool ApiTestFuzzer::fuzzing_ = …;
v8::base::Semaphore ApiTestFuzzer::all_tests_done_(0);
int ApiTestFuzzer::tests_being_run_;
int ApiTestFuzzer::active_tests_;
int ApiTestFuzzer::current_fuzzer_;

// We are in a callback and want to switch to another thread (if we
// are currently running the thread fuzzing test).
void ApiTestFuzzer::Fuzz() { … }


// Let the next thread go.  Since it is also waiting on the V8 lock it may
// not start immediately.
bool ApiTestFuzzer::NextThread() { … }void ApiTestFuzzer::Run() { … }void ApiTestFuzzer::SetUp(PartOfTest part) { … }void ApiTestFuzzer::RunAllTests() { … }int ApiTestFuzzer::GetNextFuzzer() { … }void ApiTestFuzzer::ContextSwitch() { … }void ApiTestFuzzer::TearDown() { … }void ApiTestFuzzer::CallTest() { … }#define THREADING_TEST …THREADING_TEST …THREADING_TEST …THREADING_TEST …THREADING_TEST …THREADING_TEST …THREADING_TEST …THREADING_TEST …THREADING_TEST …#undef THREADING_TESTstatic void ThrowInJS(const v8::FunctionCallbackInfo<v8::Value>& args) { … }static void ThrowInJSNoCatch(const v8::FunctionCallbackInfo<v8::Value>& args) { … }TEST(NestedLockers) { … }TEST(NestedLockersNoTryCatch) { … }THREADED_TEST(RecursiveLocking) { … }static void UnlockForAMoment(const v8::FunctionCallbackInfo<v8::Value>& args) { … }THREADED_TEST(LockUnlockLock) { … }static int GetGlobalObjectsCount() { … }static void CheckSurvivingGlobalObjectsCount(int expected) { … }TEST(DontLeakGlobalObjects) { … }static void WeakApiCallback(
    const v8::WeakCallbackInfo<Persistent<v8::Object>>& data) { … }TEST(WeakCallbackApi) { … }v8::Persistent<v8::Object> some_objectv8::Persistent<v8::Object> bad_handlevoid NewPersistentHandleCallback2(
    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) { … }void NewPersistentHandleCallback1(
    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) { … }TEST(NewPersistentHandleFromWeakCallback) { … }v8::Persistent<v8::Object> to_be_disposedvoid DisposeAndForceGcCallback2(
    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) { … }void DisposeAndForceGcCallback1(
    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) { … }TEST(DoNotUseDeletedNodesInSecondLevelGc) { … }void DisposingCallback(
    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) { … }void HandleCreatingCallback2(
    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) { … }void HandleCreatingCallback1(
    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) { … }TEST(NoGlobalHandlesOrphaningDueToWeakCallback) { … }THREADED_TEST(CheckForCrossContextObjectLiterals) { … }static v8::Local<Value> NestedScope(v8::Local<Context> env) { … }THREADED_TEST(NestedHandleScopeAndContexts) { … }static v8::base::HashMap* instruction_stream_map = …static v8::base::HashMap* jitcode_line_info = …static int saw_bar = …static int move_events = …static bool FunctionNameIs(const char* expected,
                           const v8::JitCodeEvent* event) { … }static void event_handler(const v8::JitCodeEvent* event) { … }UNINITIALIZED_TEST(SetJitCodeEventHandler) { … }#if V8_ENABLE_WEBASSEMBLYstatic bool saw_wasm_main = …static void wasm_event_handler(const v8::JitCodeEvent* event) { … }TEST(WasmSetJitCodeEventHandler) { … }#endif  // V8_ENABLE_WEBASSEMBLYTEST(ExternalAllocatedMemory) { … }TEST(Regress51719) { … }THREADED_TEST(Regress54) { … }TEST(CatchStackOverflow) { … }static void CheckTryCatchSourceInfo(v8::Local<v8::Script> script,
                                    const char* resource_name,
                                    int line_offset) { … }THREADED_TEST(TryCatchSourceInfo) { … }THREADED_TEST(TryCatchSourceInfoForEOSError) { … }THREADED_TEST(CompilationCache) { … }static void FunctionNameCallback(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }THREADED_TEST(CallbackFunctionName) { … }THREADED_TEST(DateAccess) { … }void CheckIsSymbolAt(v8::Isolate* isolate, v8::Local<v8::Array> properties,
                     unsigned index, const char* name) { … }void CheckStringArray(v8::Isolate* isolate, v8::Local<v8::Array> properties,
                      unsigned length, const char* names[]) { … }void CheckProperties(v8::Isolate* isolate, v8::Local<v8::Value> val,
                     unsigned length, const char* names[]) { … }void CheckOwnProperties(v8::Isolate* isolate, v8::Local<v8::Value> val,
                        unsigned elmc, const char* elmv[]) { … }THREADED_TEST(PropertyEnumeration) { … }THREADED_TEST(PropertyEnumeration2) { … }THREADED_TEST(GetPropertyNames) { … }THREADED_TEST(ProxyGetPropertyNames) { … }THREADED_TEST(ProxyGetPropertyNamesWithOwnKeysTrap) { … }THREADED_TEST(AccessChecksReenabledCorrectly) { … }THREADED_TEST(DictionaryICLoadedFunction) { … }THREADED_TEST(CrossContextNew) { … }TEST(ObjectClone) { … }class OneByteVectorResource : public v8::String::ExternalOneByteStringResource { … }class UC16VectorResource : public v8::String::ExternalStringResource { … }static void MorphAString(i::Tagged<i::String> string,
                         OneByteVectorResource* one_byte_resource,
                         UC16VectorResource* uc16_resource) { … }THREADED_TEST(MorphCompositeStringTest) { … }TEST(CompileExternalTwoByteSource) { … }TEST(ReadOnlyPropertyInGlobalProto) { … }TEST(CreateDataProperty) { … }TEST(DefineOwnProperty) { … }TEST(DefineProperty) { … }THREADED_TEST(GetCurrentContextWhenNotInContext) { … }THREADED_TEST(InitGlobalVarInProtoChain) { … }THREADED_TEST(ReplaceConstantFunction) { … }THREADED_TEST(ScriptContextDependence) { … }#if V8_ENABLE_WEBASSEMBLYstatic int asm_warning_triggered = …static void AsmJsWarningListener(v8::Local<v8::Message> message,
                                 v8::Local<Value>) { … }TEST(AsmJsWarning) { … }#endif  // V8_ENABLE_WEBASSEMBLYstatic int error_level_message_count = …static int expected_error_level = …static void ErrorLevelListener(v8::Local<v8::Message> message,
                               v8::Local<Value>) { … }TEST(ErrorLevelWarning) { … }v8::PromiseRejectEvent reject_event = …int promise_reject_counter = …int promise_revoke_counter = …int promise_reject_after_resolved_counter = …int promise_resolve_after_resolved_counter = …int promise_reject_msg_line_number = …int promise_reject_msg_column_number = …int promise_reject_line_number = …int promise_reject_column_number = …int promise_reject_frame_count = …bool promise_reject_is_shared_cross_origin = …void PromiseRejectCallback(v8::PromiseRejectMessage reject_message) { … }v8::Local<v8::Promise> GetPromise(const char* name) { … }v8::Local<v8::Value> RejectValue() { … }void ResetPromiseStates() { … }TEST(PromiseRejectCallback) { … }TEST(PromiseRejectIsSharedCrossOrigin) { … }TEST(PromiseRejectMarkAsHandled) { … }void PromiseRejectCallbackConstructError(
    v8::PromiseRejectMessage reject_message) { … }TEST(PromiseRejectCallbackConstructError) { … }void SetPromise(const char* name, v8::Local<v8::Promise> promise) { … }class PromiseHookData { … }PromiseHookData* promise_hook_datavoid CustomPromiseHook(v8::PromiseHookType type, v8::Local<v8::Promise> promise,
                       v8::Local<v8::Value> parentPromise) { … }TEST(PromiseHook) { … }TEST(EvalWithSourceURLInMessageScriptResourceNameOrSourceURL) { … }TEST(RecursionWithSourceURLInMessageScriptResourceNameOrSourceURL) { … }TEST(Regress2333) { … }static uint32_t* stack_limitstatic void GetStackLimitCallback(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }static uint32_t* ComputeStackLimit(uint32_t size) { … }static const int stack_breathing_room = …TEST(SetStackLimit) { … }TEST(SetStackLimitInThread) { … }THREADED_TEST(GetHeapStatistics) { … }TEST(GetHeapSpaceStatistics) { … }TEST(NumberOfNativeContexts) { … }TEST(NumberOfDetachedContexts) { … }TEST(ExternalizeOldSpaceTwoByteCons) { … }TEST(ExternalizeOldSpaceOneByteCons) { … }TEST(ExternalStringCollectedAtTearDown) { … }TEST(ExternalInternalizedStringCollectedAtTearDown) { … }TEST(ExternalInternalizedStringCollectedAtGC) { … }static double DoubleFromBits(uint64_t value) { … }static uint64_t DoubleToBits(double value) { … }static double DoubleToDateTime(double input) { … }static double DoubleFromBits(uint32_t high_bits, uint32_t low_bits) { … }THREADED_TEST(QuietSignalingNaNs) { … }static void SpaghettiIncident(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }THREADED_TEST(SpaghettiStackReThrow) { … }TEST(Regress528) { … }THREADED_TEST(ScriptOrigin) { … }THREADED_TEST(FunctionGetInferredName) { … }THREADED_TEST(FunctionGetDebugName) { … }THREADED_TEST(ScriptLineNumber) { … }THREADED_TEST(ScriptColumnNumber) { … }THREADED_TEST(ScriptStartPosition) { … }THREADED_TEST(FunctionGetScriptId) { … }THREADED_TEST(FunctionGetBoundFunction) { … }THREADED_TEST(FunctionProtoToString) { … }static void GetterWhichReturns42(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }static void SetterWhichSetsYOnThisTo23(
    Local<Name> name, Local<Value> value,
    const v8::PropertyCallbackInfo<void>& info) { … }v8::Intercepted FooGetInterceptor(
    Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … }v8::Intercepted FooSetInterceptor(Local<Name> name, Local<Value> value,
                                  const v8::PropertyCallbackInfo<void>& info) { … }TEST(SetterOnConstructorPrototype) { … }v8::Intercepted NamedPropertySetterWhichSetsYOnThisTo23(
    Local<Name> name, Local<Value> value,
    const v8::PropertyCallbackInfo<void>& info) { … }THREADED_TEST(InterceptorOnConstructorPrototype) { … }TEST(Regress618) { … }v8::Isolate* gc_callbacks_isolate = …int prologue_call_count = …int epilogue_call_count = …int prologue_call_count_second = …int epilogue_call_count_second = …int prologue_call_count_alloc = …int epilogue_call_count_alloc = …void PrologueCallback(v8::Isolate* isolate,
                      v8::GCType,
                      v8::GCCallbackFlags flags) { … }void EpilogueCallback(v8::Isolate* isolate,
                      v8::GCType,
                      v8::GCCallbackFlags flags) { … }void PrologueCallbackSecond(v8::Isolate* isolate,
                            v8::GCType,
                            v8::GCCallbackFlags flags) { … }void EpilogueCallbackSecond(v8::Isolate* isolate,
                            v8::GCType,
                            v8::GCCallbackFlags flags) { … }void PrologueCallbackNew(v8::Isolate* isolate, v8::GCType,
                         v8::GCCallbackFlags flags, void* data) { … }void EpilogueCallbackNew(v8::Isolate* isolate, v8::GCType,
                         v8::GCCallbackFlags flags, void* data) { … }TEST(GCCallbacksOld) { … }TEST(GCCallbacksWithData) { … }TEST(ContainsOnlyOneByte) { … }void FailedAccessCheckCallbackGC(Local<v8::Object> target,
                                 v8::AccessType type,
                                 Local<v8::Value> data) { … }TEST(GCInFailedAccessCheckCallback) { … }TEST(IsolateNewDispose) { … }UNINITIALIZED_TEST(DisposeIsolateWhenInUse) { … }static void BreakArrayGuarantees(const char* script) { … }TEST(VerifyArrayPrototypeGuarantees) { … }TEST(RunTwoIsolatesOnSingleThread) { … }static int CalcFibonacci(v8::Isolate* isolate, int limit) { … }class IsolateThread : public v8::base::Thread { … }TEST(MultipleIsolatesOnIndividualThreads) { … }TEST(IsolateDifferentContexts) { … }class InitDefaultIsolateThread : public v8::base::Thread { … }static void InitializeTestHelper(InitDefaultIsolateThread::TestCase testCase) { … }TEST(InitializeDefaultIsolateOnSecondaryThread_FatalHandler) { … }TEST(InitializeDefaultIsolateOnSecondaryThread_CounterFunction) { … }TEST(InitializeDefaultIsolateOnSecondaryThread_CreateHistogramFunction) { … }TEST(InitializeDefaultIsolateOnSecondaryThread_AddHistogramSampleFunction) { … }TEST(StringCheckMultipleContexts) { … }TEST(NumberCheckMultipleContexts) { … }TEST(BooleanCheckMultipleContexts) { … }TEST(DontDeleteCellLoadIC) { … }TEST(WrapperClassId) { … }TEST(RegExp) { … }START_ALLOW_USE_DEPRECATED(…)THREADED_TEST(Equals) { … }END_ALLOW_USE_DEPRECATED(…)v8::Intercepted Getter(v8::Local<v8::Name> property,
                       const v8::PropertyCallbackInfo<v8::Value>& info) { … }void Enumerator(const v8::PropertyCallbackInfo<v8::Array>& info) { … }TEST(NamedEnumeratorAndForIn) { … }TEST(DefinePropertyPostDetach) { … }static void InstallContextId(v8::Local<Context> context, int id) { … }static void CheckContextId(v8::Local<Object> object, int expected) { … }THREADED_TEST(CreationContext) { … }THREADED_TEST(CreationContextOfJsFunction) { … }THREADED_TEST(CreationContextOfJsBoundFunction) { … }v8::Intercepted HasOwnPropertyIndexedPropertyGetter(
    uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) { … }v8::Intercepted HasOwnPropertyNamedPropertyGetter(
    Local<Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) { … }v8::Intercepted HasOwnPropertyIndexedPropertyQuery(
    uint32_t index, const v8::PropertyCallbackInfo<v8::Integer>& info) { … }v8::Intercepted HasOwnPropertyNamedPropertyQuery(
    Local<Name> property, const v8::PropertyCallbackInfo<v8::Integer>& info) { … }v8::Intercepted HasOwnPropertyNamedPropertyQuery2(
    Local<Name> property, const v8::PropertyCallbackInfo<v8::Integer>& info) { … }void HasOwnPropertyAccessorGetter(
    Local<Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) { … }v8::Intercepted HasOwnPropertyAccessorNameGetter(
    Local<Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) { … }TEST(HasOwnProperty) { … }TEST(IndexedInterceptorWithStringProto) { … }void CheckCodeGenerationAllowed() { … }void CheckCodeGenerationDisallowed() { … }char first_fourty_bytes[41]v8::ModifyCodeGenerationFromStringsResult CodeGenerationAllowed(
    Local<Context> context, Local<Value> source, bool is_code_like) { … }v8::ModifyCodeGenerationFromStringsResult CodeGenerationDisallowed(
    Local<Context> context, Local<Value> source, bool is_code_like) { … }v8::ModifyCodeGenerationFromStringsResult ModifyCodeGeneration(
    Local<Context> context, Local<Value> source, bool is_code_like) { … }THREADED_TEST(AllowCodeGenFromStrings) { … }TEST(ModifyCodeGenFromStrings) { … }v8::ModifyCodeGenerationFromStringsResult RejectStringsIncrementNumbers(
    Local<Context> context, Local<Value> source, bool is_code_like) { … }TEST(AllowFromStringsOrModifyCodegen) { … }TEST(SetErrorMessageForCodeGenFromStrings) { … }TEST(CaptureSourceForCodeGenFromStrings) { … }static void NonObjectThis(const v8::FunctionCallbackInfo<v8::Value>& args) { … }THREADED_TEST(CallAPIFunctionOnNonObject) { … }THREADED_TEST(ReadOnlyIndexedProperties) { … }static int CountLiveMapsInMapCache(i::Tagged<i::Context> context) { … }TEST(Regress1516) { … }static void TestReceiver(Local<Value> expected_result,
                         Local<Value> expected_receiver,
                         const char* code) { … }THREADED_TEST(ForeignFunctionReceiver) { … }uint8_t callback_fired = …uint8_t before_call_entered_callback_count1 = …uint8_t before_call_entered_callback_count2 = …void CallCompletedCallback1(v8::Isolate*) { … }void CallCompletedCallback2(v8::Isolate*) { … }void BeforeCallEnteredCallback1(v8::Isolate*) { … }void BeforeCallEnteredCallback2(v8::Isolate*) { … }void RecursiveCall(const v8::FunctionCallbackInfo<v8::Value>& args) { … }TEST(CallCompletedCallback) { … }void CallCompletedCallbackNoException(v8::Isolate*) { … }void CallCompletedCallbackException(v8::Isolate*) { … }TEST(CallCompletedCallbackOneException) { … }TEST(CallCompletedCallbackTwoExceptions) { … }static void MicrotaskOne(const v8::FunctionCallbackInfo<Value>& info) { … }static void MicrotaskTwo(const v8::FunctionCallbackInfo<Value>& info) { … }void* g_passed_to_three = …static void MicrotaskThree(void* data) { … }TEST(EnqueueMicrotask) { … }static void MicrotaskExceptionOne(
    const v8::FunctionCallbackInfo<Value>& info) { … }static void MicrotaskExceptionTwo(
    const v8::FunctionCallbackInfo<Value>& info) { … }int handler_call_count = …static void MicrotaskExceptionHandler(Local<Message> message,
                                      Local<Value> exception) { … }TEST(RunMicrotasksIgnoresThrownExceptions) { … }static void ThrowExceptionMicrotask(void* data) { … }int microtask_callback_count = …static void IncrementCounterMicrotask(void* data) { … }TEST(RunMicrotasksIgnoresThrownExceptionsFromApi) { … }uint8_t microtasks_completed_callback_count = …static void MicrotasksCompletedCallback(v8::Isolate* isolate, void*) { … }static void MicrotasksCompletedCallbackCallScript(v8::Isolate* isolate, void*) { … }TEST(SetAutorunMicrotasks) { … }TEST(RunMicrotasksWithoutEnteringContext) { … }static void Regress808911_MicrotaskCallback(void* data) { … }static void Regress808911_CurrentContextWrapper(
    const v8::FunctionCallbackInfo<Value>& info) { … }THREADED_TEST(Regress808911) { … }TEST(ScopedMicrotasks) { … }void AssertCowElements(bool expected, const char* source) { … }TEST(CheckCOWArraysCreatedRuntimeCounter) { … }TEST(StaticGetters) { … }UNINITIALIZED_TEST(IsolateEmbedderData) { … }TEST(StringEmpty) { … }THREADED_TEST(CheckIsLeafTemplateForApiObject) { … }static void Helper137002(bool do_store,
                         bool polymorphic,
                         bool remove_accessor,
                         bool interceptor) { … }THREADED_TEST(Regress137002a) { … }THREADED_TEST(Regress137002b) { … }THREADED_TEST(Regress142088) { … }THREADED_TEST(Regress137496) { … }THREADED_TEST(Regress157124) { … }THREADED_TEST(Regress2535) { … }THREADED_TEST(Regress2746) { … }THREADED_TEST(Regress260106) { … }THREADED_TEST(JSONParseObject) { … }THREADED_TEST(JSONParseNumber) { … }void TestJSONParseArray(Local<Context> context, const char* input_str,
                        const char* expected_output_str,
                        i::ElementsKind expected_elements_kind) { … }THREADED_TEST(JSONParseArray) { … }THREADED_TEST(JSONStringifyObject) { … }THREADED_TEST(JSONStringifyObjectWithGap) { … }#if V8_OS_POSIXclass ThreadInterruptTest { … }THREADED_TEST(SemaphoreInterruption) { … }#endif  // V8_OS_POSIXvoid UnreachableCallback(const v8::FunctionCallbackInfo<v8::Value>& args) { … }TEST(JSONStringifyAccessCheck) { … }bool access_check_fail_thrown = …bool catch_callback_called = …void FailedAccessCheckThrows(Local<v8::Object> target,
                             v8::AccessType type,
                             Local<v8::Value> data) { … }void CatcherCallback(const v8::FunctionCallbackInfo<v8::Value>& args) { … }void HasOwnPropertyCallback(const v8::FunctionCallbackInfo<v8::Value>& args) { … }void CheckCorrectThrow(const char* script) { … }TEST(AccessCheckThrows) { … }class RequestInterruptTestBase { … }class RequestInterruptTestBaseWithSimpleInterrupt
    : public RequestInterruptTestBase { … }class RequestInterruptTestWithFunctionCall
    : public RequestInterruptTestBaseWithSimpleInterrupt { … }class RequestInterruptTestWithMethodCall
    : public RequestInterruptTestBaseWithSimpleInterrupt { … }class RequestInterruptTestWithAccessor
    : public RequestInterruptTestBaseWithSimpleInterrupt { … }class RequestInterruptTestWithNativeAccessor
    : public RequestInterruptTestBaseWithSimpleInterrupt { … }class RequestInterruptTestWithMethodCallAndInterceptor
    : public RequestInterruptTestBaseWithSimpleInterrupt { … }class RequestInterruptTestWithMathAbs
    : public RequestInterruptTestBaseWithSimpleInterrupt { … }TEST(RequestInterruptTestWithFunctionCall) { … }TEST(RequestInterruptTestWithMethodCall) { … }TEST(RequestInterruptTestWithAccessor) { … }TEST(RequestInterruptTestWithNativeAccessor) { … }TEST(RequestInterruptTestWithMethodCallAndInterceptor) { … }TEST(RequestInterruptTestWithMathAbs) { … }class RequestMultipleInterrupts : public RequestInterruptTestBase { … }TEST(RequestMultipleInterrupts) { … }static bool interrupt_was_called = …void SmallScriptsInterruptCallback(v8::Isolate* isolate, void* data) { … }TEST(RequestInterruptSmallScripts) { … }static v8::Global<Value> function_new_expected_env_globalstatic void FunctionNewCallback(const v8::FunctionCallbackInfo<Value>& info) { … }THREADED_TEST(FunctionNew) { … }void Verify(v8::Isolate* isolate, Local<v8::Object> obj) { … }THREADED_TEST(ObjectNew) { … }TEST(EscapableHandleScope) { … }START_ALLOW_USE_DEPRECATED(…)static void SetterWhichExpectsThisAndHolderToDiffer(
    Local<Name>, Local<Value>, const v8::PropertyCallbackInfo<void>& info) { … }END_ALLOW_USE_DEPRECATED(…)TEST(Regress239669) { … }class ApiCallOptimizationChecker { … }v8::Global<Object> ApiCallOptimizationChecker::datav8::Global<Object> ApiCallOptimizationChecker::receiverv8::Global<Object> ApiCallOptimizationChecker::holderv8::Global<Object> ApiCallOptimizationChecker::calleeint ApiCallOptimizationChecker::count = …TEST(FunctionCallOptimization) { … }TEST(FunctionCallOptimizationMultipleArgs) { … }static void ReturnsSymbolCallback(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }TEST(ApiCallbackCanReturnSymbols) { … }TEST(EmptyApiCallback) { … }TEST(SimpleSignatureCheck) { … }TEST(ChainSignatureCheck) { … }static const char* last_event_messagestatic v8::LogEventStatus last_event_statusstatic int event_count = …void StoringEventLoggerCallback(const char* message, int status) { … }TEST(EventLogging) { … }TEST(PropertyDescriptor) { … }TEST(Promises) { … }TEST(PromiseThen) { … }TEST(PromiseThen2) { … }TEST(PromiseCatchCallsBuiltin) { … }TEST(PromiseStateAndValue) { … }TEST(ResolvedPromiseReFulfill) { … }TEST(RejectedPromiseReFulfill) { … }TEST(DisallowJavascriptExecutionScope) { … }TEST(AllowJavascriptExecutionScope) { … }TEST(ThrowOnJavascriptExecution) { … }class MockPlatform final : public TestPlatform { … }TEST_WITH_PLATFORM(DumpOnJavascriptExecution, MockPlatform) { … }TEST(Regress354123) { … }bool ValueEqualsString(v8::Isolate* isolate, Local<Value> lhs,
                       const char* rhs) { … }TEST(ScriptNameAndLineNumber) { … }TEST(ScriptPositionInfo) { … }TEST(ScriptPositionInfoWithLineEnds) { … }template <typename T>
void CheckMagicComments(v8::Isolate* isolate, Local<T> unbound_script,
                        const char* expected_source_url,
                        const char* expected_source_mapping_url) { … }void SourceURLHelper(v8::Isolate* isolate, const char* source_text,
                     const char* expected_source_url,
                     const char* expected_source_mapping_url) { … }TEST(ScriptSourceURLAndSourceMappingURL) { … }TEST(GetOwnPropertyDescriptor) { … }TEST(Regress411877) { … }TEST(GetHiddenPropertyTableAfterAccessCheck) { … }TEST(Regress411793) { … }v8::MaybeLocal<Module> UnexpectedModuleResolveCallback(
    Local<Context> context, Local<String> specifier,
    Local<FixedArray> import_attributes, Local<Module> referrer) { … }void RunStreamingTest(const char** chunks, v8::ScriptType type,
                      v8::ScriptCompiler::StreamedSource::Encoding encoding =
                          v8::ScriptCompiler::StreamedSource::ONE_BYTE,
                      bool expected_success = true,
                      const char* expected_source_url = nullptr,
                      const char* expected_source_mapping_url = nullptr) { … }void RunStreamingTest(const char** chunks,
                      v8::ScriptCompiler::StreamedSource::Encoding encoding =
                          v8::ScriptCompiler::StreamedSource::ONE_BYTE,
                      bool expected_success = true,
                      const char* expected_source_url = nullptr,
                      const char* expected_source_mapping_url = nullptr) { … }TEST(StreamingSimpleScript) { … }TEST(StreamingScriptConstantArray) { … }TEST(StreamingScriptEvalShadowing) { … }TEST(StreamingBiggerScript) { … }TEST(StreamingScriptWithParseError) { … }TEST(StreamingUtf8Script) { … }TEST(StreamingUtf8ScriptWithSplitCharactersSanityCheck) { … }TEST(StreamingUtf8ScriptWithSplitCharacters) { … }TEST(StreamingUtf8ScriptWithSplitCharactersValidEdgeCases) { … }TEST(StreamingUtf8ScriptWithSplitCharactersInvalidEdgeCases) { … }TEST(StreamingWithDebuggingEnabledLate) { … }TEST(StreamingScriptWithInvalidUtf8) { … }TEST(StreamingUtf8ScriptWithMultipleMultibyteCharactersSomeSplit) { … }TEST(StreamingUtf8ScriptWithMultipleMultibyteCharactersSomeSplit2) { … }TEST(StreamingWithHarmonyScopes) { … }void StreamingWithIsolateScriptCache(bool run_gc) { … }TEST(StreamingWithIsolateScriptCache) { … }TEST(StreamingWithIsolateScriptCacheClearingRootSFI) { … }TEST(CodeCache) { … }v8::MaybeLocal<Value> UnexpectedSyntheticModuleEvaluationStepsCallback(
    Local<Context> context, Local<Module> module) { … }static int synthetic_module_callback_countv8::MaybeLocal<Value> SyntheticModuleEvaluationStepsCallback(
    Local<Context> context, Local<Module> module) { … }v8::MaybeLocal<Value> SyntheticModuleEvaluationStepsCallbackFail(
    Local<Context> context, Local<Module> module) { … }v8::MaybeLocal<Value> SyntheticModuleEvaluationStepsCallbackSetExport(
    Local<Context> context, Local<Module> module) { … }Local<Module> CompileAndInstantiateModule(v8::Isolate* isolate,
                                          Local<Context> context,
                                          const char* resource_name,
                                          const char* source) { … }Local<Module> CreateAndInstantiateSyntheticModule(
    v8::Isolate* isolate, Local<String> module_name, Local<Context> context,
    const v8::MemorySpan<const v8::Local<v8::String>>& export_names,
    v8::Module::SyntheticModuleEvaluationSteps evaluation_steps) { … }Local<Module> CompileAndInstantiateModuleFromCache(
    v8::Isolate* isolate, Local<Context> context, const char* resource_name,
    const char* source, v8::ScriptCompiler::CachedData* cache) { … }v8::MaybeLocal<Module> SyntheticModuleResolveCallback(
    Local<Context> context, Local<String> specifier,
    Local<FixedArray> import_attributes, Local<Module> referrer) { … }v8::MaybeLocal<Module> SyntheticModuleThatThrowsDuringEvaluateResolveCallback(
    Local<Context> context, Local<String> specifier,
    Local<FixedArray> import_attributes, Local<Module> referrer) { … }TEST(ModuleCodeCache) { … }TEST(CreateSyntheticModule) { … }TEST(CreateSyntheticModuleGC) { … }TEST(CreateSyntheticModuleGCName) { … }TEST(SyntheticModuleSetExports) { … }TEST(SyntheticModuleSetMissingExport) { … }TEST(SyntheticModuleEvaluationStepsNoThrow) { … }TEST(SyntheticModuleEvaluationStepsThrow) { … }TEST(SyntheticModuleEvaluationStepsSetExport) { … }TEST(ImportFromSyntheticModule) { … }TEST(ImportFromSyntheticModuleThrow) { … }v8::MaybeLocal<Module> ModuleEvaluateTerminateExecutionResolveCallback(
    Local<Context> context, Local<String> specifier,
    Local<FixedArray> import_attributes, Local<Module> referrer) { … }void ModuleEvaluateTerminateExecution(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }TEST(ModuleEvaluateTerminateExecution) { … }TEST(ModuleEvaluateImportTerminateExecution) { … }TEST(CodeCacheModuleScriptMismatch) { … }TEST(CodeCacheScriptModuleMismatch) { … }TEST(InvalidCodeCacheDataInCompileModule) { … }void TestInvalidCacheData(v8::ScriptCompiler::CompileOptions option) { … }TEST(InvalidCodeCacheData) { … }TEST(StringConcatOverflow) { … }TEST(TurboAsmDisablesDetach) { … }TEST(ClassPrototypeCreationContext) { … }TEST(SimpleStreamingScriptWithSourceURL) { … }TEST(StreamingScriptWithSplitSourceURL) { … }TEST(StreamingScriptWithSourceMappingURLInTheMiddle) { … }void GetCurrentHostDefinedOptionsTest(
    const v8::FunctionCallbackInfo<Value>& info) { … }THREADED_TEST(TestGetCurrentHostDefinedOptions) { … }TEST(NewStringRangeError) { … }TEST(SealHandleScope) { … }TEST(SealHandleScopeNested) { … }TEST(Map) { … }TEST(Set) { … }TEST(SetDeleteThenAsArray) { … }TEST(MapDeleteThenAsArray) { … }TEST(CompatibleReceiverCheckOnCachedICHandler) { … }THREADED_TEST(ReceiverConversionForAccessors) { … }class TerminateExecutionThread : public v8::base::Thread { … }TEST(FutexInterruption) { … }TEST(StackCheckTermination) { … }static int nb_uncaught_exception_callback_calls = …bool NoAbortOnUncaughtException(v8::Isolate* isolate) { … }TEST(AbortOnUncaughtExceptionNoAbort) { … }TEST(AccessCheckedIsConcatSpreadable) { … }TEST(AccessCheckedToStringTag) { … }TEST(TemplateIteratorPrototypeIntrinsics) { … }TEST(TemplateAsyncIteratorPrototypeIntrinsics) { … }TEST(TemplateErrorPrototypeIntrinsics) { … }TEST(ObjectTemplateArrayProtoIntrinsics) { … }TEST(ObjectTemplatePerContextIntrinsics) { … }TEST(Proxy) { … }WeakCallCounterAndPersistent<Value>* CreateGarbageWithWeakCallCounter(
    v8::Isolate* isolate, WeakCallCounter* counter) { … }class MemoryPressureThread : public v8::base::Thread { … }TEST(MemoryPressure) { … }TEST(SetIntegrityLevel) { … }TEST(PrivateForApiIsNumber) { … }THREADED_TEST(ImmutableProto) { … }v8::Global<v8::Context> call_eval_context_globalv8::Global<v8::Function> call_eval_bound_function_globalvoid CallEval(const v8::FunctionCallbackInfo<v8::Value>& info) { … }TEST(CrossActivationEval) { … }TEST(EvalInAccessCheckedContext) { … }THREADED_TEST(ImmutableProtoWithParent) { … }TEST(InternalFieldsOnGlobalProxy) { … }THREADED_TEST(ImmutableProtoGlobal) { … }THREADED_TEST(MutableProtoGlobal) { … }TEST(SetPrototypeTemplate) { … }void ensure_receiver_is_global_proxy(
    v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) { … }THREADED_TEST(GlobalAccessorInfo) { … }TEST(DeterministicRandomNumberGeneration) { … }UNINITIALIZED_TEST(AllowAtomicsWait) { … }enum ContextId { … }void CheckContexts(v8::Isolate* isolate) { … }void ContextCheckGetter(Local<Name> name,
                        const v8::PropertyCallbackInfo<v8::Value>& info) { … }void ContextCheckSetter(Local<Name> name, Local<Value>,
                        const v8::PropertyCallbackInfo<void>& info) { … }void ContextCheckToString(const v8::FunctionCallbackInfo<v8::Value>& info) { … }TEST(CorrectEnteredContext) { … }const int kCustomHostDefinedOptionsLengthForTesting = …v8::MaybeLocal<v8::Promise> HostImportModuleDynamicallyCallbackResolve(
    Local<v8::Context> context, Local<v8::Data> host_defined_options,
    Local<v8::Value> resource_name, Local<v8::String> specifier,
    Local<v8::FixedArray> import_attributes) { … }TEST(DynamicImport) { … }v8::MaybeLocal<v8::Promise>
HostImportModuleDynamicallyWithAssertionsCallbackResolve(
    Local<v8::Context> context, Local<v8::Data> host_defined_options,
    Local<v8::Value> resource_name, Local<v8::String> specifier,
    Local<v8::FixedArray> import_attributes) { … }TEST(DynamicImportWithAssertions) { … }void HostInitializeImportMetaObjectCallbackStatic(Local<Context> context,
                                                  Local<Module> module,
                                                  Local<Object> meta) { … }TEST(ImportMeta) { … }void HostInitializeImportMetaObjectCallbackThrow(Local<Context> context,
                                                 Local<Module> module,
                                                 Local<Object> meta) { … }TEST(ImportMetaThrowUnhandled) { … }TEST(ImportMetaThrowHandled) { … }v8::MaybeLocal<v8::Context> HostCreateShadowRealmContextCallbackStatic(
    v8::Local<v8::Context> initiator_context) { … }TEST(CreateShadowRealmContextHostNotSupported) { … }TEST(CreateShadowRealmContext) { … }v8::MaybeLocal<v8::Context> HostCreateShadowRealmContextCallbackThrow(
    v8::Local<v8::Context> initiator_context) { … }TEST(CreateShadowRealmContextThrow) { … }TEST(GetModuleNamespace) { … }TEST(ModuleGetUnboundModuleScript) { … }TEST(ModuleScriptId) { … }TEST(ModuleIsSourceTextModule) { … }TEST(GlobalTemplateWithDoubleProperty) { … }TEST(PrimitiveArray) { … }TEST(PersistentValueMap) { … }enum class AtomicsWaitCallbackAction { … }class StopAtomicsWaitThreadstruct AtomicsWaitCallbackInfo { … }class StopAtomicsWaitThread : public v8::base::Thread { … }void AtomicsWaitCallbackForTesting(
    v8::Isolate::AtomicsWaitEvent event, Local<v8::SharedArrayBuffer> sab,
    size_t offset_in_bytes, int64_t value, double timeout_in_ms,
    v8::Isolate::AtomicsWaitWakeHandle* wake_handle, void* data) { … }void AtomicsWaitCallbackCommon(v8::Isolate* isolate, Local<Value> sab,
                               size_t initial_offset,
                               size_t offset_multiplier) { … }TEST(AtomicsWaitCallback) { … }#if V8_ENABLE_WEBASSEMBLYTEST(WasmCodeFlushingOnMemoryPressure) { … }TEST(WasmI32AtomicWaitCallback) { … }TEST(WasmI64AtomicWaitCallback) { … }#endif  // V8_ENABLE_WEBASSEMBLYTEST(BigIntAPI) { … }TEST(GetJSEntryStubs) { … }TEST(MicrotaskContextShouldBeNativeContext) { … }TEST(PreviewSetKeysIteratorEntriesWithDeleted) { … }TEST(PreviewSetValuesIteratorEntriesWithDeleted) { … }TEST(PreviewMapEntriesIteratorEntries) { … }TEST(PreviewMapValuesIteratorEntriesWithDeleted) { … }TEST(PreviewMapKeysIteratorEntriesWithDeleted) { … }static v8::Isolate* isolate_1static v8::Isolate* isolate_2v8::Persistent<v8::Context> context_1v8::Persistent<v8::Context> context_2void CallIsolate1(const v8::FunctionCallbackInfo<v8::Value>& info) { … }void CallIsolate2(const v8::FunctionCallbackInfo<v8::Value>& info) { … }UNINITIALIZED_TEST(NestedIsolates) { … }#undef THREADED_PROFILED_TEST#if !defined(V8_LITE_MODE) && defined(V8_ENABLE_TURBOFAN)#ifdef V8_USE_SIMULATOR_WITH_GENERIC_C_CALLS#endif  // V8_USE_SIMULATOR_WITH_GENERIC_C_CALLStemplate <typename Value, typename Impl, typename Ret>
struct BasicApiChecker { … }#ifdef V8_USE_SIMULATOR_WITH_GENERIC_C_CALLS#endif  // V8_USE_SIMULATOR_WITH_GENERIC_C_CALLSenum class Behavior { … }template <typename T>
struct ApiNumberChecker : BasicApiChecker<T, ApiNumberChecker<T>, void> { … }struct UnexpectedObjectChecker
    : BasicApiChecker<v8::Local<v8::Value>, UnexpectedObjectChecker, void> { … }struct EmbedderType { … }struct ApiObjectChecker
    : BasicApiChecker<v8::Local<v8::Value>, ApiObjectChecker, void> { … }template <typename Value, typename Impl, typename Ret>
bool SetupTest(v8::Local<v8::Value> initial_value, LocalContext* env,
               BasicApiChecker<Value, Impl, Ret>* checker,
               const char* source_code, bool has_options = true,
               bool accept_any_receiver = true, bool setup_try_catch = true) { … }template <typename I, std::enable_if_t<std::is_integral<I>::value, bool> = true>
void CheckEqual(I actual, I expected, std::ostringstream& error_msg) { … }template <typename F,
          std::enable_if_t<std::is_floating_point<F>::value, bool> = true>
void CheckEqual(F actual, F expected, std::ostringstream& error_msg) { … }#if V8_ENABLE_WEBASSEMBLYvoid CallAndCheckFromWasm() { … }#endif  // V8_ENABLE_WEBASSEMBLYtemplate <typename T>
void CallAndCheck(T expected_value, Behavior expected_behavior,
                  ApiCheckerResultFlags expected_path,
                  v8::Local<v8::Value> initial_value,
                  Behavior raise_exception = Behavior::kNoException) { … }void CheckApiObjectArg() { … }static const char* fast_calls_error_message = …static const char* fast_calls_error_location = …void FastCallsErrorCallback(const char* location, const char* message) { … }void CheckFastCallsWithConstructor() { … }template <typename T>
struct ReturnValueChecker : BasicApiChecker<T, ReturnValueChecker<T>, T> { … }struct AllocationChecker : BasicApiChecker<int32_t, AllocationChecker, void> { … }struct ThrowInReentrantJSChecker
    : BasicApiChecker<int32_t, ThrowInReentrantJSChecker, void> { … }template <typename T>
void CheckFastReturnValue(v8::Local<v8::Value> expected_value,
                          ApiCheckerResultFlags expected_path) { … }void CallAndDeopt() { … }void CallNoOptions(int32_t expected_value) { … }void CallNoConvertReceiver(int32_t expected_value) { … }void CallWithLessArguments() { … }void CallWithMoreArguments() { … }void FastApiCallWithAllocationAndGC(AllocationChecker::GCLocation gc_location) { … }TEST(FastApiCallWithAllocationAndGCInC) { … }TEST(FastApiCallWithAllocationAndGCInJS) { … }TEST(FastApiCallWithThrowInReentrantCode) { … }void DoFastReentrantCall(i::Isolate* i_isolate, LocalContext* env, int* sum,
                         int value, bool inner_most_throws)struct RecursiveReentrantJSChecker
    : BasicApiChecker<int32_t, RecursiveReentrantJSChecker, void> { … }void DoFastReentrantCall(i::Isolate* i_isolate, LocalContext* env, int* sum,
                         int value, bool inner_most_throws) { … }void FastApiCallRecursion(bool inner_most_throws) { … }TEST(FastApiCallRecursionWithException) { … }TEST(FastApiCallRecursionNoException) { … }void CallWithUnexpectedReceiverType(v8::Local<v8::Value> receiver) { … }void CallWithUnexpectedObjectType(v8::Local<v8::Value> receiver) { … }class TestCFunctionInfo : public v8::CFunctionInfo { … }void CheckDynamicTypeInfo() { … }#endif  // !defined(V8_LITE_MODE) && defined(V8_ENABLE_TURBOFAN)TEST(FastApiStackSlot) { … }TEST(FastApiCalls) { … }#if V8_ENABLE_WEBASSEMBLYTEST(FastApiCallsFromWasm) { … }#endif#if !defined(V8_LITE_MODE) && defined(V8_ENABLE_TURBOFAN)namespace …#endif  // !defined(V8_LITE_MODE) && defined(V8_ENABLE_TURBOFAN)TEST(FastApiSequenceOverloads) { … }TEST(FastApiOverloadResolution) { … }TEST(Recorder_GetContext) { … }class MetricsRecorder : public v8::metrics::Recorder { … }TEST(TriggerMainThreadMetricsEvent) { … }TEST(TriggerDelayedMainThreadMetricsEvent) { … }TEST(TriggerThreadSafeMetricsEvent) { … }void SetupCodeLike(LocalContext* env, const char* name,
                   v8::Local<v8::FunctionTemplate> to_string,
                   bool is_code_like) { … }TEST(CodeLikeEval) { … }TEST(CodeLikeFunction) { … }THREADED_TEST(MicrotaskQueueOfContext) { … }THREADED_TEST(SetMicrotaskQueueOfContext) { … }bool MockSabConstructorEnabledCallback(v8::Local<v8::Context>) { … }bool MockSabConstructorDisabledCallback(v8::Local<v8::Context>) { … }TEST(TestSetSabConstructorEnabledCallback) { … }void NodeTypeCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { … }TEST(EmbedderInstanceTypes) { … }template <typename T>
void TestCopyAndMoveConstructionAndAssignment() { … }UNINITIALIZED_TEST(IsolateCreateParamsIsMovableAndCopyable) { … }UNINITIALIZED_TEST(OOMDetailsAreMovableAndCopyable) { … }UNINITIALIZED_TEST(JitCodeEventIsMovableAndCopyable) { … }#if V8_ENABLE_WEBASSEMBLYTEST(WasmAbortStreamingAfterContextDisposal) { … }#endif  // V8_ENABLE_WEBASSEMBLYTEST(DeepFreezeIncompatibleTypes) { … }TEST(DeepFreezeIsFrozen) { … }TEST(DeepFreezeAllowsSyntax) { … }class AllowEmbedderObjects : public v8::Context::DeepFreezeDelegate { … }TEST(DeepFreezesJSApiObjectWithDelegate) { … }class MyObject { … }class HiddenDataDelegate : public v8::Context::DeepFreezeDelegate { … }TEST(DeepFreezeDoesntFreezeJSApiObjectFunctionData) { … }TEST(DeepFreezeForbidsJSApiObjectWithoutDelegate) { … }TEST(DeepFreezeFreezesJSApiObjectData) { … }TEST(DeepFreezeFreezesExternalObjectData) { … }void handle_property(Local<Name> name,
                     const v8::PropertyCallbackInfo<v8::Value>& info) { … }void handle_property_2(Local<Name> name,
                       const v8::PropertyCallbackInfo<v8::Value>& info) { … }void handle_property(const v8::FunctionCallbackInfo<v8::Value>& info) { … }TEST(DeepFreezeInstantiatesAccessors) { … }void handle_object_property(v8::Local<v8::Name> property,
                            const v8::PropertyCallbackInfo<Value>& info) { … }TEST(DeepFreezeInstantiatesAccessors2) { … }void GetIsolatePreservedContinuationData(
    const v8::FunctionCallbackInfo<v8::Value>& info) { … }TEST(ContinuationPreservedEmbedderData) { … }TEST(ContinuationPreservedEmbedderDataClearedAndRestored) { … }static bool did_callback_microtask_run = …static void CallbackTaskMicrotask(void* data) { … }TEST(EnqueMicrotaskContinuationPreservedEmbedderData_CallbackTask) { … }static bool did_callable_microtask_run = …static void CallableTaskMicrotask(const v8::FunctionCallbackInfo<Value>& info) { … }TEST(EnqueMicrotaskContinuationPreservedEmbedderData_CallableTask) { … }static bool did_thenable_callback_run = …static void ThenableCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { … }TEST(ContinuationPreservedEmbedderData_Thenable) { … }TEST(WrappedFunctionWithClass) { … }