Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	uv.cc	Lines:	46	48	95.8 %
Date:	2022-06-06 04:15:48	Branches:	14	20	70.0 %


// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

#include "uv.h"
#include "env-inl.h"
#include "node.h"
#include "node_external_reference.h"
#include "node_process-inl.h"

namespace node {

namespace per_process {
struct UVError {
  int value;
  const char* name;
  const char* message;
};

// We only expand the macro once here to reduce the amount of code
// generated.
static const struct UVError uv_errors_map[] = {
#define V(name, message) {UV_##name, #name, message},
    UV_ERRNO_MAP(V)
#undef V
};
}  // namespace per_process

namespace uv {

using v8::Array;
using v8::Context;
using v8::DontDelete;
using v8::FunctionCallbackInfo;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Map;
using v8::Object;
using v8::PropertyAttribute;
using v8::ReadOnly;
using v8::String;
using v8::Value;

void ErrName(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  if (env->options()->pending_deprecation && env->EmitErrNameWarning()) {
    if (ProcessEmitDeprecationWarning(
        env,
        "Directly calling process.binding('uv').errname(<val>) is being"
        " deprecated. "
        "Please make sure to use util.getSystemErrorName() instead.",
        "DEP0119").IsNothing())
    return;
  }
  int err;
  if (!args[0]->Int32Value(env->context()).To(&err)) return;
  CHECK_LT(err, 0);
  const char* name = uv_err_name(err);
  args.GetReturnValue().Set(OneByteString(env->isolate(), name));
}

void GetErrMap(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  Isolate* isolate = env->isolate();
  Local<Context> context = env->context();

  // This can't return a SafeMap, because the uv binding can be referenced
  // by user code by using `process.binding('uv').getErrorMap()`:
  Local<Map> err_map = Map::New(isolate);

  size_t errors_len = arraysize(per_process::uv_errors_map);
  for (size_t i = 0; i < errors_len; ++i) {
    const auto& error = per_process::uv_errors_map[i];
    Local<Value> arr[] = {OneByteString(isolate, error.name),
                          OneByteString(isolate, error.message)};
    if (err_map
            ->Set(context,
                  Integer::New(isolate, error.value),
                  Array::New(isolate, arr, arraysize(arr)))
            .IsEmpty()) {
      return;
    }
  }

  args.GetReturnValue().Set(err_map);
}

void Initialize(Local<Object> target,
                Local<Value> unused,
                Local<Context> context,
                void* priv) {
  Environment* env = Environment::GetCurrent(context);
  Isolate* isolate = env->isolate();
  env->SetConstructorFunction(
      target,
      "errname",
      env->NewFunctionTemplate(ErrName));

  // TODO(joyeecheung): This should be deprecated in user land in favor of
  // `util.getSystemErrorName(err)`.
  PropertyAttribute attributes =
      static_cast<PropertyAttribute>(ReadOnly | DontDelete);
  size_t errors_len = arraysize(per_process::uv_errors_map);
  const std::string prefix = "UV_";
  for (size_t i = 0; i < errors_len; ++i) {
    const auto& error = per_process::uv_errors_map[i];
    const std::string prefixed_name = prefix + error.name;
    Local<String> name = OneByteString(isolate, prefixed_name.c_str());
    Local<Integer> value = Integer::New(isolate, error.value);
    target->DefineOwnProperty(context, name, value, attributes).Check();
  }

  env->SetMethod(target, "getErrorMap", GetErrMap);
}

void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(ErrName);
  registry->Register(GetErrMap);
}
}  // namespace uv
}  // namespace node

