Head

GCC Code Coverage Report

Directory:	../		Exec	Total	Coverage
File:	/home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/node_env_var.cc	Lines:	181	190	95.3 %
Date:	2020-11-21 04:10:54	Branches:	76	104	73.1 %


#include "debug_utils-inl.h"
#include "env-inl.h"
#include "node_errors.h"
#include "node_external_reference.h"
#include "node_process.h"

#include <time.h>  // tzset(), _tzset()

namespace node {
using v8::Array;
using v8::Boolean;
using v8::Context;
using v8::DontDelete;
using v8::DontEnum;
using v8::EscapableHandleScope;
using v8::HandleScope;
using v8::Integer;
using v8::Isolate;
using v8::Just;
using v8::Local;
using v8::Maybe;
using v8::MaybeLocal;
using v8::Name;
using v8::NamedPropertyHandlerConfiguration;
using v8::NewStringType;
using v8::Nothing;
using v8::Object;
using v8::ObjectTemplate;
using v8::PropertyCallbackInfo;
using v8::PropertyHandlerFlags;
using v8::ReadOnly;
using v8::String;
using v8::Value;

class RealEnvStore final : public KVStore {
 public:
  MaybeLocal<String> Get(Isolate* isolate, Local<String> key) const override;
  Maybe<std::string> Get(const char* key) const override;
  void Set(Isolate* isolate, Local<String> key, Local<String> value) override;
  int32_t Query(Isolate* isolate, Local<String> key) const override;
  int32_t Query(const char* key) const override;
  void Delete(Isolate* isolate, Local<String> key) override;
  Local<Array> Enumerate(Isolate* isolate) const override;
};

class MapKVStore final : public KVStore {
 public:
  MaybeLocal<String> Get(Isolate* isolate, Local<String> key) const override;
  Maybe<std::string> Get(const char* key) const override;
  void Set(Isolate* isolate, Local<String> key, Local<String> value) override;
  int32_t Query(Isolate* isolate, Local<String> key) const override;
  int32_t Query(const char* key) const override;
  void Delete(Isolate* isolate, Local<String> key) override;
  Local<Array> Enumerate(Isolate* isolate) const override;

  std::shared_ptr<KVStore> Clone(Isolate* isolate) const override;

  MapKVStore() = default;
  MapKVStore(const MapKVStore& other) : KVStore(), map_(other.map_) {}

