const char* source,

const char* function_name) {

CompileRunChecked(isolate, source);

v8::Local<v8::String> name = v8_str(isolate, function_name);

v8::Local<v8::Context> context = isolate->GetCurrentContext();

v8::MaybeLocal<v8::Value> maybe_function =

context->Global()->Get(context, name);

return v8::Local<v8::Function>::Cast(maybe_function.ToLocalChecked());

const char* source,

const char* function_name) {

return CompileFunction((*env)->GetIsolate(), source, function_name);

Handle<v8::internal::JSFunction> f =

Handle<v8::internal::JSFunction>::cast(v8::Utils::OpenHandle(*fun));

Handle<v8::internal::SharedFunctionInfo> shared(f->shared(), f->GetIsolate());

return shared->HasBreakInfo();

int position,

const char* condition = nullptr) {

i::Handle<i::JSFunction> function =

i::Handle<i::JSFunction>::cast(v8::Utils::OpenHandle(*fun));

position += function->shared().StartPosition();

static int break_point_index = 0;

i::Isolate* isolate = function->GetIsolate();

i::Handle<i::String> condition_string =

condition ? isolate->factory()->NewStringFromAsciiChecked(condition)

: isolate->factory()->empty_string();

i::Debug* debug = isolate->debug();

i::Handle<i::BreakPoint> break_point =

isolate->factory()->NewBreakPoint(++break_point_index, condition_string);

debug->SetBreakpoint(handle(function->shared(), isolate), break_point,

&position);

return break_point;

v8::internal::Isolate* isolate = CcTest::i_isolate();

v8::internal::Debug* debug = isolate->debug();

debug->ClearBreakPoint(break_point);

bool uncaught) {

v8::internal::Debug* debug =

reinterpret_cast<v8::internal::Isolate*>(isolate)->debug();

debug->ChangeBreakOnException(v8::internal::BreakException, caught);

debug->ChangeBreakOnException(v8::internal::BreakUncaughtException, uncaught);

Debug* debug = CcTest::i_isolate()->debug();

v8::internal::DebugInfoListNode* node = debug->debug_info_list_;

// Find the number of debugged functions.

int count = 0;

while (node) {

count++;

node = node->next();

}

// Allocate array for the debugged functions

Handle<FixedArray> debugged_functions =

CcTest::i_isolate()->factory()->NewFixedArray(count);

// Run through the debug info objects and collect all functions.

count = 0;

while (node) {

debugged_functions->set(count++, *node->debug_info());

node = node->next();

}

return debugged_functions;

// Check that the debugger context is cleared and that there is no debug

// information stored for the debugger.

CHECK(!CcTest::i_isolate()->debug()->debug_info_list_);

// Collect garbage to ensure weak handles are cleared.

CcTest::CollectAllGarbage();

CcTest::CollectAllGarbage();

// Iterate the heap and check that there are no debugger related objects left.

HeapObjectIterator iterator(CcTest::heap());

for (HeapObject obj = iterator.Next(); !obj.is_null();

obj = iterator.Next()) {

CHECK(!obj.IsDebugInfo());

}

public:

void BreakProgramRequested(

v8::Local<v8::Context>,

const std::vector<v8::debug::BreakpointId>&) override {

break_point_hit_count++;

// Perform a full deoptimization when the specified number of

// breaks have been hit.

if (break_point_hit_count == break_point_hit_count_deoptimize) {

i::Deoptimizer::DeoptimizeAll(CcTest::i_isolate());

}

if (step_action_ != StepNone) PrepareStep(step_action_);

}

void set_step_action(i::StepAction step_action) {

step_action_ = step_action;

}

private:

i::StepAction step_action_ = StepNone;

public:

void BreakProgramRequested(

v8::Local<v8::Context>,

const std::vector<v8::debug::BreakpointId>&) override {

// Perform a garbage collection when break point is hit and continue. Based

// on the number of break points hit either scavenge or mark compact

// collector is used.

break_point_hit_count++;

if (break_point_hit_count % 2 == 0) {

// Scavenge.

CcTest::CollectGarbage(v8::internal::NEW_SPACE);

} else {

// Mark sweep compact.

CcTest::CollectAllGarbage();

}

}

public:

void BreakProgramRequested(

v8::Local<v8::Context>,

const std::vector<v8::debug::BreakpointId>&) override {

// Count the number of breaks.

break_point_hit_count++;

// Run the garbage collector to enforce heap verification if option

// --verify-heap is set.

CcTest::CollectGarbage(v8::internal::NEW_SPACE);

// Set the break flag again to come back here as soon as possible.

v8::debug::SetBreakOnNextFunctionCall(CcTest::isolate());

}

public:

void BreakProgramRequested(

v8::Local<v8::Context>,

const std::vector<v8::debug::BreakpointId>&) override {

v8::Isolate* v8_isolate = CcTest::isolate();

v8::internal::Isolate* isolate = CcTest::i_isolate();

if (break_point_hit_count < max_break_point_hit_count) {

// Count the number of breaks.

break_point_hit_count++;

// Set the break flag again to come back here as soon as possible.

v8_isolate->RequestInterrupt(BreakRightNow, nullptr);

} else if (terminate_after_max_break_point_hit) {

// Terminate execution after the last break if requested.

v8_isolate->TerminateExecution();

}

// Perform a full deoptimization when the specified number of

// breaks have been hit.

if (break_point_hit_count == break_point_hit_count_deoptimize) {

i::Deoptimizer::DeoptimizeAll(isolate);

}

}

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

// Create a couple of functions for the test.

v8::Local<v8::Function> foo =

CompileFunction(&env, "function foo(){}", "foo");

v8::Local<v8::Function> bar =

CompileFunction(&env, "function bar(){}", "bar");

// Initially no functions are debugged.

CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());