NODE_MODULE_CONTEXT_AWARE_INTERNAL(uv, node::uv::Initialize)
NODE_MODULE_EXTERNAL_REFERENCE(uv, node::uv::RegisterExternalReferences)


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			// Copyright Joyent, Inc. and other Node contributors.
2			//
3			// Permission is hereby granted, free of charge, to any person obtaining a
4			// copy of this software and associated documentation files (the
5			// "Software"), to deal in the Software without restriction, including
6			// without limitation the rights to use, copy, modify, merge, publish,
7			// distribute, sublicense, and/or sell copies of the Software, and to permit
8			// persons to whom the Software is furnished to do so, subject to the
9			// following conditions:
10			//
11			// The above copyright notice and this permission notice shall be included
12			// in all copies or substantial portions of the Software.
13			//
14			// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15			// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16			// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17			// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18			// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19			// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20			// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22			#include "uv.h"
23			#include "env-inl.h"
24			#include "node.h"
25			#include "node_external_reference.h"
26			#include "node_process-inl.h"
27
28			namespace node {
29
30			namespace per_process {
31			struct UVError {
32			int value;
33			const char* name;
34			const char* message;
35			};
36
37			// We only expand the macro once here to reduce the amount of code
38			// generated.
39			static const struct UVError uv_errors_map[] = {
40			#define V(name, message) {UV_##name, #name, message},
41			UV_ERRNO_MAP(V)
42			#undef V
43			};
44			} // namespace per_process
45
46			namespace uv {
47
48			using v8::Array;
49			using v8::Context;
50			using v8::DontDelete;
51			using v8::FunctionCallbackInfo;
52			using v8::Integer;
53			using v8::Isolate;
54			using v8::Local;
55			using v8::Map;
56			using v8::Object;
57			using v8::PropertyAttribute;
58			using v8::ReadOnly;
59			using v8::String;
60			using v8::Value;
61
62		165	void ErrName(const FunctionCallbackInfo<Value>& args) {
63		165	Environment* env = Environment::GetCurrent(args);
64	✓✓✓✗ ✓✗✓✓	165	if (env->options()->pending_deprecation && env->EmitErrNameWarning()) {
65		1	if (ProcessEmitDeprecationWarning(
66			env,
67			"Directly calling process.binding('uv').errname(<val>) is being"
68			" deprecated. "
69			"Please make sure to use util.getSystemErrorName() instead.",
70	✗✓	2	"DEP0119").IsNothing())
71			return;
72			}
73			int err;
74	✗✓	330	if (!args[0]->Int32Value(env->context()).To(&err)) return;
75	✗✓	165	CHECK_LT(err, 0);
76		165	const char* name = uv_err_name(err);
77		330	args.GetReturnValue().Set(OneByteString(env->isolate(), name));
78			}
79
80		548	void GetErrMap(const FunctionCallbackInfo<Value>& args) {
81		548	Environment* env = Environment::GetCurrent(args);
82		548	Isolate* isolate = env->isolate();
83		548	Local<Context> context = env->context();
84
85			// This can't return a SafeMap, because the uv binding can be referenced
86			// by user code by using `process.binding('uv').getErrorMap()`:
87		548	Local<Map> err_map = Map::New(isolate);
88
89		548	size_t errors_len = arraysize(per_process::uv_errors_map);
90	✓✓	45484	for (size_t i = 0; i < errors_len; ++i) {
91		44936	const auto& error = per_process::uv_errors_map[i];
92		44936	Local<Value> arr[] = {OneByteString(isolate, error.name),
93		134808	OneByteString(isolate, error.message)};
94		44936	if (err_map
95		44936	->Set(context,
96		44936	Integer::New(isolate, error.value),
97		134808	Array::New(isolate, arr, arraysize(arr)))
98	✗✓	44936	.IsEmpty()) {
99			return;
100			}
101			}
102
103		1096	args.GetReturnValue().Set(err_map);
104			}
105
106		854	void Initialize(Local<Object> target,
107			Local<Value> unused,
108			Local<Context> context,
109			void* priv) {
110		854	Environment* env = Environment::GetCurrent(context);
111		854	Isolate* isolate = env->isolate();
112		854	env->SetConstructorFunction(
113			target,
114			"errname",
115			env->NewFunctionTemplate(ErrName));
116
117			// TODO(joyeecheung): This should be deprecated in user land in favor of
118			// `util.getSystemErrorName(err)`.
119		854	PropertyAttribute attributes =
120			static_cast<PropertyAttribute>(ReadOnly \| DontDelete);
121		854	size_t errors_len = arraysize(per_process::uv_errors_map);
122		1708	const std::string prefix = "UV_";
123	✓✓	70882	for (size_t i = 0; i < errors_len; ++i) {
124		70028	const auto& error = per_process::uv_errors_map[i];
125		70028	const std::string prefixed_name = prefix + error.name;
126		70028	Local<String> name = OneByteString(isolate, prefixed_name.c_str());
127		70028	Local<Integer> value = Integer::New(isolate, error.value);
128		140056	target->DefineOwnProperty(context, name, value, attributes).Check();
129			}
130
131		854	env->SetMethod(target, "getErrorMap", GetErrMap);
132		854	}
133
134		5206	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
135		5206	registry->Register(ErrName);
136		5206	registry->Register(GetErrMap);
137		5206	}
138			} // namespace uv
139			} // namespace node
140
141		5274	NODE_MODULE_CONTEXT_AWARE_INTERNAL(uv, node::uv::Initialize)
142		5206	NODE_MODULE_EXTERNAL_REFERENCE(uv, node::uv::RegisterExternalReferences)