Head

GCC Code Coverage Report

Directory:	../		Exec	Total	Coverage
File:	/home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/util.cc	Lines:	101	113	89.4 %
Date:	2019-09-24 22:36:24	Branches:	21	38	55.3 %


// 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 "util.h"  // NOLINT(build/include_inline)
#include "util-inl.h"

#include "env-inl.h"
#include "node_buffer.h"
#include "node_errors.h"
#include "node_internals.h"
#include "string_bytes.h"
#include "uv.h"

#ifdef _WIN32
#include <io.h>  // _S_IREAD _S_IWRITE
#include <time.h>
#ifndef S_IRUSR
#define S_IRUSR _S_IREAD
#endif  // S_IRUSR
#ifndef S_IWUSR
#define S_IWUSR _S_IWRITE
#endif  // S_IWUSR
#else
#include <sys/time.h>
#include <sys/types.h>
#endif

#include <atomic>
#include <cstdio>
#include <iomanip>
#include <sstream>

static std::atomic_int seq = {0};  // Sequence number for diagnostic filenames.

namespace node {

using v8::ArrayBufferView;
using v8::Isolate;
using v8::Local;
using v8::String;
using v8::Value;

template <typename T>
static void MakeUtf8String(Isolate* isolate,
                           Local<Value> value,
                           T* target) {
  Local<String> string;
  if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;

  size_t storage;
  if (!StringBytes::StorageSize(isolate, string, UTF8).To(&storage)) return;
  storage += 1;
  target->AllocateSufficientStorage(storage);
  const int flags =
      String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8;
  const int length =
      string->WriteUtf8(isolate, target->out(), storage, nullptr, flags);
  target->SetLengthAndZeroTerminate(length);
}

Utf8Value::Utf8Value(Isolate* isolate, Local<Value> value) {
  if (value.IsEmpty())
    return;

  MakeUtf8String(isolate, value, this);
}


TwoByteValue::TwoByteValue(Isolate* isolate, Local<Value> value) {
  if (value.IsEmpty()) {
    return;
  }

  Local<String> string;
  if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;

  // Allocate enough space to include the null terminator
  const size_t storage = string->Length() + 1;
  AllocateSufficientStorage(storage);

  const int flags = String::NO_NULL_TERMINATION;
  const int length = string->Write(isolate, out(), 0, storage, flags);
  SetLengthAndZeroTerminate(length);
}

BufferValue::BufferValue(Isolate* isolate, Local<Value> value) {
  // Slightly different take on Utf8Value. If value is a String,
  // it will return a Utf8 encoded string. If value is a Buffer,
  // it will copy the data out of the Buffer as is.
  if (value.IsEmpty()) {
    // Dereferencing this object will return nullptr.
    Invalidate();
    return;
  }

  if (value->IsString()) {
    MakeUtf8String(isolate, value, this);
  } else if (value->IsArrayBufferView()) {
    const size_t len = value.As<ArrayBufferView>()->ByteLength();
    // Leave place for the terminating '\0' byte.
    AllocateSufficientStorage(len + 1);
    value.As<ArrayBufferView>()->CopyContents(out(), len);
    SetLengthAndZeroTerminate(len);
  } else {
    Invalidate();
  }
}

void LowMemoryNotification() {
  if (per_process::v8_initialized) {
    auto isolate = Isolate::GetCurrent();
    if (isolate != nullptr) {
      isolate->LowMemoryNotification();
    }
  }
}

std::string GetHumanReadableProcessName() {
  char name[1024];
  GetHumanReadableProcessName(&name);
  return name;
}

void GetHumanReadableProcessName(char (*name)[1024]) {
  // Leave room after title for pid, which can be up to 20 digits for 64 bit.
  char title[1000] = "Node.js";
  uv_get_process_title(title, sizeof(title));
  snprintf(*name, sizeof(*name), "%s[%d]", title, uv_os_getpid());
}

std::vector<std::string> SplitString(const std::string& in, char delim) {
  std::vector<std::string> out;
  if (in.empty())
    return out;
  std::istringstream in_stream(in);
  while (in_stream.good()) {
    std::string item;
    std::getline(in_stream, item, delim);
    if (item.empty()) continue;
    out.emplace_back(std::move(item));
  }
  return out;
}

void ThrowErrStringTooLong(Isolate* isolate) {
  isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
}

double GetCurrentTimeInMicroseconds() {
  constexpr double kMicrosecondsPerSecond = 1e6;
  uv_timeval64_t tv;
  CHECK_EQ(0, uv_gettimeofday(&tv));
  return kMicrosecondsPerSecond * tv.tv_sec + tv.tv_usec;
}

int WriteFileSync(const char* path, uv_buf_t buf) {
  uv_fs_t req;
  int fd = uv_fs_open(nullptr,
                      &req,
                      path,
                      O_WRONLY | O_CREAT | O_TRUNC,
                      S_IWUSR | S_IRUSR,
                      nullptr);
  uv_fs_req_cleanup(&req);
  if (fd < 0) {
    return fd;
  }

  int err = uv_fs_write(nullptr, &req, fd, &buf, 1, 0, nullptr);
  uv_fs_req_cleanup(&req);
  if (err < 0) {
    return err;
  }

  err = uv_fs_close(nullptr, &req, fd, nullptr);
  uv_fs_req_cleanup(&req);
  return err;
}

int WriteFileSync(v8::Isolate* isolate,
                  const char* path,
                  v8::Local<v8::String> string) {
  node::Utf8Value utf8(isolate, string);
  uv_buf_t buf = uv_buf_init(utf8.out(), utf8.length());
  return WriteFileSync(path, buf);
}

void DiagnosticFilename::LocalTime(TIME_TYPE* tm_struct) {
#ifdef _WIN32
  GetLocalTime(tm_struct);
#else  // UNIX, OSX
  struct timeval time_val;
  gettimeofday(&time_val, nullptr);
  localtime_r(&time_val.tv_sec, tm_struct);
#endif
}

// Defined in node_internals.h
std::string DiagnosticFilename::MakeFilename(
    uint64_t thread_id,
    const char* prefix,
    const char* ext) {
  std::ostringstream oss;
  TIME_TYPE tm_struct;
  LocalTime(&tm_struct);
  oss << prefix;
#ifdef _WIN32
  oss << "." << std::setfill('0') << std::setw(4) << tm_struct.wYear;
  oss << std::setfill('0') << std::setw(2) << tm_struct.wMonth;
  oss << std::setfill('0') << std::setw(2) << tm_struct.wDay;
  oss << "." << std::setfill('0') << std::setw(2) << tm_struct.wHour;
  oss << std::setfill('0') << std::setw(2) << tm_struct.wMinute;
  oss << std::setfill('0') << std::setw(2) << tm_struct.wSecond;
#else  // UNIX, OSX
  oss << "."
            << std::setfill('0')
            << std::setw(4)
            << tm_struct.tm_year + 1900;
  oss << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_mon + 1;
  oss << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_mday;
  oss << "."
            << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_hour;
  oss << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_min;
  oss << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_sec;
#endif
  oss << "." << uv_os_getpid();
  oss << "." << thread_id;
  oss << "." << std::setfill('0') << std::setw(3) << ++seq;
  oss << "." << ext;
  return oss.str();
}

}  // namespace node


