Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	uv.cc	Lines:	46	48	95.8 %
Date:	2022-09-19 04:21:54	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);
  char name[50];
  uv_err_name_r(err, name, sizeof(name));
  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();
  SetConstructorFunction(
      context, target, "errname", NewFunctionTemplate(isolate, 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();
  }

  SetMethod(context, 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		166	void ErrName(const FunctionCallbackInfo<Value>& args) {
63		166	Environment* env = Environment::GetCurrent(args);
64	✓✓✓✗ ✓✗✓✓	166	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	✗✓	332	if (!args[0]->Int32Value(env->context()).To(&err)) return;
75	✗✓	166	CHECK_LT(err, 0);
76			char name[50];
77		166	uv_err_name_r(err, name, sizeof(name));
78		332	args.GetReturnValue().Set(OneByteString(env->isolate(), name));
79			}
80
81		593	void GetErrMap(const FunctionCallbackInfo<Value>& args) {
82		593	Environment* env = Environment::GetCurrent(args);
83		593	Isolate* isolate = env->isolate();
84		593	Local<Context> context = env->context();
85
86			// This can't return a SafeMap, because the uv binding can be referenced
87			// by user code by using `process.binding('uv').getErrorMap()`:
88		593	Local<Map> err_map = Map::New(isolate);
89
90		593	size_t errors_len = arraysize(per_process::uv_errors_map);
91	✓✓	49219	for (size_t i = 0; i < errors_len; ++i) {
92		48626	const auto& error = per_process::uv_errors_map[i];
93		48626	Local<Value> arr[] = {OneByteString(isolate, error.name),
94		145878	OneByteString(isolate, error.message)};
95		48626	if (err_map
96		48626	->Set(context,
97		48626	Integer::New(isolate, error.value),
98		145878	Array::New(isolate, arr, arraysize(arr)))
99	✗✓	48626	.IsEmpty()) {
100			return;
101			}
102			}
103
104		1186	args.GetReturnValue().Set(err_map);
105			}
106
107		788	void Initialize(Local<Object> target,
108			Local<Value> unused,
109			Local<Context> context,
110			void* priv) {
111		788	Environment* env = Environment::GetCurrent(context);
112		788	Isolate* isolate = env->isolate();
113		788	SetConstructorFunction(
114			context, target, "errname", NewFunctionTemplate(isolate, ErrName));
115
116			// TODO(joyeecheung): This should be deprecated in user land in favor of
117			// `util.getSystemErrorName(err)`.
118		788	PropertyAttribute attributes =
119			static_cast<PropertyAttribute>(ReadOnly \| DontDelete);
120		788	size_t errors_len = arraysize(per_process::uv_errors_map);
121		1576	const std::string prefix = "UV_";
122	✓✓	65404	for (size_t i = 0; i < errors_len; ++i) {
123		64616	const auto& error = per_process::uv_errors_map[i];
124		64616	const std::string prefixed_name = prefix + error.name;
125		64616	Local<String> name = OneByteString(isolate, prefixed_name.c_str());
126		64616	Local<Integer> value = Integer::New(isolate, error.value);
127		129232	target->DefineOwnProperty(context, name, value, attributes).Check();
128			}
129
130		788	SetMethod(context, target, "getErrorMap", GetErrMap);
131		788	}
132
133		5528	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
134		5528	registry->Register(ErrName);
135		5528	registry->Register(GetErrMap);
136		5528	}
137			} // namespace uv
138			} // namespace node
139
140		5598	NODE_MODULE_CONTEXT_AWARE_INTERNAL(uv, node::uv::Initialize)
141		5528	NODE_MODULE_EXTERNAL_REFERENCE(uv, node::uv::RegisterExternalReferences)