42 # include <sys/stat.h> 46 #endif // GTEST_OS_WINDOWS 49 # include <mach/mach_init.h> 50 # include <mach/task.h> 51 # include <mach/vm_map.h> 52 #endif // GTEST_OS_MAC 57 # include <sys/procfs.h> 58 #endif // GTEST_OS_QNX 70 #define GTEST_IMPLEMENTATION_ 1 72 #undef GTEST_IMPLEMENTATION_ 77 #if defined(_MSC_VER) || defined(__BORLANDC__) 91 const task_t task = mach_task_self();
92 mach_msg_type_number_t thread_count;
93 thread_act_array_t thread_list;
94 const kern_return_t status = task_threads(task, &thread_list, &thread_count);
95 if (status == KERN_SUCCESS) {
99 reinterpret_cast<vm_address_t>(thread_list),
100 sizeof(thread_t) * thread_count);
101 return static_cast<size_t>(thread_count);
112 const int fd = open(
"/proc/self/as", O_RDONLY);
116 procfs_info process_info;
118 devctl(fd, DCMD_PROC_INFO, &process_info,
sizeof(process_info), NULL);
121 return static_cast<size_t>(process_info.num_threads);
135 #endif // GTEST_OS_MAC 137 #if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS 139 void SleepMilliseconds(
int n) {
143 AutoHandle::AutoHandle()
144 : handle_(INVALID_HANDLE_VALUE) {}
146 AutoHandle::AutoHandle(Handle handle)
149 AutoHandle::~AutoHandle() {
157 void AutoHandle::Reset() {
158 Reset(INVALID_HANDLE_VALUE);
161 void AutoHandle::Reset(HANDLE handle) {
163 if (handle_ != handle) {
165 ::CloseHandle(handle_);
170 <<
"Resetting a valid handle to itself is likely a programmer error " 171 "and thus not allowed.";
175 bool AutoHandle::IsCloseable()
const {
178 return handle_ != NULL && handle_ != INVALID_HANDLE_VALUE;
182 : event_(::CreateEvent(NULL,
189 void Notification::Notify() {
193 void Notification::WaitForNotification() {
195 ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
201 critical_section_init_phase_(0),
202 critical_section_(
new CRITICAL_SECTION) {
203 ::InitializeCriticalSection(critical_section_);
212 if (type_ == kDynamic) {
213 ::DeleteCriticalSection(critical_section_);
214 delete critical_section_;
215 critical_section_ = NULL;
220 ThreadSafeLazyInit();
221 ::EnterCriticalSection(critical_section_);
222 owner_thread_id_ = ::GetCurrentThreadId();
226 ThreadSafeLazyInit();
230 owner_thread_id_ = 0;
231 ::LeaveCriticalSection(critical_section_);
237 ThreadSafeLazyInit();
238 GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
239 <<
"The current thread is not holding the mutex @" <<
this;
243 void Mutex::ThreadSafeLazyInit() {
245 if (type_ == kStatic) {
247 ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
251 owner_thread_id_ = 0;
252 critical_section_ =
new CRITICAL_SECTION;
253 ::InitializeCriticalSection(critical_section_);
257 &critical_section_init_phase_, 2L, 1L) ==
263 while (::InterlockedCompareExchange(&critical_section_init_phase_,
277 <<
"Unexpected value of critical_section_init_phase_ " 278 <<
"while initializing a static mutex.";
285 class ThreadWithParamSupport :
public ThreadWithParamBase {
287 static HANDLE CreateThread(Runnable* runnable,
289 ThreadMainParam*
param =
new ThreadMainParam(runnable, thread_can_start);
292 HANDLE thread_handle = ::CreateThread(
295 &ThreadWithParamSupport::ThreadMain,
299 GTEST_CHECK_(thread_handle != NULL) <<
"CreateThread failed with error " 300 << ::GetLastError() <<
".";
301 if (thread_handle == NULL) {
304 return thread_handle;
308 struct ThreadMainParam {
309 ThreadMainParam(Runnable* runnable,
Notification* thread_can_start)
310 : runnable_(runnable),
311 thread_can_start_(thread_can_start) {
318 static DWORD WINAPI ThreadMain(
void*
ptr) {
321 if (param->thread_can_start_ != NULL)
322 param->thread_can_start_->WaitForNotification();
323 param->runnable_->Run();
328 ThreadWithParamSupport();
335 ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
337 : thread_(ThreadWithParamSupport::CreateThread(runnable,
341 ThreadWithParamBase::~ThreadWithParamBase() {
345 void ThreadWithParamBase::Join() {
346 GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
347 <<
"Failed to join the thread with error " << ::GetLastError() <<
".";
354 class ThreadLocalRegistryImpl {
358 static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
359 const ThreadLocalBase* thread_local_instance) {
360 DWORD current_thread = ::GetCurrentThreadId();
362 ThreadIdToThreadLocals*
const thread_to_thread_locals =
363 GetThreadLocalsMapLocked();
364 ThreadIdToThreadLocals::iterator thread_local_pos =
365 thread_to_thread_locals->find(current_thread);
366 if (thread_local_pos == thread_to_thread_locals->end()) {
367 thread_local_pos = thread_to_thread_locals->insert(
368 std::make_pair(current_thread, ThreadLocalValues())).first;
369 StartWatcherThreadFor(current_thread);
371 ThreadLocalValues& thread_local_values = thread_local_pos->second;
372 ThreadLocalValues::iterator value_pos =
373 thread_local_values.find(thread_local_instance);
374 if (value_pos == thread_local_values.end()) {
377 .insert(std::make_pair(
378 thread_local_instance,
380 thread_local_instance->NewValueForCurrentThread())))
383 return value_pos->second.get();
386 static void OnThreadLocalDestroyed(
387 const ThreadLocalBase* thread_local_instance) {
388 std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
393 ThreadIdToThreadLocals*
const thread_to_thread_locals =
394 GetThreadLocalsMapLocked();
395 for (ThreadIdToThreadLocals::iterator it =
396 thread_to_thread_locals->begin();
397 it != thread_to_thread_locals->end();
399 ThreadLocalValues& thread_local_values = it->second;
400 ThreadLocalValues::iterator value_pos =
401 thread_local_values.find(thread_local_instance);
402 if (value_pos != thread_local_values.end()) {
403 value_holders.push_back(value_pos->second);
404 thread_local_values.erase(value_pos);
414 static void OnThreadExit(DWORD
thread_id) {
416 std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
421 ThreadIdToThreadLocals*
const thread_to_thread_locals =
422 GetThreadLocalsMapLocked();
423 ThreadIdToThreadLocals::iterator thread_local_pos =
424 thread_to_thread_locals->find(thread_id);
425 if (thread_local_pos != thread_to_thread_locals->end()) {
426 ThreadLocalValues& thread_local_values = thread_local_pos->second;
427 for (ThreadLocalValues::iterator value_pos =
428 thread_local_values.begin();
429 value_pos != thread_local_values.end();
431 value_holders.push_back(value_pos->second);
433 thread_to_thread_locals->erase(thread_local_pos);
442 typedef std::map<
const ThreadLocalBase*,
446 typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
450 typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;
452 static void StartWatcherThreadFor(DWORD thread_id) {
455 HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
461 DWORD watcher_thread_id;
462 HANDLE watcher_thread = ::CreateThread(
465 &ThreadLocalRegistryImpl::WatcherThreadFunc,
466 reinterpret_cast<LPVOID>(
new ThreadIdAndHandle(thread_id, thread)),
472 ::SetThreadPriority(watcher_thread,
473 ::GetThreadPriority(::GetCurrentThread()));
474 ::ResumeThread(watcher_thread);
475 ::CloseHandle(watcher_thread);
480 static DWORD WINAPI WatcherThreadFunc(LPVOID
param) {
481 const ThreadIdAndHandle* tah =
482 reinterpret_cast<const ThreadIdAndHandle*
>(param);
484 ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
485 OnThreadExit(tah->first);
486 ::CloseHandle(tah->second);
492 static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
494 static ThreadIdToThreadLocals* map =
new ThreadIdToThreadLocals;
501 static Mutex thread_map_mutex_;
504 Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);
505 Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);
507 ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
508 const ThreadLocalBase* thread_local_instance) {
509 return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
510 thread_local_instance);
513 void ThreadLocalRegistry::OnThreadLocalDestroyed(
514 const ThreadLocalBase* thread_local_instance) {
515 ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
518 #endif // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS 520 #if GTEST_USES_POSIX_RE 530 regfree(&partial_regex_);
531 regfree(&full_regex_);
533 free(const_cast<char*>(pattern_));
541 return regexec(&re.
full_regex_, str, 1, &match, 0) == 0;
559 const size_t full_regex_len = strlen(regex) + 10;
560 char*
const full_pattern =
new char[full_regex_len];
562 snprintf(full_pattern, full_regex_len,
"^(%s)$", regex);
563 is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
573 const char*
const partial_regex = (*regex ==
'\0') ?
"()" : regex;
574 is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
577 <<
"Regular expression \"" << regex
578 <<
"\" is not a valid POSIX Extended regular expression.";
580 delete[] full_pattern;
583 #elif GTEST_USES_SIMPLE_RE 587 bool IsInSet(
char ch,
const char* str) {
588 return ch !=
'\0' && strchr(str, ch) != NULL;
594 bool IsAsciiDigit(
char ch) {
return '0' <= ch && ch <=
'9'; }
595 bool IsAsciiPunct(
char ch) {
596 return IsInSet(ch,
"^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
598 bool IsRepeat(
char ch) {
return IsInSet(ch,
"?*+"); }
599 bool IsAsciiWhiteSpace(
char ch) {
return IsInSet(ch,
" \f\n\r\t\v"); }
600 bool IsAsciiWordChar(
char ch) {
601 return (
'a' <= ch && ch <=
'z') || (
'A' <= ch && ch <=
'Z') ||
602 (
'0' <= ch && ch <=
'9') || ch ==
'_';
606 bool IsValidEscape(
char c) {
607 return (IsAsciiPunct(c) || IsInSet(c,
"dDfnrsStvwW"));
612 bool AtomMatchesChar(
bool escaped,
char pattern_char,
char ch) {
614 switch (pattern_char) {
615 case 'd':
return IsAsciiDigit(ch);
616 case 'D':
return !IsAsciiDigit(ch);
617 case 'f':
return ch ==
'\f';
618 case 'n':
return ch ==
'\n';
619 case 'r':
return ch ==
'\r';
620 case 's':
return IsAsciiWhiteSpace(ch);
621 case 'S':
return !IsAsciiWhiteSpace(ch);
622 case 't':
return ch ==
'\t';
623 case 'v':
return ch ==
'\v';
624 case 'w':
return IsAsciiWordChar(ch);
625 case 'W':
return !IsAsciiWordChar(ch);
627 return IsAsciiPunct(pattern_char) && pattern_char == ch;
630 return (pattern_char ==
'.' && ch !=
'\n') || pattern_char == ch;
634 std::string FormatRegexSyntaxError(
const char* regex,
int index) {
635 return (
Message() <<
"Syntax error at index " << index
636 <<
" in simple regular expression \"" << regex <<
"\": ").GetString();
641 bool ValidateRegex(
const char* regex) {
646 ADD_FAILURE() <<
"NULL is not a valid simple regular expression.";
650 bool is_valid =
true;
653 bool prev_repeatable =
false;
654 for (
int i = 0; regex[
i];
i++) {
655 if (regex[
i] ==
'\\') {
657 if (regex[
i] ==
'\0') {
659 <<
"'\\' cannot appear at the end.";
663 if (!IsValidEscape(regex[
i])) {
664 ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
665 <<
"invalid escape sequence \"\\" << regex[
i] <<
"\".";
668 prev_repeatable =
true;
670 const char ch = regex[
i];
672 if (ch ==
'^' &&
i > 0) {
674 <<
"'^' can only appear at the beginning.";
676 }
else if (ch ==
'$' && regex[
i + 1] !=
'\0') {
678 <<
"'$' can only appear at the end.";
680 }
else if (IsInSet(ch,
"()[]{}|")) {
682 <<
"'" << ch <<
"' is unsupported.";
684 }
else if (IsRepeat(ch) && !prev_repeatable) {
686 <<
"'" << ch <<
"' can only follow a repeatable token.";
690 prev_repeatable = !IsInSet(ch,
"^$?*+");
704 bool MatchRepetitionAndRegexAtHead(
705 bool escaped,
char c,
char repeat,
const char* regex,
707 const size_t min_count = (repeat ==
'+') ? 1 : 0;
708 const size_t max_count = (repeat ==
'?') ? 1 :
709 static_cast<size_t>(-1) - 1;
713 for (
size_t i = 0;
i <= max_count; ++
i) {
715 if (
i >= min_count && MatchRegexAtHead(regex, str +
i)) {
722 if (str[
i] ==
'\0' || !AtomMatchesChar(escaped, c, str[
i]))
731 bool MatchRegexAtHead(
const char* regex,
const char* str) {
741 const bool escaped = *regex ==
'\\';
744 if (IsRepeat(regex[1])) {
748 return MatchRepetitionAndRegexAtHead(
749 escaped, regex[0], regex[1], regex + 2, str);
754 return (*str !=
'\0') && AtomMatchesChar(escaped, *regex, *str) &&
755 MatchRegexAtHead(regex + 1, str + 1);
767 bool MatchRegexAnywhere(
const char* regex,
const char* str) {
768 if (regex == NULL || str == NULL)
772 return MatchRegexAtHead(regex + 1, str);
776 if (MatchRegexAtHead(regex, str))
778 }
while (*str++ !=
'\0');
785 free(const_cast<char*>(pattern_));
786 free(const_cast<char*>(full_pattern_));
791 return re.
is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
802 pattern_ = full_pattern_ = NULL;
807 is_valid_ = ValidateRegex(regex);
813 const size_t len = strlen(regex);
825 memcpy(buffer, regex, len);
828 if (len == 0 || regex[len - 1] !=
'$')
834 #endif // GTEST_USES_POSIX_RE 841 const std::string file_name(file == NULL ? kUnknownFile : file);
844 return file_name +
":";
859 const char* file,
int line) {
860 const std::string file_name(file == NULL ? kUnknownFile : file);
870 : severity_(severity) {
871 const char*
const marker =
874 severity ==
GTEST_ERROR ?
"[ ERROR ]" :
"[ FATAL ]";
875 GetStream() << ::std::endl << marker <<
" " 891 #if GTEST_HAS_STREAM_REDIRECTION 894 class CapturedStream {
897 explicit CapturedStream(
int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
898 # if GTEST_OS_WINDOWS 899 char temp_dir_path[MAX_PATH + 1] = {
'\0' };
900 char temp_file_path[MAX_PATH + 1] = {
'\0' };
902 ::GetTempPathA(
sizeof(temp_dir_path), temp_dir_path);
903 const UINT success = ::GetTempFileNameA(temp_dir_path,
908 <<
"Unable to create a temporary file in " << temp_dir_path;
909 const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
910 GTEST_CHECK_(captured_fd != -1) <<
"Unable to open temporary file " 912 filename_ = temp_file_path;
918 # if GTEST_OS_LINUX_ANDROID 933 char name_template[] =
"/sdcard/gtest_captured_stream.XXXXXX";
935 char name_template[] =
"/tmp/captured_stream.XXXXXX";
936 # endif // GTEST_OS_LINUX_ANDROID 937 const int captured_fd = mkstemp(name_template);
938 filename_ = name_template;
939 # endif // GTEST_OS_WINDOWS 941 dup2(captured_fd, fd_);
946 remove(filename_.c_str());
950 if (uncaptured_fd_ != -1) {
953 dup2(uncaptured_fd_, fd_);
954 close(uncaptured_fd_);
958 FILE*
const file =
posix::FOpen(filename_.c_str(),
"r");
969 static size_t GetFileSize(FILE* file);
980 size_t CapturedStream::GetFileSize(FILE* file) {
981 fseek(file, 0, SEEK_END);
982 return static_cast<size_t>(ftell(file));
986 std::string CapturedStream::ReadEntireFile(FILE* file) {
987 const size_t file_size = GetFileSize(file);
988 char*
const buffer =
new char[file_size];
990 size_t bytes_last_read = 0;
991 size_t bytes_read = 0;
993 fseek(file, 0, SEEK_SET);
998 bytes_last_read =
fread(buffer+bytes_read, 1, file_size-bytes_read, file);
999 bytes_read += bytes_last_read;
1000 }
while (bytes_last_read > 0 && bytes_read < file_size);
1010 static CapturedStream* g_captured_stderr = NULL;
1011 static CapturedStream* g_captured_stdout = NULL;
1014 void CaptureStream(
int fd,
const char* stream_name, CapturedStream** stream) {
1015 if (*stream != NULL) {
1016 GTEST_LOG_(FATAL) <<
"Only one " << stream_name
1017 <<
" capturer can exist at a time.";
1019 *stream =
new CapturedStream(fd);
1023 std::string GetCapturedStream(CapturedStream** captured_stream) {
1024 const std::string content = (*captured_stream)->GetCapturedString();
1026 delete *captured_stream;
1027 *captured_stream = NULL;
1034 CaptureStream(kStdOutFileno,
"stdout", &g_captured_stdout);
1039 CaptureStream(kStdErrFileno,
"stderr", &g_captured_stderr);
1044 return GetCapturedStream(&g_captured_stdout);
1049 return GetCapturedStream(&g_captured_stderr);
1052 #endif // GTEST_HAS_STREAM_REDIRECTION 1054 #if GTEST_HAS_DEATH_TEST 1057 ::std::vector<testing::internal::string> g_argvs;
1059 static const ::std::vector<testing::internal::string>* g_injected_test_argvs =
1062 void SetInjectableArgvs(const ::std::vector<testing::internal::string>* argvs) {
1063 if (g_injected_test_argvs != argvs)
1064 delete g_injected_test_argvs;
1065 g_injected_test_argvs = argvs;
1068 const ::std::vector<testing::internal::string>& GetInjectableArgvs() {
1069 if (g_injected_test_argvs != NULL) {
1070 return *g_injected_test_argvs;
1074 #endif // GTEST_HAS_DEATH_TEST 1076 #if GTEST_OS_WINDOWS_MOBILE 1080 TerminateProcess(GetCurrentProcess(), 1);
1083 #endif // GTEST_OS_WINDOWS_MOBILE 1093 for (
size_t i = 0;
i != full_flag.length();
i++) {
1094 env_var <<
ToUpper(full_flag.c_str()[
i]);
1106 const long long_value = strtol(str, &end, 10);
1112 msg <<
"WARNING: " << src_text
1113 <<
" is expected to be a 32-bit integer, but actually" 1114 <<
" has value \"" << str <<
"\".\n";
1122 if (long_value == LONG_MAX || long_value == LONG_MIN ||
1125 result != long_value
1129 msg <<
"WARNING: " << src_text
1130 <<
" is expected to be a 32-bit integer, but actually" 1131 <<
" has value " << str <<
", which overflows.\n";
1147 const char*
const string_value =
posix::GetEnv(env_var.c_str());
1148 return string_value == NULL ?
1149 default_value : strcmp(string_value,
"0") != 0;
1157 const char*
const string_value =
posix::GetEnv(env_var.c_str());
1158 if (string_value == NULL) {
1160 return default_value;
1165 string_value, &result)) {
1166 printf(
"The default value %s is used.\n",
1167 (
Message() << default_value).GetString().c_str());
1169 return default_value;
1180 return value == NULL ? default_value :
value;
GTEST_API_ Int32 Int32FromGTestEnv(const char *flag, Int32 default_val)
GTEST_API_ std::string GetCapturedStdout()
GTEST_API_ std::string GetCapturedStderr()
bool param(const std::string ¶m_name, T ¶m_val, const T &default_val)
static bool FullMatch(const ::std::string &str, const RE &re)
GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog)
#define GTEST_DISABLE_MSC_WARNINGS_POP_()
const char * StringFromGTestEnv(const char *flag, const char *default_val)
#define GTEST_LOG_(severity)
GTEST_API_::std::string FormatFileLocation(const char *file, int line)
bool ParseInt32(const Message &src_text, const char *str, Int32 *value)
UNITTEST_START char * ptr
GTEST_API_ size_t GetThreadCount()
const char * GetEnv(const char *name)
GTEST_API_ void CaptureStdout()
Notification(int expected_count)
static bool PartialMatch(const ::std::string &str, const RE &re)
UNITTEST_START int result
static std::string FlagToEnvVar(const char *flag)
std::string StreamableToString(const T &streamable)
::std::ostream & GetStream()
TypeWithSize< 4 >::Int Int32
memcpy(filename, filename1, strlen(filename1))
const GTestLogSeverity severity_
#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
#define GTEST_CHECK_(condition)
std::string GetString() const
GTestLog(GTestLogSeverity severity, const char *file, int line)
void Init(const char *regex)
GTEST_API_::std::string FormatCompilerIndependentFileLocation(const char *file, int line)
bool BoolFromGTestEnv(const char *flag, bool default_val)
FILE * FOpen(const char *path, const char *mode)
const char kUnknownFile[]
GTEST_API_ void CaptureStderr()
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)
UNITTEST_START int * value
#define EXPECT_TRUE(condition)
static unsigned long thread_id(void)
char * StrDup(const char *src)
#define GTEST_FLAG_PREFIX_