Generated by: GCOVR (Version 3.4)

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 "util.h" // NOLINT(build/include_inline)
23			#include "util-inl.h"
24
25			#include "env-inl.h"
26			#include "node_buffer.h"
27			#include "node_errors.h"
28			#include "node_internals.h"
29			#include "string_bytes.h"
30			#include "uv.h"
31
32			#ifdef _WIN32
33			#include <io.h> // _S_IREAD _S_IWRITE
34			#include <time.h>
35			#ifndef S_IRUSR
36			#define S_IRUSR _S_IREAD
37			#endif // S_IRUSR
38			#ifndef S_IWUSR
39			#define S_IWUSR _S_IWRITE
40			#endif // S_IWUSR
41			#else
42			#include <sys/time.h>
43			#include <sys/types.h>
44			#endif
45
46			#include <atomic>
47			#include <cstdio>
48			#include <iomanip>
49			#include <sstream>
50
51			static std::atomic_int seq = {0}; // Sequence number for diagnostic filenames.
52
53			namespace node {
54
55			using v8::ArrayBufferView;
56			using v8::Isolate;
57			using v8::Local;
58			using v8::String;
59			using v8::Value;
60
61			template <typename T>
62		6165170	static void MakeUtf8String(Isolate* isolate,
63			Local<Value> value,
64			T* target) {
65			Local<String> string;
66	✗✓✗✓	18495518	if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;
67
68			size_t storage;
69	✗✓✗✓	12330347	if (!StringBytes::StorageSize(isolate, string, UTF8).To(&storage)) return;
70		6165172	storage += 1;
71		6165172	target->AllocateSufficientStorage(storage);
72			const int flags =
73		6165171	String::NO_NULL_TERMINATION \| String::REPLACE_INVALID_UTF8;
74			const int length =
75		12330342	string->WriteUtf8(isolate, target->out(), storage, nullptr, flags);
76		6165172	target->SetLengthAndZeroTerminate(length);
77			}
78
79		5932518	Utf8Value::Utf8Value(Isolate* isolate, Local<Value> value) {
80	✓✓	5932518	if (value.IsEmpty())
81		5934626	return;
82
83		5930413	MakeUtf8String(isolate, value, this);
84			}
85
86
87		1555	TwoByteValue::TwoByteValue(Isolate* isolate, Local<Value> value) {
88	✗✓	1555	if (value.IsEmpty()) {
89			return;
90			}
91
92			Local<String> string;
93	✗✓	4665	if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;
94
95			// Allocate enough space to include the null terminator
96		1555	const size_t storage = string->Length() + 1;
97		1555	AllocateSufficientStorage(storage);
98
99		1555	const int flags = String::NO_NULL_TERMINATION;
100		3110	const int length = string->Write(isolate, out(), 0, storage, flags);
101		1555	SetLengthAndZeroTerminate(length);
102			}
103
104		253390	BufferValue::BufferValue(Isolate* isolate, Local<Value> value) {
105			// Slightly different take on Utf8Value. If value is a String,
106			// it will return a Utf8 encoded string. If value is a Buffer,
107			// it will copy the data out of the Buffer as is.
108	✗✓	253390	if (value.IsEmpty()) {
109			// Dereferencing this object will return nullptr.
110			Invalidate();
111		253390	return;
112			}
113
114	✓✓	506780	if (value->IsString()) {
115		234759	MakeUtf8String(isolate, value, this);
116	✓✗	18631	} else if (value->IsArrayBufferView()) {
117		37262	const size_t len = value.As<ArrayBufferView>()->ByteLength();
118			// Leave place for the terminating '\0' byte.
119		18631	AllocateSufficientStorage(len + 1);
120		55893	value.As<ArrayBufferView>()->CopyContents(out(), len);
121		18631	SetLengthAndZeroTerminate(len);
122			} else {
123			Invalidate();
124			}
125			}
126
127			void LowMemoryNotification() {
128			if (per_process::v8_initialized) {
129			auto isolate = Isolate::GetCurrent();
130			if (isolate != nullptr) {
131			isolate->LowMemoryNotification();
132			}
133			}
134			}
135
136		4911	std::string GetHumanReadableProcessName() {
137			char name[1024];
138		4911	GetHumanReadableProcessName(&name);
139		4911	return name;
140			}
141
142		4911	void GetHumanReadableProcessName(char (*name)[1024]) {
143			// Leave room after title for pid, which can be up to 20 digits for 64 bit.
144		4911	char title[1000] = "Node.js";
145		4911	uv_get_process_title(title, sizeof(title));
146		4911	snprintf(name, sizeof(name), "%s[%d]", title, uv_os_getpid());
147		4911	}
148
149		9829	std::vector<std::string> SplitString(const std::string& in, char delim) {
150		9829	std::vector<std::string> out;
151	✓✓	9829	if (in.empty())
152		3	return out;
153		19652	std::istringstream in_stream(in);
154	✓✓	39243	while (in_stream.good()) {
155		19591	std::string item;
156		19591	std::getline(in_stream, item, delim);
157	✗✓	19591	if (item.empty()) continue;
158	✓✗	19591	out.emplace_back(std::move(item));
159		19591	}
160		9826	return out;
161			}
162
163			void ThrowErrStringTooLong(Isolate* isolate) {
164			isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
165			}
166
167		10016	double GetCurrentTimeInMicroseconds() {
168		10016	constexpr double kMicrosecondsPerSecond = 1e6;
169			uv_timeval64_t tv;
170	✗✓	10016	CHECK_EQ(0, uv_gettimeofday(&tv));
171		10016	return kMicrosecondsPerSecond * tv.tv_sec + tv.tv_usec;
172			}
173
174		5078	int WriteFileSync(const char* path, uv_buf_t buf) {
175			uv_fs_t req;
176			int fd = uv_fs_open(nullptr,
177			&req,
178			path,
179			O_WRONLY \| O_CREAT \| O_TRUNC,
180			S_IWUSR \| S_IRUSR,
181		5078	nullptr);
182		5078	uv_fs_req_cleanup(&req);
183	✗✓	5078	if (fd < 0) {
184			return fd;
185			}
186
187		5078	int err = uv_fs_write(nullptr, &req, fd, &buf, 1, 0, nullptr);
188		5078	uv_fs_req_cleanup(&req);
189	✗✓	5078	if (err < 0) {
190			return err;
191			}
192
193		5078	err = uv_fs_close(nullptr, &req, fd, nullptr);
194		5078	uv_fs_req_cleanup(&req);
195		5078	return err;
196			}
197
198		5078	int WriteFileSync(v8::Isolate* isolate,
199			const char* path,
200			v8::Local<v8::String> string) {
201		5078	node::Utf8Value utf8(isolate, string);
202		5078	uv_buf_t buf = uv_buf_init(utf8.out(), utf8.length());
203		5078	return WriteFileSync(path, buf);
204			}
205
206		40	void DiagnosticFilename::LocalTime(TIME_TYPE* tm_struct) {
207			#ifdef _WIN32
208			GetLocalTime(tm_struct);
209			#else // UNIX, OSX
210			struct timeval time_val;
211		40	gettimeofday(&time_val, nullptr);
212		40	localtime_r(&time_val.tv_sec, tm_struct);
213			#endif
214		40	}
215
216			// Defined in node_internals.h
217		25	std::string DiagnosticFilename::MakeFilename(
218			uint64_t thread_id,
219			const char* prefix,
220			const char* ext) {
221		25	std::ostringstream oss;
222			TIME_TYPE tm_struct;
223		25	LocalTime(&tm_struct);
224		25	oss << prefix;
225			#ifdef _WIN32
226			oss << "." << std::setfill('0') << std::setw(4) << tm_struct.wYear;
227			oss << std::setfill('0') << std::setw(2) << tm_struct.wMonth;
228			oss << std::setfill('0') << std::setw(2) << tm_struct.wDay;
229			oss << "." << std::setfill('0') << std::setw(2) << tm_struct.wHour;
230			oss << std::setfill('0') << std::setw(2) << tm_struct.wMinute;
231			oss << std::setfill('0') << std::setw(2) << tm_struct.wSecond;
232			#else // UNIX, OSX
233		25	oss << "."
234		50	<< std::setfill('0')
235		50	<< std::setw(4)
236		50	<< tm_struct.tm_year + 1900;
237		25	oss << std::setfill('0')
238		50	<< std::setw(2)
239		50	<< tm_struct.tm_mon + 1;
240		25	oss << std::setfill('0')
241		50	<< std::setw(2)
242		50	<< tm_struct.tm_mday;
243		25	oss << "."
244		50	<< std::setfill('0')
245		50	<< std::setw(2)
246		50	<< tm_struct.tm_hour;
247		25	oss << std::setfill('0')
248		50	<< std::setw(2)
249		50	<< tm_struct.tm_min;
250		25	oss << std::setfill('0')
251		50	<< std::setw(2)
252		50	<< tm_struct.tm_sec;
253			#endif
254		25	oss << "." << uv_os_getpid();
255		25	oss << "." << thread_id;
256		25	oss << "." << std::setfill('0') << std::setw(3) << ++seq;
257		25	oss << "." << ext;
258		25	return oss.str();
259			}
260
261			} // namespace node