deps: V8: cherry-pick 74571c8 · nodejs/node@cf649c9 (original) (raw)

`@@ -28644,7 +28644,7 @@ TEST(MicrotaskContextShouldBeNativeContext) {

28644

` isolate->RunMicrotasks();

28645

28646

28647

TEST(PreviewSetIteratorEntriesWithDeleted) {

28647

TEST(PreviewSetKeysIteratorEntriesWithDeleted) {

28648

` LocalContext env;

28649

` v8::HandleScope handle_scope(env->GetIsolate());

28650

` v8::Localv8::Context context = env.local();

`@@ -28743,7 +28743,142 @@ TEST(PreviewSetIteratorEntriesWithDeleted) {

28743

` }

28744

28745

28746

TEST(PreviewMapIteratorEntriesWithDeleted) {

28746

TEST(PreviewSetValuesIteratorEntriesWithDeleted) {

28747

LocalContext env;

28748

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

28749

v8::Localv8::Context context = env.local();

28750

+

28751

{

28752

// Create set, delete entry, create iterator, preview.

28753

v8::Localv8::Object iterator =

28754

CompileRun("var set = new Set([1,2,3]); set.delete(1); set.values()")

28755

->ToObject(context)

28756

.ToLocalChecked();

28757

bool is_key;

28758

v8::Localv8::Array entries =

28759

iterator->PreviewEntries(&is_key).ToLocalChecked();

28760

CHECK(!is_key);

28761

CHECK_EQ(2, entries->Length());

28762

CHECK_EQ(2, entries->Get(context, 0)

28763

.ToLocalChecked()

28764

->Int32Value(context)

28765

.FromJust());

28766

CHECK_EQ(3, entries->Get(context, 1)

28767

.ToLocalChecked()

28768

->Int32Value(context)

28769

.FromJust());

28770

}

28771

{

28772

// Create set, create iterator, delete entry, preview.

28773

v8::Localv8::Object iterator =

28774

CompileRun("var set = new Set([1,2,3]); set.values()")

28775

->ToObject(context)

28776

.ToLocalChecked();

28777

CompileRun("set.delete(1);");

28778

bool is_key;

28779

v8::Localv8::Array entries =

28780

iterator->PreviewEntries(&is_key).ToLocalChecked();

28781

CHECK(!is_key);

28782

CHECK_EQ(2, entries->Length());

28783

CHECK_EQ(2, entries->Get(context, 0)

28784

.ToLocalChecked()

28785

->Int32Value(context)

28786

.FromJust());

28787

CHECK_EQ(3, entries->Get(context, 1)

28788

.ToLocalChecked()

28789

->Int32Value(context)

28790

.FromJust());

28791

}

28792

{

28793

// Create set, create iterator, delete entry, iterate, preview.

28794

v8::Localv8::Object iterator =

28795

CompileRun("var set = new Set([1,2,3]); var it = set.values(); it")

28796

->ToObject(context)

28797

.ToLocalChecked();

28798

CompileRun("set.delete(1); it.next();");

28799

bool is_key;

28800

v8::Localv8::Array entries =

28801

iterator->PreviewEntries(&is_key).ToLocalChecked();

28802

CHECK(!is_key);

28803

CHECK_EQ(1, entries->Length());

28804

CHECK_EQ(3, entries->Get(context, 0)

28805

.ToLocalChecked()

28806

->Int32Value(context)

28807

.FromJust());

28808

}

28809

{

28810

// Create set, create iterator, delete entry, iterate until empty, preview.

28811

v8::Localv8::Object iterator =

28812

CompileRun("var set = new Set([1,2,3]); var it = set.values(); it")

28813

->ToObject(context)

28814

.ToLocalChecked();

28815

CompileRun("set.delete(1); it.next(); it.next();");

28816

bool is_key;

28817

v8::Localv8::Array entries =

28818

iterator->PreviewEntries(&is_key).ToLocalChecked();

28819

CHECK(!is_key);

28820

CHECK_EQ(0, entries->Length());

28821

}

28822

{

28823

// Create set, create iterator, delete entry, iterate, trigger rehash,

28824

// preview.

28825

v8::Localv8::Object iterator =

28826

CompileRun("var set = new Set([1,2,3]); var it = set.values(); it")

28827

->ToObject(context)

28828

.ToLocalChecked();

28829

CompileRun("set.delete(1); it.next();");

28830

CompileRun("for (var i = 4; i < 20; i++) set.add(i);");

28831

bool is_key;

28832

v8::Localv8::Array entries =

28833

iterator->PreviewEntries(&is_key).ToLocalChecked();

28834

CHECK(!is_key);

28835

CHECK_EQ(17, entries->Length());

28836

for (uint32_t i = 0; i < 17; i++) {

28837

CHECK_EQ(i + 3, entries->Get(context, i)

28838

.ToLocalChecked()

28839

->Int32Value(context)

28840

.FromJust());

28841

}

28842

}

28843

}

28844

+

28845

TEST(PreviewMapEntriesIteratorEntries) {

28846

LocalContext env;

28847

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

28848

v8::Localv8::Context context = env.local();

28849

{

28850

// Create set, delete entry, create entries iterator, preview.

28851

v8::Localv8::Object iterator =

28852

CompileRun("var set = new Set([1,2,3]); set.delete(2); set.entries()")

28853

->ToObject(context)

28854

.ToLocalChecked();

28855

bool is_key;

28856

v8::Localv8::Array entries =

28857

iterator->PreviewEntries(&is_key).ToLocalChecked();

28858

CHECK(is_key);

28859

CHECK_EQ(4, entries->Length());

28860

uint32_t first = entries->Get(context, 0)

28861

.ToLocalChecked()

28862

->Int32Value(context)

28863

.FromJust();

28864

uint32_t second = entries->Get(context, 2)

28865

.ToLocalChecked()

28866

->Int32Value(context)

28867

.FromJust();

28868

CHECK_EQ(1, first);

28869

CHECK_EQ(3, second);

28870

CHECK_EQ(first, entries->Get(context, 1)

28871

.ToLocalChecked()

28872

->Int32Value(context)

28873

.FromJust());

28874

CHECK_EQ(second, entries->Get(context, 3)

28875

.ToLocalChecked()

28876

->Int32Value(context)

28877

.FromJust());

28878

}

28879

}

28880

+

28881

TEST(PreviewMapValuesIteratorEntriesWithDeleted) {

28747

28882

` LocalContext env;

28748

28883

` v8::HandleScope handle_scope(env->GetIsolate());

28749

28884

` v8::Localv8::Context context = env.local();

`@@ -28858,6 +28993,97 @@ TEST(PreviewMapIteratorEntriesWithDeleted) {

28858

28993

` }

28859

28994

28860

28995

28996

TEST(PreviewMapKeysIteratorEntriesWithDeleted) {

28997

LocalContext env;

28998

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

28999

v8::Localv8::Context context = env.local();

29000

+

29001

{

29002

// Create map, delete entry, create iterator, preview.

29003

v8::Localv8::Object iterator = CompileRun(

29004

"var map = new Map();"

29005

"var key = 1; map.set(key, {});"

29006

"map.set(2, {}); map.set(3, {});"

29007

"map.delete(key);"

29008

"map.keys()")

29009

->ToObject(context)

29010

.ToLocalChecked();

29011

bool is_key;

29012

v8::Localv8::Array entries =

29013

iterator->PreviewEntries(&is_key).ToLocalChecked();

29014

CHECK(!is_key);

29015

CHECK_EQ(2, entries->Length());

29016

CHECK_EQ(2, entries->Get(context, 0)

29017

.ToLocalChecked()

29018

->Int32Value(context)

29019

.FromJust());

29020

CHECK_EQ(3, entries->Get(context, 1)

29021

.ToLocalChecked()

29022

->Int32Value(context)

29023

.FromJust());

29024

}

29025

{

29026

// Create map, create iterator, delete entry, preview.

29027

v8::Localv8::Object iterator = CompileRun(

29028

"var map = new Map();"

29029

"var key = 1; map.set(key, {});"

29030

"map.set(2, {}); map.set(3, {});"

29031

"map.keys()")

29032

->ToObject(context)

29033

.ToLocalChecked();

29034

CompileRun("map.delete(key);");

29035

bool is_key;

29036

v8::Localv8::Array entries =

29037

iterator->PreviewEntries(&is_key).ToLocalChecked();

29038

CHECK(!is_key);

29039

CHECK_EQ(2, entries->Length());

29040

CHECK_EQ(2, entries->Get(context, 0)

29041

.ToLocalChecked()

29042

->Int32Value(context)

29043

.FromJust());

29044

CHECK_EQ(3, entries->Get(context, 1)

29045

.ToLocalChecked()

29046

->Int32Value(context)

29047

.FromJust());

29048

}

29049

{

29050

// Create map, create iterator, delete entry, iterate, preview.

29051

v8::Localv8::Object iterator = CompileRun(

29052

"var map = new Map();"

29053

"var key = 1; map.set(key, {});"

29054

"map.set(2, {}); map.set(3, {});"

29055

"var it = map.keys(); it")

29056

->ToObject(context)

29057

.ToLocalChecked();

29058

CompileRun("map.delete(key); it.next();");

29059

bool is_key;

29060

v8::Localv8::Array entries =

29061

iterator->PreviewEntries(&is_key).ToLocalChecked();

29062

CHECK(!is_key);

29063

CHECK_EQ(1, entries->Length());

29064

CHECK_EQ(3, entries->Get(context, 0)

29065

.ToLocalChecked()

29066

->Int32Value(context)

29067

.FromJust());

29068

}

29069

{

29070

// Create map, create iterator, delete entry, iterate until empty, preview.

29071

v8::Localv8::Object iterator = CompileRun(

29072

"var map = new Map();"

29073

"var key = 1; map.set(key, {});"

29074

"map.set(2, {}); map.set(3, {});"

29075

"var it = map.keys(); it")

29076

->ToObject(context)

29077

.ToLocalChecked();

29078

CompileRun("map.delete(key); it.next(); it.next();");

29079

bool is_key;

29080

v8::Localv8::Array entries =

29081

iterator->PreviewEntries(&is_key).ToLocalChecked();

29082

CHECK(!is_key);

29083

CHECK_EQ(0, entries->Length());

29084

}

29085

}

29086

+

28861

29087

`namespace {

28862

29088

`static v8::Isolate* isolate_1;

28863

29089

`static v8::Isolate* isolate_2;