 private:
  mutable Mutex mutex_;
  std::unordered_map<std::string, std::string> map_;
};

namespace per_process {
Mutex env_var_mutex;
std::shared_ptr<KVStore> system_environment = std::make_shared<RealEnvStore>();
}  // namespace per_process

template <typename T>
void DateTimeConfigurationChangeNotification(Isolate* isolate, const T& key) {
  if (key.length() == 2 && key[0] == 'T' && key[1] == 'Z') {
#ifdef __POSIX__
    tzset();
#else
    _tzset();
#endif
    auto constexpr time_zone_detection = Isolate::TimeZoneDetection::kRedetect;
    isolate->DateTimeConfigurationChangeNotification(time_zone_detection);
  }
}

Maybe<std::string> RealEnvStore::Get(const char* key) const {
  Mutex::ScopedLock lock(per_process::env_var_mutex);

  size_t init_sz = 256;
  MaybeStackBuffer<char, 256> val;
  int ret = uv_os_getenv(key, *val, &init_sz);

  if (ret == UV_ENOBUFS) {
    // Buffer is not large enough, reallocate to the updated init_sz
    // and fetch env value again.
    val.AllocateSufficientStorage(init_sz);
    ret = uv_os_getenv(key, *val, &init_sz);
  }

  if (ret >= 0) {  // Env key value fetch success.
    return Just(std::string(*val, init_sz));
  }

  return Nothing<std::string>();
}

MaybeLocal<String> RealEnvStore::Get(Isolate* isolate,
                                     Local<String> property) const {
  node::Utf8Value key(isolate, property);
  Maybe<std::string> value = Get(*key);

  if (value.IsJust()) {
    std::string val = value.FromJust();
    return String::NewFromUtf8(
        isolate, val.data(), NewStringType::kNormal, val.size());
  }

  return MaybeLocal<String>();
}

void RealEnvStore::Set(Isolate* isolate,
                       Local<String> property,
                       Local<String> value) {
  Mutex::ScopedLock lock(per_process::env_var_mutex);

  node::Utf8Value key(isolate, property);
  node::Utf8Value val(isolate, value);

#ifdef _WIN32
  if (key.length() > 0 && key[0] == '=') return;
#endif
  uv_os_setenv(*key, *val);
  DateTimeConfigurationChangeNotification(isolate, key);
}

int32_t RealEnvStore::Query(const char* key) const {
  Mutex::ScopedLock lock(per_process::env_var_mutex);

  char val[2];
  size_t init_sz = sizeof(val);
  int ret = uv_os_getenv(key, val, &init_sz);

  if (ret == UV_ENOENT) {
    return -1;
  }

#ifdef _WIN32
  if (key[0] == '=') {
    return static_cast<int32_t>(ReadOnly) |
           static_cast<int32_t>(DontDelete) |
           static_cast<int32_t>(DontEnum);
  }
#endif

  return 0;
}

int32_t RealEnvStore::Query(Isolate* isolate, Local<String> property) const {
  node::Utf8Value key(isolate, property);
  return Query(*key);
}

void RealEnvStore::Delete(Isolate* isolate, Local<String> property) {
  Mutex::ScopedLock lock(per_process::env_var_mutex);

  node::Utf8Value key(isolate, property);
  uv_os_unsetenv(*key);
  DateTimeConfigurationChangeNotification(isolate, key);
}

Local<Array> RealEnvStore::Enumerate(Isolate* isolate) const {
  Mutex::ScopedLock lock(per_process::env_var_mutex);
  uv_env_item_t* items;
  int count;

  auto cleanup = OnScopeLeave([&]() { uv_os_free_environ(items, count); });
  CHECK_EQ(uv_os_environ(&items, &count), 0);

  MaybeStackBuffer<Local<Value>, 256> env_v(count);
  int env_v_index = 0;
  for (int i = 0; i < count; i++) {
#ifdef _WIN32
    // If the key starts with '=' it is a hidden environment variable.
    // The '\0' check is a workaround for the bug behind
    // https://github.com/libuv/libuv/pull/2473 and can be removed later.
    if (items[i].name[0] == '=' || items[i].name[0] == '\0') continue;
#endif
    MaybeLocal<String> str = String::NewFromUtf8(isolate, items[i].name);
    if (str.IsEmpty()) {
      isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
      return Local<Array>();
    }
    env_v[env_v_index++] = str.ToLocalChecked();
  }

  return Array::New(isolate, env_v.out(), env_v_index);
}

std::shared_ptr<KVStore> KVStore::Clone(Isolate* isolate) const {
  HandleScope handle_scope(isolate);
  Local<Context> context = isolate->GetCurrentContext();

  std::shared_ptr<KVStore> copy = KVStore::CreateMapKVStore();
  Local<Array> keys = Enumerate(isolate);
  uint32_t keys_length = keys->Length();
  for (uint32_t i = 0; i < keys_length; i++) {
    Local<Value> key = keys->Get(context, i).ToLocalChecked();
    CHECK(key->IsString());
    copy->Set(isolate,
              key.As<String>(),
              Get(isolate, key.As<String>()).ToLocalChecked());
  }
  return copy;
}

Maybe<std::string> MapKVStore::Get(const char* key) const {
  Mutex::ScopedLock lock(mutex_);
  auto it = map_.find(key);
  return it == map_.end() ? Nothing<std::string>() : Just(it->second);
}

MaybeLocal<String> MapKVStore::Get(Isolate* isolate, Local<String> key) const {
  Utf8Value str(isolate, key);
  Maybe<std::string> value = Get(*str);
  if (value.IsNothing()) return Local<String>();
  std::string val = value.FromJust();
  return String::NewFromUtf8(
      isolate, val.data(), NewStringType::kNormal, val.size());
}

void MapKVStore::Set(Isolate* isolate, Local<String> key, Local<String> value) {
  Mutex::ScopedLock lock(mutex_);
  Utf8Value key_str(isolate, key);
  Utf8Value value_str(isolate, value);
  if (*key_str != nullptr && key_str.length() > 0 && *value_str != nullptr) {
    map_[std::string(*key_str, key_str.length())] =
        std::string(*value_str, value_str.length());
  }
}

int32_t MapKVStore::Query(const char* key) const {
  Mutex::ScopedLock lock(mutex_);
  return map_.find(key) == map_.end() ? -1 : 0;
}

int32_t MapKVStore::Query(Isolate* isolate, Local<String> key) const {
  Utf8Value str(isolate, key);
  return Query(*str);
}

void MapKVStore::Delete(Isolate* isolate, Local<String> key) {
  Mutex::ScopedLock lock(mutex_);
  Utf8Value str(isolate, key);
  map_.erase(std::string(*str, str.length()));
}

Local<Array> MapKVStore::Enumerate(Isolate* isolate) const {
  Mutex::ScopedLock lock(mutex_);
  std::vector<Local<Value>> values;
  values.reserve(map_.size());
  for (const auto& pair : map_) {
    values.emplace_back(
        String::NewFromUtf8(isolate, pair.first.data(),
                            NewStringType::kNormal, pair.first.size())
            .ToLocalChecked());
  }
  return Array::New(isolate, values.data(), values.size());
}

std::shared_ptr<KVStore> MapKVStore::Clone(Isolate* isolate) const {
  return std::make_shared<MapKVStore>(*this);
}

std::shared_ptr<KVStore> KVStore::CreateMapKVStore() {
  return std::make_shared<MapKVStore>();
}

Maybe<bool> KVStore::AssignFromObject(Local<Context> context,
                                      Local<Object> entries) {
  Isolate* isolate = context->GetIsolate();
  HandleScope handle_scope(isolate);
  Local<Array> keys;
  if (!entries->GetOwnPropertyNames(context).ToLocal(&keys))
    return Nothing<bool>();
  uint32_t keys_length = keys->Length();
  for (uint32_t i = 0; i < keys_length; i++) {
    Local<Value> key;
    if (!keys->Get(context, i).ToLocal(&key))
      return Nothing<bool>();
    if (!key->IsString()) continue;

    Local<Value> value;
    Local<String> value_string;
    if (!entries->Get(context, key).ToLocal(&value) ||
        !value->ToString(context).ToLocal(&value_string)) {
      return Nothing<bool>();
    }

    Set(isolate, key.As<String>(), value_string);
  }
  return Just(true);
}

static void EnvGetter(Local<Name> property,
                      const PropertyCallbackInfo<Value>& info) {
  Environment* env = Environment::GetCurrent(info);
  CHECK(env->has_run_bootstrapping_code());
  if (property->IsSymbol()) {
    return info.GetReturnValue().SetUndefined();
  }
  CHECK(property->IsString());
  MaybeLocal<String> value_string =
      env->env_vars()->Get(env->isolate(), property.As<String>());
  if (!value_string.IsEmpty()) {
    info.GetReturnValue().Set(value_string.ToLocalChecked());
  }
}

static void EnvSetter(Local<Name> property,
                      Local<Value> value,
                      const PropertyCallbackInfo<Value>& info) {
  Environment* env = Environment::GetCurrent(info);
  CHECK(env->has_run_bootstrapping_code());
  // calling env->EmitProcessEnvWarning() sets a variable indicating that
  // warnings have been emitted. It should be called last after other
  // conditions leading to a warning have been met.
  if (env->options()->pending_deprecation && !value->IsString() &&
      !value->IsNumber() && !value->IsBoolean() &&
      env->EmitProcessEnvWarning()) {
    if (ProcessEmitDeprecationWarning(
            env,
            "Assigning any value other than a string, number, or boolean to a "
            "process.env property is deprecated. Please make sure to convert "
            "the "
            "value to a string before setting process.env with it.",
            "DEP0104")
            .IsNothing())
      return;
  }

  Local<String> key;
  Local<String> value_string;
  if (!property->ToString(env->context()).ToLocal(&key) ||
      !value->ToString(env->context()).ToLocal(&value_string)) {
    return;
  }

  env->env_vars()->Set(env->isolate(), key, value_string);

  // Whether it worked or not, always return value.
  info.GetReturnValue().Set(value);
}

static void EnvQuery(Local<Name> property,
                     const PropertyCallbackInfo<Integer>& info) {
  Environment* env = Environment::GetCurrent(info);
  CHECK(env->has_run_bootstrapping_code());
  if (property->IsString()) {
    int32_t rc = env->env_vars()->Query(env->isolate(), property.As<String>());
    if (rc != -1) info.GetReturnValue().Set(rc);
  }
}

static void EnvDeleter(Local<Name> property,
                       const PropertyCallbackInfo<Boolean>& info) {
  Environment* env = Environment::GetCurrent(info);
  CHECK(env->has_run_bootstrapping_code());
  if (property->IsString()) {
    env->env_vars()->Delete(env->isolate(), property.As<String>());
  }

  // process.env never has non-configurable properties, so always
  // return true like the tc39 delete operator.
  info.GetReturnValue().Set(true);
}

static void EnvEnumerator(const PropertyCallbackInfo<Array>& info) {
  Environment* env = Environment::GetCurrent(info);
  CHECK(env->has_run_bootstrapping_code());

  info.GetReturnValue().Set(
      env->env_vars()->Enumerate(env->isolate()));
}

MaybeLocal<Object> CreateEnvVarProxy(Local<Context> context, Isolate* isolate) {
  EscapableHandleScope scope(isolate);
  Local<ObjectTemplate> env_proxy_template = ObjectTemplate::New(isolate);
  env_proxy_template->SetHandler(NamedPropertyHandlerConfiguration(
      EnvGetter, EnvSetter, EnvQuery, EnvDeleter, EnvEnumerator, Local<Value>(),
      PropertyHandlerFlags::kHasNoSideEffect));
  return scope.EscapeMaybe(env_proxy_template->NewInstance(context));
}

void RegisterEnvVarExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(EnvGetter);
  registry->Register(EnvSetter);
  registry->Register(EnvQuery);
  registry->Register(EnvDeleter);
  registry->Register(EnvEnumerator);
}
}  // namespace node

