private:

void SetUp() override {

EnvironmentTestFixture::SetUp();

finalizer_call_count = 0;

}

void TearDown() override { NodeTestFixture::TearDown(); }

const v8::HandleScope handle_scope(isolate_);

Argv argv;

napi_ref ref;

void* embedder_fields[v8::kEmbedderFieldsInWeakCallback] = {nullptr, nullptr};

v8::WeakCallbackInfo<Reference::SecondPassCallParameterRef>::Callback

callback;

Reference::SecondPassCallParameterRef* parameter = nullptr;

{

Env test_env{handle_scope, argv};

node::Environment* env = *test_env;

node::LoadEnvironment(env, "");

napi_addon_register_func init = [](napi_env env, napi_value exports) {

addon_env = env;

return exports;

};

Local<Object> module_obj = Object::New(isolate_);

Local<Object> exports_obj = Object::New(isolate_);

napi_module_register_by_symbol(

exports_obj, module_obj, env->context(), init);

ASSERT_NE(addon_env, nullptr);

node_napi_env internal_env = reinterpret_cast<node_napi_env>(addon_env);

EXPECT_EQ(internal_env->node_env(), env);

// Create a new scope to manage the handles.

{

const v8::HandleScope handle_scope(isolate_);

napi_value value;

napi_create_object(addon_env, &value);

// Create a weak reference;

napi_add_finalizer(

addon_env,

value,

nullptr,

[](napi_env env, void* finalize_data, void* finalize_hint) {

finalizer_call_count++;

},

nullptr,

&ref);

parameter = reinterpret_cast<Reference*>(ref)->_secondPassParameter;

}

// We can hardly trigger a non-forced Garbage Collection in a stable way.

// Here we just invoke the weak callbacks directly.

// The persistent handles should be reset in the weak callback in respect

// to the API contract of v8 weak callbacks.

v8::WeakCallbackInfo<Reference::SecondPassCallParameterRef> data(

reinterpret_cast<v8::Isolate*>(isolate_),

parameter,

embedder_fields,

&callback);

Reference::FinalizeCallback(data);

EXPECT_EQ(callback, &Reference::SecondPassCallback);

}

// Env goes out of scope, the environment has been teardown. All node-api ref

// trackers should have been destroyed.

// Now we call the second pass callback to verify the method do not abort with

// memory violations.

v8::WeakCallbackInfo<Reference::SecondPassCallParameterRef> data(

reinterpret_cast<v8::Isolate*>(isolate_),

parameter,

embedder_fields,

nullptr);

Reference::SecondPassCallback(data);

// After Environment Teardown

EXPECT_EQ(finalizer_call_count, uint32_t(1));