CHECK(!HasBreakInfo(foo));

CHECK(!HasBreakInfo(bar));

EnableDebugger(env->GetIsolate());

// One function (foo) is debugged.

i::Handle<i::BreakPoint> bp1 = SetBreakPoint(foo, 0);

CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());

CHECK(HasBreakInfo(foo));

CHECK(!HasBreakInfo(bar));

// Two functions are debugged.

i::Handle<i::BreakPoint> bp2 = SetBreakPoint(bar, 0);

CHECK_EQ(2, v8::internal::GetDebuggedFunctions()->length());

CHECK(HasBreakInfo(foo));

CHECK(HasBreakInfo(bar));

// One function (bar) is debugged.

ClearBreakPoint(bp1);

CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());

CHECK(!HasBreakInfo(foo));

CHECK(HasBreakInfo(bar));

// No functions are debugged.

ClearBreakPoint(bp2);

DisableDebugger(env->GetIsolate());

CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());

CHECK(!HasBreakInfo(foo));

CHECK(!HasBreakInfo(bar));

break_point_hit_count = 0;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> foo =

CompileFunction(&env, "function foo(){bar=0;}", "foo");

// Run without breakpoints.

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint

i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(1, break_point_hit_count);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(2, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(2, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

break_point_hit_count = 0;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

CompileRun("var a = false");

v8::Local<v8::Function> foo =

CompileFunction(&env, "function foo() { return 1 }", "foo");

// Run without breakpoints.

CompileRun("foo()");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint

i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0, "a == true");

CompileRun("foo()");

CHECK_EQ(0, break_point_hit_count);

CompileRun("a = true");

CompileRun("foo()");

CHECK_EQ(1, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

CompileRun("foo()");

CHECK_EQ(1, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

break_point_hit_count = 0;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

CompileRunChecked(env->GetIsolate(), "bar=1");

v8::Local<v8::Function> foo =

CompileFunction(&env, "function foo(){var x=bar;}", "foo");

// Run without breakpoints.

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(1, break_point_hit_count);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(2, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(2, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

break_point_hit_count = 0;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

CompileRunChecked(env->GetIsolate(), "function bar(){}");

v8::Local<v8::Function> foo =

CompileFunction(&env, "function foo(){bar();}", "foo");

// Run without breakpoints.

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint

i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(1, break_point_hit_count);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(2, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(2, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

break_point_hit_count = 0;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventBreakPointCollectGarbage delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

CompileRunChecked(env->GetIsolate(), "function bar(){return 1;}");

v8::Local<v8::Function> foo =

CompileFunction(&env, "function foo(){return bar();}", "foo");

v8::Local<v8::Context> context = env.local();

// Run without breakpoints.

CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)

.ToLocalChecked()

->Int32Value(context)

.FromJust());

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);

CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)

.ToLocalChecked()

->Int32Value(context)

.FromJust());

CHECK_EQ(1, break_point_hit_count);

CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)

.ToLocalChecked()

->Int32Value(context)

.FromJust());