NODE_MODULE_EXTERNAL_REFERENCE(env_var, node::RegisterEnvVarExternalReferences)


Generated by: GCOVR (Version 3.4)

Line	Branch	Exec	Source
1			#include "debug_utils-inl.h"
2			#include "env-inl.h"
3			#include "node_errors.h"
4			#include "node_external_reference.h"
5			#include "node_process.h"
6
7			#include <time.h> // tzset(), _tzset()
8
9			namespace node {
10			using v8::Array;
11			using v8::Boolean;
12			using v8::Context;
13			using v8::DontDelete;
14			using v8::DontEnum;
15			using v8::EscapableHandleScope;
16			using v8::HandleScope;
17			using v8::Integer;
18			using v8::Isolate;
19			using v8::Just;
20			using v8::Local;
21			using v8::Maybe;
22			using v8::MaybeLocal;
23			using v8::Name;
24			using v8::NamedPropertyHandlerConfiguration;
25			using v8::NewStringType;
26			using v8::Nothing;
27			using v8::Object;
28			using v8::ObjectTemplate;
29			using v8::PropertyCallbackInfo;
30			using v8::PropertyHandlerFlags;
31			using v8::ReadOnly;
32			using v8::String;
33			using v8::Value;
34
35		8885	class RealEnvStore final : public KVStore {
36			public:
37			MaybeLocal<String> Get(Isolate* isolate, Local<String> key) const override;
38			Maybe<std::string> Get(const char* key) const override;
39			void Set(Isolate* isolate, Local<String> key, Local<String> value) override;
40			int32_t Query(Isolate* isolate, Local<String> key) const override;
41			int32_t Query(const char* key) const override;
42			void Delete(Isolate* isolate, Local<String> key) override;
43			Local<Array> Enumerate(Isolate* isolate) const override;
44			};
45
46		633	class MapKVStore final : public KVStore {
47			public:
48			MaybeLocal<String> Get(Isolate* isolate, Local<String> key) const override;
49			Maybe<std::string> Get(const char* key) const override;
50			void Set(Isolate* isolate, Local<String> key, Local<String> value) override;
51			int32_t Query(Isolate* isolate, Local<String> key) const override;
52			int32_t Query(const char* key) const override;
53			void Delete(Isolate* isolate, Local<String> key) override;
54			Local<Array> Enumerate(Isolate* isolate) const override;
55
56			std::shared_ptr<KVStore> Clone(Isolate* isolate) const override;
57
58		626	MapKVStore() = default;
59		7	MapKVStore(const MapKVStore& other) : KVStore(), map_(other.map_) {}
60
61			private:
62			mutable Mutex mutex_;
63			std::unordered_map<std::string, std::string> map_;
64			};
65
66			namespace per_process {
67		4678	Mutex env_var_mutex;
68		4678	std::shared_ptr<KVStore> system_environment = std::make_shared<RealEnvStore>();
69			} // namespace per_process
70
71			template <typename T>
72		7595	void DateTimeConfigurationChangeNotification(Isolate* isolate, const T& key) {
73	✓✓✓✗ ✓✗✓✓	7595	if (key.length() == 2 && key[0] == 'T' && key[1] == 'Z') {
74			#ifdef __POSIX__
75		4	tzset();
76			#else
77			_tzset();
78			#endif
79		4	auto constexpr time_zone_detection = Isolate::TimeZoneDetection::kRedetect;
80		4	isolate->DateTimeConfigurationChangeNotification(time_zone_detection);
81			}
82		7595	}
83
84		583977	Maybe<std::string> RealEnvStore::Get(const char* key) const {
85		1167954	Mutex::ScopedLock lock(per_process::env_var_mutex);
86
87		583977	size_t init_sz = 256;
88		1167954	MaybeStackBuffer<char, 256> val;
89		583977	int ret = uv_os_getenv(key, *val, &init_sz);
90
91	✓✓	583977	if (ret == UV_ENOBUFS) {
92			// Buffer is not large enough, reallocate to the updated init_sz
93			// and fetch env value again.
94		6034	val.AllocateSufficientStorage(init_sz);
95		6034	ret = uv_os_getenv(key, *val, &init_sz);
96			}
97
98	✓✓	583977	if (ret >= 0) { // Env key value fetch success.
99		523867	return Just(std::string(*val, init_sz));
100			}
101
102		60110	return Nothing<std::string>();
103			}
104
105		583976	MaybeLocal<String> RealEnvStore::Get(Isolate* isolate,
106			Local<String> property) const {
107		1167953	node::Utf8Value key(isolate, property);
108		1167954	Maybe<std::string> value = Get(*key);
109
110	✓✓	583977	if (value.IsJust()) {
111		523867	std::string val = value.FromJust();
112			return String::NewFromUtf8(
113		523867	isolate, val.data(), NewStringType::kNormal, val.size());
114			}
115
116		60110	return MaybeLocal<String>();
117			}
118
119		6576	void RealEnvStore::Set(Isolate* isolate,
120			Local<String> property,
121			Local<String> value) {
122		13152	Mutex::ScopedLock lock(per_process::env_var_mutex);
123
124		13152	node::Utf8Value key(isolate, property);
125		13152	node::Utf8Value val(isolate, value);
126
127			#ifdef _WIN32
128			if (key.length() > 0 && key[0] == '=') return;
129			#endif
130		6576	uv_os_setenv(key, val);
131		6576	DateTimeConfigurationChangeNotification(isolate, key);
132		6576	}
133
134		638687	int32_t RealEnvStore::Query(const char* key) const {
135		1277374	Mutex::ScopedLock lock(per_process::env_var_mutex);
136
137			char val[2];
138		638687	size_t init_sz = sizeof(val);
139		638687	int ret = uv_os_getenv(key, val, &init_sz);
140
141	✓✓	638687	if (ret == UV_ENOENT) {
142		5664	return -1;
143			}
144
145			#ifdef _WIN32
146			if (key[0] == '=') {
147			return static_cast<int32_t>(ReadOnly) \|
148			static_cast<int32_t>(DontDelete) \|
149			static_cast<int32_t>(DontEnum);
150			}
151			#endif
152
153		633023	return 0;
154			}
155
156		638687	int32_t RealEnvStore::Query(Isolate* isolate, Local<String> property) const {
157		1277374	node::Utf8Value key(isolate, property);
158		1277374	return Query(*key);
159			}
160
161		1019	void RealEnvStore::Delete(Isolate* isolate, Local<String> property) {
162		2038	Mutex::ScopedLock lock(per_process::env_var_mutex);
163
164		2038	node::Utf8Value key(isolate, property);
165		1019	uv_os_unsetenv(*key);
166		1019	DateTimeConfigurationChangeNotification(isolate, key);
167		1019	}
168
169		7765	Local<Array> RealEnvStore::Enumerate(Isolate* isolate) const {
170		15530	Mutex::ScopedLock lock(per_process::env_var_mutex);
171			uv_env_item_t* items;
172			int count;
173
174		23295	auto cleanup = OnScopeLeave([&]() { uv_os_free_environ(items, count); });
175	✗✓	7765	CHECK_EQ(uv_os_environ(&items, &count), 0);
176
177		15530	MaybeStackBuffer<Local<Value>, 256> env_v(count);
178		7765	int env_v_index = 0;
179	✓✓	567705	for (int i = 0; i < count; i++) {
180			#ifdef _WIN32
181			// If the key starts with '=' it is a hidden environment variable.
182			// The '\0' check is a workaround for the bug behind
183			// https://github.com/libuv/libuv/pull/2473 and can be removed later.
184			if (items[i].name[0] == '=' \|\| items[i].name[0] == '\0') continue;
185			#endif
186		559940	MaybeLocal<String> str = String::NewFromUtf8(isolate, items[i].name);
187	✗✓	559940	if (str.IsEmpty()) {
188			isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
189			return Local<Array>();
190			}
191		1119880	env_v[env_v_index++] = str.ToLocalChecked();
192			}
193
194		7765	return Array::New(isolate, env_v.out(), env_v_index);
195			}
196
197		602	std::shared_ptr<KVStore> KVStore::Clone(Isolate* isolate) const {
198		1204	HandleScope handle_scope(isolate);
199		602	Local<Context> context = isolate->GetCurrentContext();
200
201		602	std::shared_ptr<KVStore> copy = KVStore::CreateMapKVStore();
202		602	Local<Array> keys = Enumerate(isolate);
203		602	uint32_t keys_length = keys->Length();
204	✓✓	43387	for (uint32_t i = 0; i < keys_length; i++) {
205		85570	Local<Value> key = keys->Get(context, i).ToLocalChecked();
206	✗✓	85570	CHECK(key->IsString());
207		42785	copy->Set(isolate,
208			key.As<String>(),
209		128355	Get(isolate, key.As<String>()).ToLocalChecked());
210			}
211		1204	return copy;
212			}
213
214		31085	Maybe<std::string> MapKVStore::Get(const char* key) const {
215		62170	Mutex::ScopedLock lock(mutex_);
216		31085	auto it = map_.find(key);
217	✓✓	62170	return it == map_.end() ? Nothing<std::string>() : Just(it->second);
218			}
219
220		30673	MaybeLocal<String> MapKVStore::Get(Isolate* isolate, Local<String> key) const {
221		61346	Utf8Value str(isolate, key);
222		61346	Maybe<std::string> value = Get(*str);
223	✓✓	32792	if (value.IsNothing()) return Local<String>();
224		28554	std::string val = value.FromJust();
225			return String::NewFromUtf8(
226		28554	isolate, val.data(), NewStringType::kNormal, val.size());
227			}
228
229		44427	void MapKVStore::Set(Isolate* isolate, Local<String> key, Local<String> value) {
230		88854	Mutex::ScopedLock lock(mutex_);
231		88854	Utf8Value key_str(isolate, key);
232		88854	Utf8Value value_str(isolate, value);
233	✓✗✓✗ ✓✗✓✗	44427	if (key_str != nullptr && key_str.length() > 0 && value_str != nullptr) {
234		88854	map_[std::string(*key_str, key_str.length())] =
235		133281	std::string(*value_str, value_str.length());
236			}
237		44427	}
238
239		52861	int32_t MapKVStore::Query(const char* key) const {
240		105722	Mutex::ScopedLock lock(mutex_);
241	✓✓	105722	return map_.find(key) == map_.end() ? -1 : 0;
242			}
243
244		52861	int32_t MapKVStore::Query(Isolate* isolate, Local<String> key) const {
245		105722	Utf8Value str(isolate, key);
246		105722	return Query(*str);
247			}
248
249			void MapKVStore::Delete(Isolate* isolate, Local<String> key) {
250			Mutex::ScopedLock lock(mutex_);
251			Utf8Value str(isolate, key);
252			map_.erase(std::string(*str, str.length()));
253			}
254
255		720	Local<Array> MapKVStore::Enumerate(Isolate* isolate) const {
256		1440	Mutex::ScopedLock lock(mutex_);
257		1440	std::vector<Local<Value>> values;
258		720	values.reserve(map_.size());
259	✓✓	53003	for (const auto& pair : map_) {
260			values.emplace_back(
261		104566	String::NewFromUtf8(isolate, pair.first.data(),
262		52283	NewStringType::kNormal, pair.first.size())
263		52283	.ToLocalChecked());
264			}
265		1440	return Array::New(isolate, values.data(), values.size());
266			}
267
268		7	std::shared_ptr<KVStore> MapKVStore::Clone(Isolate* isolate) const {
269		7	return std::make_shared<MapKVStore>(*this);
270			}
271
272		626	std::shared_ptr<KVStore> KVStore::CreateMapKVStore() {
273		626	return std::make_shared<MapKVStore>();
274			}
275
276		24	Maybe<bool> KVStore::AssignFromObject(Local<Context> context,
277			Local<Object> entries) {
278		24	Isolate* isolate = context->GetIsolate();
279		48	HandleScope handle_scope(isolate);
280			Local<Array> keys;
281	✗✓	48	if (!entries->GetOwnPropertyNames(context).ToLocal(&keys))
282			return Nothing<bool>();
283		24	uint32_t keys_length = keys->Length();
284	✓✓	1660	for (uint32_t i = 0; i < keys_length; i++) {
285			Local<Value> key;
286	✗✓	3272	if (!keys->Get(context, i).ToLocal(&key))
287			return Nothing<bool>();
288	✗✓	3272	if (!key->IsString()) continue;
289
290			Local<Value> value;
291			Local<String> value_string;
292	✓✗✗✓ ✗✓	6544	if (!entries->Get(context, key).ToLocal(&value) \|\|
293		4908	!value->ToString(context).ToLocal(&value_string)) {
294			return Nothing<bool>();
295			}
296
297		3272	Set(isolate, key.As<String>(), value_string);
298			}
299		24	return Just(true);
300			}
301
302		559342	static void EnvGetter(Local<Name> property,
303			const PropertyCallbackInfo<Value>& info) {
304		559342	Environment* env = Environment::GetCurrent(info);
305	✗✓	559342	CHECK(env->has_run_bootstrapping_code());
306	✓✓	559342	if (property->IsSymbol()) {
307		16044	return info.GetReturnValue().SetUndefined();
308			}
309	✗✓	1102638	CHECK(property->IsString());
310			MaybeLocal<String> value_string =
311		1102639	env->env_vars()->Get(env->isolate(), property.As<String>());
312	✓✓	551320	if (!value_string.IsEmpty()) {
313		998722	info.GetReturnValue().Set(value_string.ToLocalChecked());
314			}
315			}
316
317		6584	static void EnvSetter(Local<Name> property,
318			Local<Value> value,
319			const PropertyCallbackInfo<Value>& info) {
320		6584	Environment* env = Environment::GetCurrent(info);
321	✗✓	6584	CHECK(env->has_run_bootstrapping_code());
322			// calling env->EmitProcessEnvWarning() sets a variable indicating that
323			// warnings have been emitted. It should be called last after other
324			// conditions leading to a warning have been met.
325	✓✓✓✗ ✓✗✓✓	19795	if (env->options()->pending_deprecation && !value->IsString() &&
326	✓✓✓✗ ✓✗	19755	!value->IsNumber() && !value->IsBoolean() &&
327		1	env->EmitProcessEnvWarning()) {
328	✗✓	2	if (ProcessEmitDeprecationWarning(
329			env,
330			"Assigning any value other than a string, number, or boolean to a "
331			"process.env property is deprecated. Please make sure to convert "
332			"the "
333			"value to a string before setting process.env with it.",
334			"DEP0104")
335			.IsNothing())
336		2	return;
337			}
338
339			Local<String> key;
340			Local<String> value_string;
341	✓✓✓✓ ✓✓	32919	if (!property->ToString(env->context()).ToLocal(&key) \|\|
342		26333	!value->ToString(env->context()).ToLocal(&value_string)) {
343		2	return;
344			}
345
346		6582	env->env_vars()->Set(env->isolate(), key, value_string);
347
348			// Whether it worked or not, always return value.
349		13164	info.GetReturnValue().Set(value);
350			}
351
352		691549	static void EnvQuery(Local<Name> property,
353			const PropertyCallbackInfo<Integer>& info) {
354		691549	Environment* env = Environment::GetCurrent(info);
355	✗✓	691549	CHECK(env->has_run_bootstrapping_code());
356	✓✓	1383098	if (property->IsString()) {
357		1383096	int32_t rc = env->env_vars()->Query(env->isolate(), property.As<String>());
358	✓✓	2062592	if (rc != -1) info.GetReturnValue().Set(rc);
359			}
360		691549	}
361
362		1020	static void EnvDeleter(Local<Name> property,
363			const PropertyCallbackInfo<Boolean>& info) {
364		1020	Environment* env = Environment::GetCurrent(info);
365	✗✓	1020	CHECK(env->has_run_bootstrapping_code());
366	✓✓	2040	if (property->IsString()) {
367		2038	env->env_vars()->Delete(env->isolate(), property.As<String>());
368			}
369
370			// process.env never has non-configurable properties, so always
371			// return true like the tc39 delete operator.
372		2040	info.GetReturnValue().Set(true);
373		1020	}
374
375		7883	static void EnvEnumerator(const PropertyCallbackInfo<Array>& info) {
376		7883	Environment* env = Environment::GetCurrent(info);
377	✗✓	7883	CHECK(env->has_run_bootstrapping_code());
378
379		23649	info.GetReturnValue().Set(
380		15766	env->env_vars()->Enumerate(env->isolate()));
381		7883	}
382
383		445	MaybeLocal<Object> CreateEnvVarProxy(Local<Context> context, Isolate* isolate) {
384		445	EscapableHandleScope scope(isolate);
385		445	Local<ObjectTemplate> env_proxy_template = ObjectTemplate::New(isolate);
386		1335	env_proxy_template->SetHandler(NamedPropertyHandlerConfiguration(
387			EnvGetter, EnvSetter, EnvQuery, EnvDeleter, EnvEnumerator, Local<Value>(),
388		445	PropertyHandlerFlags::kHasNoSideEffect));
389		890	return scope.EscapeMaybe(env_proxy_template->NewInstance(context));
390			}
391
392		4601	void RegisterEnvVarExternalReferences(ExternalReferenceRegistry* registry) {
393		4601	registry->Register(EnvGetter);
394		4601	registry->Register(EnvSetter);
395		4601	registry->Register(EnvQuery);
396		4601	registry->Register(EnvDeleter);
397		4601	registry->Register(EnvEnumerator);
398		4601	}
399			} // namespace node
400
401	✓✗✓✗	18635	NODE_MODULE_EXTERNAL_REFERENCE(env_var, node::RegisterEnvVarExternalReferences)