CHECK_EQ(2, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(2, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

break_point_hit_count = 0;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventBreakPointCollectGarbage delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

CompileRunChecked(env->GetIsolate(), "function bar(){ this.x = 1;}");

v8::Local<v8::Function> foo =

CompileFunction(&env, "function foo(){return new bar(1).x;}", "foo");

v8::Local<v8::Context> context = env.local();

// Run without breakpoints.

CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)

.ToLocalChecked()

->Int32Value(context)

.FromJust());

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);

CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)

.ToLocalChecked()

->Int32Value(context)

.FromJust());

CHECK_EQ(1, break_point_hit_count);

CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)

.ToLocalChecked()

->Int32Value(context)

.FromJust());

CHECK_EQ(2, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();

CHECK_EQ(2, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test simple builtin ===

break_point_hit_count = 0;

builtin = CompileRun("String.prototype.repeat").As<v8::Function>();

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0, "this != 1");

ExpectString("'b'.repeat(10)", "bbbbbbbbbb");

CHECK_EQ(1, break_point_hit_count);

ExpectString("'b'.repeat(10)", "bbbbbbbbbb");

CHECK_EQ(2, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

ExpectString("'b'.repeat(10)", "bbbbbbbbbb");

CHECK_EQ(2, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

// === Test that using API-exposed functions won't trigger breakpoints ===

{

v8::Local<v8::Function> weakmap_get =

CompileRun("WeakMap.prototype.get").As<v8::Function>();

SetBreakPoint(weakmap_get, 0);

v8::Local<v8::Function> weakmap_set =

CompileRun("WeakMap.prototype.set").As<v8::Function>();

SetBreakPoint(weakmap_set, 0);

// Run with breakpoint.

break_point_hit_count = 0;

CompileRun("var w = new WeakMap(); w.set(w, 1); w.get(w);");

CHECK_EQ(2, break_point_hit_count);

break_point_hit_count = 0;

v8::Local<v8::debug::EphemeronTable> weakmap =

v8::debug::EphemeronTable::New(env->GetIsolate());

v8::Local<v8::Object> key = v8::Object::New(env->GetIsolate());

CHECK(!weakmap->Set(env->GetIsolate(), key, v8_num(1)).IsEmpty());

CHECK(!weakmap->Get(env->GetIsolate(), key).IsEmpty());

CHECK_EQ(0, break_point_hit_count);

}

{

v8::Local<v8::Function> object_to_string =

CompileRun("Object.prototype.toString").As<v8::Function>();

SetBreakPoint(object_to_string, 0);

// Run with breakpoint.

break_point_hit_count = 0;

CompileRun("var o = {}; o.toString();");

CHECK_EQ(1, break_point_hit_count);

break_point_hit_count = 0;

v8::Local<v8::Object> object = v8::Object::New(env->GetIsolate());

CHECK(!object->ObjectProtoToString(env.local()).IsEmpty());

CHECK_EQ(0, break_point_hit_count);

}

{

v8::Local<v8::Function> map_set =

CompileRun("Map.prototype.set").As<v8::Function>();

v8::Local<v8::Function> map_get =

CompileRun("Map.prototype.get").As<v8::Function>();

v8::Local<v8::Function> map_has =

CompileRun("Map.prototype.has").As<v8::Function>();

v8::Local<v8::Function> map_delete =

CompileRun("Map.prototype.delete").As<v8::Function>();

SetBreakPoint(map_set, 0);

SetBreakPoint(map_get, 0);

SetBreakPoint(map_has, 0);

SetBreakPoint(map_delete, 0);

// Run with breakpoint.

break_point_hit_count = 0;

CompileRun(

"var m = new Map(); m.set(m, 1); m.get(m); m.has(m); m.delete(m);");

CHECK_EQ(4, break_point_hit_count);

break_point_hit_count = 0;

v8::Local<v8::Map> map = v8::Map::New(env->GetIsolate());

CHECK(!map->Set(env.local(), map, v8_num(1)).IsEmpty());

CHECK(!map->Get(env.local(), map).IsEmpty());

CHECK(map->Has(env.local(), map).FromJust());

CHECK(map->Delete(env.local(), map).FromJust());

CHECK_EQ(0, break_point_hit_count);

}

{

v8::Local<v8::Function> set_add =

CompileRun("Set.prototype.add").As<v8::Function>();

v8::Local<v8::Function> set_get =

CompileRun("Set.prototype.has").As<v8::Function>();

v8::Local<v8::Function> set_delete =

CompileRun("Set.prototype.delete").As<v8::Function>();

SetBreakPoint(set_add, 0);

SetBreakPoint(set_get, 0);

SetBreakPoint(set_delete, 0);

// Run with breakpoint.

break_point_hit_count = 0;

CompileRun("var s = new Set(); s.add(s); s.has(s); s.delete(s);");

CHECK_EQ(3, break_point_hit_count);

break_point_hit_count = 0;

v8::Local<v8::Set> set = v8::Set::New(env->GetIsolate());

CHECK(!set->Add(env.local(), set).IsEmpty());

CHECK(set->Has(env.local(), set).FromJust());

CHECK(set->Delete(env.local(), set).FromJust());

CHECK_EQ(0, break_point_hit_count);

}

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test JS builtin ===

break_point_hit_count = 0;

builtin = CompileRun("Array.prototype.sort").As<v8::Function>();

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0);

CompileRun("[1,2,3].sort()");

CHECK_EQ(1, break_point_hit_count);

CompileRun("[1,2,3].sort()");

CHECK_EQ(2, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

CompileRun("[1,2,3].sort()");

CHECK_EQ(2, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test bound function from a builtin ===

break_point_hit_count = 0;

builtin = CompileRun(

"var boundrepeat = String.prototype.repeat.bind('a');"

"String.prototype.repeat")

.As<v8::Function>();

ExpectString("boundrepeat(10)", "aaaaaaaaaa");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0);

ExpectString("boundrepeat(10)", "aaaaaaaaaa");

CHECK_EQ(1, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

ExpectString("boundrepeat(10)", "aaaaaaaaaa");

CHECK_EQ(1, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test Promise constructor ===

break_point_hit_count = 0;

builtin = CompileRun("Promise").As<v8::Function>();

ExpectString("(new Promise(()=>{})).toString()", "[object Promise]");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0, "this != 1");

ExpectString("(new Promise(()=>{})).toString()", "[object Promise]");

CHECK_EQ(1, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

ExpectString("(new Promise(()=>{})).toString()", "[object Promise]");

CHECK_EQ(1, break_point_hit_count);

// === Test Object constructor ===

break_point_hit_count = 0;

builtin = CompileRun("Object").As<v8::Function>();

CompileRun("new Object()");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0);

CompileRun("new Object()");

CHECK_EQ(1, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

CompileRun("new Object()");

CHECK_EQ(1, break_point_hit_count);

// === Test Number constructor ===

break_point_hit_count = 0;

builtin = CompileRun("Number").As<v8::Function>();

CompileRun("new Number()");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0);

CompileRun("new Number()");

CHECK_EQ(1, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

CompileRun("new Number()");

CHECK_EQ(1, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

i::FLAG_allow_natives_syntax = true;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test inlined builtin ===

break_point_hit_count = 0;

builtin = CompileRun("Math.sin").As<v8::Function>();

CompileRun("function test(x) { return 1 + Math.sin(x) }");

CompileRun(

"%PrepareFunctionForOptimization(test);"

"test(0.5); test(0.6);"

"%OptimizeFunctionOnNextCall(test); test(0.7);");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0, "this != 1");

CompileRun("Math.sin(0.1);");

CHECK_EQ(1, break_point_hit_count);

CompileRun("test(0.2);");

CHECK_EQ(2, break_point_hit_count);

// Re-optimize.

CompileRun(

"%PrepareFunctionForOptimization(test);"

"%OptimizeFunctionOnNextCall(test);");

ExpectBoolean("test(0.3) < 2", true);

CHECK_EQ(3, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

CompileRun("test(0.3);");

CHECK_EQ(3, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

i::FLAG_allow_natives_syntax = true;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test inlined bound builtin ===

break_point_hit_count = 0;

builtin = CompileRun(

"var boundrepeat = String.prototype.repeat.bind('a');"

"String.prototype.repeat")

.As<v8::Function>();

CompileRun("function test(x) { return 'a' + boundrepeat(x) }");

CompileRun(

"%PrepareFunctionForOptimization(test);"

"test(4); test(5);"

"%OptimizeFunctionOnNextCall(test); test(6);");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0, "this != 1");

CompileRun("'a'.repeat(2);");

CHECK_EQ(1, break_point_hit_count);

CompileRun("test(7);");

CHECK_EQ(2, break_point_hit_count);

// Re-optimize.

CompileRun(

"%PrepareFunctionForOptimization(f);"

"%OptimizeFunctionOnNextCall(test);");

CompileRun("test(8);");

CHECK_EQ(3, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

CompileRun("test(9);");

CHECK_EQ(3, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

i::FLAG_allow_natives_syntax = true;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test inlined constructor builtin (regular construct builtin) ===

break_point_hit_count = 0;

builtin = CompileRun("Promise").As<v8::Function>();

CompileRun("function test(x) { return new Promise(()=>x); }");

CompileRun(

"%PrepareFunctionForOptimization(test);"

"test(4); test(5);"

"%OptimizeFunctionOnNextCall(test); test(6);");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0, "this != 1");

CompileRun("new Promise(()=>{});");

CHECK_EQ(1, break_point_hit_count);

CompileRun("test(7);");

CHECK_EQ(2, break_point_hit_count);

// Re-optimize.

CompileRun(

"%PrepareFunctionForOptimization(f);"

"%OptimizeFunctionOnNextCall(test);");

CompileRun("test(8);");

CHECK_EQ(3, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

CompileRun("test(9);");

CHECK_EQ(3, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

i::FLAG_allow_natives_syntax = true;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test concurrent optimization ===

break_point_hit_count = 0;

builtin = CompileRun("Math.sin").As<v8::Function>();

CompileRun("function test(x) { return 1 + Math.sin(x) }");

CompileRun(

"%PrepareFunctionForOptimization(test);"

"test(0.5); test(0.6);"

"%DisableOptimizationFinalization();"

"%OptimizeFunctionOnNextCall(test, 'concurrent');"

"test(0.7);");

CHECK_EQ(0, break_point_hit_count);

// Run with breakpoint.

bp = SetBreakPoint(builtin, 0);

// Have the concurrent compile job finish now.

CompileRun(

"%FinalizeOptimization();"

"%GetOptimizationStatus(test);");

CompileRun("test(0.2);");

CHECK_EQ(1, break_point_hit_count);

// Run without breakpoints.

ClearBreakPoint(bp);

CompileRun("test(0.3);");

CHECK_EQ(1, break_point_hit_count);

v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);

CheckDebuggerUnloaded();

i::FLAG_allow_natives_syntax = true;

LocalContext env;

v8::HandleScope scope(env->GetIsolate());

DebugEventCounter delegate;

v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);

v8::Local<v8::Function> builtin;

i::Handle<i::BreakPoint> bp;

// === Test builtin represented as operator ===

break_point_hit_count = 0;

builtin = CompileRun("String.prototype.indexOf").As<v8::Function>();

CompileRun("function test(x) { return 1 + 'foo'.indexOf(x) }");

CompileRun(