Implements death tests on Windows (by Vlad Losev); enables POSIX regex on Mac and Cygwin; fixes build issue on some Linux versions due to PATH_MAX.

include/gtest/gtest-death-test.h

@@ -184,6 +184,7 @@ class ExitedWithCode {
   const int exit_code_;
 };
 
+#if !GTEST_OS_WINDOWS
 // Tests that an exit code describes an exit due to termination by a
 // given signal.
 class KilledBySignal {
@@ -193,6 +194,7 @@ class KilledBySignal {
  private:
   const int signum_;
 };
+#endif  // !GTEST_OS_WINDOWS
 
 // EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
 // The death testing framework causes this to have interesting semantics,

include/gtest/internal/gtest-death-test-internal.h

@@ -39,6 +39,10 @@
 
 #include <gtest/internal/gtest-internal.h>
 
+#if GTEST_HAS_DEATH_TEST && GTEST_OS_WINDOWS
+#include <io.h>
+#endif  // GTEST_HAS_DEATH_TEST && GTEST_OS_WINDOWS
+
 namespace testing {
 namespace internal {
 
@@ -121,7 +125,12 @@ class DeathTest {
   // the last death test.
   static const char* LastMessage();
 
+  static void set_last_death_test_message(const String& message);
+
  private:
+  // A string containing a description of the outcome of the last death test.
+  static String last_death_test_message_;
+
   GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
 };
 
@@ -167,7 +176,7 @@ bool ExitedUnsuccessfully(int exit_status);
         case ::testing::internal::DeathTest::EXECUTE_TEST: { \
           ::testing::internal::DeathTest::ReturnSentinel \
               gtest_sentinel(gtest_dt); \
-          { statement; } \
+          GTEST_HIDE_UNREACHABLE_CODE_(statement); \
           gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
           break; \
         } \
@@ -179,14 +188,42 @@ bool ExitedUnsuccessfully(int exit_status);
 // The symbol "fail" here expands to something into which a message
 // can be streamed.
 
-// A struct representing the parsed contents of the
+// A class representing the parsed contents of the
 // --gtest_internal_run_death_test flag, as it existed when
 // RUN_ALL_TESTS was called.
-struct InternalRunDeathTestFlag {
+class InternalRunDeathTestFlag {
-  String file;
+ public:
-  int line;
+  InternalRunDeathTestFlag(const String& file,
-  int index;
+                           int line,
-  int status_fd;
+                           int index,
+                           int status_fd)
+      : file_(file), line_(line), index_(index), status_fd_(status_fd) {}
+
+  ~InternalRunDeathTestFlag() {
+    if (status_fd_ >= 0)
+// Suppress MSVC complaints about POSIX functions.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4996)
+#endif  // _MSC_VER
+      close(status_fd_);
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
+  }
+
+  String file() const { return file_; }
+  int line() const { return line_; }
+  int index() const { return index_; }
+  int status_fd() const { return status_fd_; }
+
+ private:
+  String file_;
+  int line_;
+  int index_;
+  int status_fd_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
 };
 
 // Returns a newly created InternalRunDeathTestFlag object with fields

include/gtest/internal/gtest-port.h

@@ -183,7 +183,7 @@
 #define GTEST_OS_SOLARIS 1
 #endif  // _MSC_VER
 
-#if GTEST_OS_LINUX
+#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
 
 // On some platforms, <regex.h> needs someone to define size_t, and
 // won't compile otherwise.  We can #include it here as we already
@@ -194,8 +194,8 @@
 
 #else
 
-// We are not on Linux, so <regex.h> may not be available.  Use our
+// <regex.h> may not be available on this platform.  Use our own
-// own simple regex implementation instead.
+// simple regex implementation instead.
 #define GTEST_USES_SIMPLE_RE 1
 
 #endif  // GTEST_OS_LINUX
@@ -367,12 +367,19 @@
 #endif  // GTEST_HAS_CLONE
 
 // Determines whether to support death tests.
-#if GTEST_HAS_STD_STRING && GTEST_HAS_CLONE
+// Google Test does not support death tests for VC 7.1 and earlier for
+// these reasons:
+//   1. std::vector does not build in VC 7.1 when exceptions are disabled.
+//   2. std::string does not build in VC 7.1 when exceptions are disabled
+//      (this is covered by GTEST_HAS_STD_STRING guard).
+//   3. abort() in a VC 7.1 application compiled as GUI in debug config
+//      pops up a dialog window that cannot be suppressed programmatically.
+#if GTEST_HAS_STD_STRING && (GTEST_HAS_CLONE || \
+                             GTEST_OS_WINDOWS && _MSC_VER >= 1400)
 #define GTEST_HAS_DEATH_TEST 1
 #include <vector>
-#include <fcntl.h>
+#endif  // GTEST_HAS_STD_STRING && (GTEST_HAS_CLONE ||
-#include <sys/mman.h>
+        //                          GTEST_OS_WINDOWS && _MSC_VER >= 1400)
-#endif  // GTEST_HAS_STD_STRING && GTEST_HAS_CLONE
 
 // Determines whether to support value-parameterized tests.
 
@@ -595,14 +602,17 @@ inline void FlushInfoLog() { fflush(NULL); }
 //   CaptureStderr     - starts capturing stderr.
 //   GetCapturedStderr - stops capturing stderr and returns the captured string.
 
+#if GTEST_HAS_STD_STRING
+void CaptureStderr();
+::std::string GetCapturedStderr();
+#endif  // GTEST_HAS_STD_STRING
+
 #if GTEST_HAS_DEATH_TEST
 
 // A copy of all command line arguments.  Set by InitGoogleTest().
 extern ::std::vector<String> g_argvs;
 
-void CaptureStderr();
 // GTEST_HAS_DEATH_TEST implies we have ::std::string.
-::std::string GetCapturedStderr();
 const ::std::vector<String>& GetArgvs();
 
 #endif  // GTEST_HAS_DEATH_TEST

scons/SConscript

@@ -102,38 +102,65 @@ env = env.Clone()
 env.Prepend(CPPPATH = ['..',
                        '../include'])
 
-# Sources shared by base library and library that includes main.
+# Sources used by base library and library that includes main.
-gtest_sources = ['../src/gtest-all.cc']
+gtest_source = '../src/gtest-all.cc'
+gtest_main_source = '../src/gtest_main.cc'
 
 # gtest.lib to be used by most apps (if you have your own main
 # function)
 gtest = env.StaticLibrary(target='gtest',
-                          source=gtest_sources)
+                          source=[gtest_source])
 
 # gtest_main.lib can be used if you just want a basic main function;
 # it is also used by the tests for Google Test itself.
 gtest_main = env.StaticLibrary(target='gtest_main',
-                               source=gtest_sources + ['../src/gtest_main.cc'])
+                               source=[gtest_source, gtest_main_source])
+
+env_with_exceptions = env.Clone()
+platform = env_with_exceptions['PLATFORM']
+if platform == 'win32':
+  env_with_exceptions.Append(CCFLAGS = ['/EHsc'])
+  env_with_exceptions.Append(CPPDEFINES = '_HAS_EXCEPTIONS=1')
+
+gtest_ex_obj = env_with_exceptions.Object(target='gtest_ex',
+                                          source=gtest_source)
+gtest_main_ex_obj = env_with_exceptions.Object(target='gtest_main_ex',
+                                               source=gtest_main_source)
+
+gtest_ex_main = env_with_exceptions.StaticLibrary(
+    target='gtest_ex_main',
+    source=gtest_ex_obj + gtest_main_ex_obj)
 
 # Install the libraries if needed.
 if 'LIB_OUTPUT' in env.Dictionary():
-  env.Install('$LIB_OUTPUT', source=[gtest, gtest_main])
+  env.Install('$LIB_OUTPUT', source=[gtest, gtest_main, gtest_ex_main])
 
 
-def GtestBinary(env, target, dir_prefix, gtest_lib, additional_sources=None):
+def ConstructSourceList(target, dir_prefix, additional_sources=None):
+  """Helper to create source file list for gtest binaries.
+
+  Args:
+    target: The basename of the target's main source file.
+    dir_prefix: The path to prefix the main source file.
+    gtest_lib: The gtest lib to use.
+    additional_sources: A list of additional source files in the target.
+  """
+  source = [env.File('%s.cc' % target, env.Dir(dir_prefix))]
+  if additional_sources:
+    source += additional_sources
+  return source
+
+def GtestBinary(env, target, gtest_lib, sources):
   """Helper to create gtest binaries: tests, samples, etc.
 
   Args:
     env: The SCons construction environment to use to build.
     target: The basename of the target's main source file, also used as target
             name.
-    dir_prefix: The path to prefix the main source file.
     gtest_lib: The gtest lib to use.
+    sources: A list of source files in the target.
   """
-  source = [env.File('%s.cc' % target, env.Dir(dir_prefix))]
+  unit_test = env.Program(target=target, source=sources, LIBS=[gtest_lib])
-  if additional_sources:
-    source += additional_sources
-  unit_test = env.Program(target=target, source=source, LIBS=[gtest_lib])
   if 'EXE_OUTPUT' in env.Dictionary():
     env.Install('$EXE_OUTPUT', source=[unit_test])
 
@@ -144,8 +171,13 @@ def GtestUnitTest(env, target, gtest_lib, additional_sources=None):
     env: The SCons construction environment to use to build.
     target: The basename of the target unit test .cc file.
     gtest_lib: The gtest lib to use.
+    additional_sources: A list of additional source files in the target.
   """
-  GtestBinary(env, target, "../test", gtest_lib, additional_sources)
+  GtestBinary(env,
+              target,
+              gtest_lib,
+              ConstructSourceList(target, "../test",
+                                  additional_sources=additional_sources))
 
 GtestUnitTest(env, 'gtest-filepath_test', gtest_main)
 GtestUnitTest(env, 'gtest-message_test', gtest_main)
@@ -168,6 +200,15 @@ GtestUnitTest(env, 'gtest_output_test_', gtest)
 GtestUnitTest(env, 'gtest_color_test_', gtest)
 GtestUnitTest(env, 'gtest-linked_ptr_test', gtest_main)
 GtestUnitTest(env, 'gtest-port_test', gtest_main)
+GtestUnitTest(env, 'gtest-death-test_test', gtest_main)
+
+gtest_unittest_ex_obj = env_with_exceptions.Object(
+    target='gtest_unittest_ex',
+    source='../test/gtest_unittest.cc')
+GtestBinary(env_with_exceptions,
+            'gtest_ex_unittest',
+            gtest_ex_main,
+            gtest_unittest_ex_obj)
 
 # TODO(wan@google.com) Add these unit tests:
 # - gtest_break_on_failure_unittest_
@@ -195,8 +236,13 @@ def GtestSample(env, target, gtest_lib, additional_sources=None):
     env: The SCons construction environment to use to build.
     target: The basename of the target unit test .cc file.
     gtest_lib: The gtest lib to use.
+    additional_sources: A list of additional source files in the target.
   """
-  GtestBinary(env, target, "../samples", gtest_lib, additional_sources)
+  GtestBinary(env,
+              target,
+              gtest_lib,
+              ConstructSourceList(target, "../samples",
+                                  additional_sources=additional_sources))
 
 # Use the GTEST_BUILD_SAMPLES build variable to control building of samples.
 # In your SConstruct file, add

src/gtest-filepath.cc

@@ -48,6 +48,7 @@
 #include <limits.h>
 #include <sys/stat.h>  // NOLINT
 #include <unistd.h>  // NOLINT
+#include <climits>  // Some Linux distributions define PATH_MAX here.
 #endif  // _WIN32_WCE or _WIN32
 
 #if GTEST_OS_WINDOWS

src/gtest-internal-inl.h

@@ -45,17 +45,20 @@
 #error "It must not be included except by Google Test itself."
 #endif  // GTEST_IMPLEMENTATION_
 
+#include <errno.h>
 #include <stddef.h>
-
+#include <stdlib.h>   // For strtoll/_strtoul64.
-#include <gtest/internal/gtest-port.h>
 
 #if GTEST_OS_WINDOWS
-#include <windows.h>  // NOLINT
+#include <windows.h>  // For DWORD.
 #endif  // GTEST_OS_WINDOWS
 
+#include <gtest/internal/gtest-port.h>
 #include <gtest/gtest.h>
 #include <gtest/gtest-spi.h>
 
+#include <string>
+
 namespace testing {
 
 // Declares the flags.
@@ -1313,6 +1316,77 @@ bool MatchRegexAnywhere(const char* regex, const char* str);
 void ParseGoogleTestFlagsOnly(int* argc, char** argv);
 void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
 
+#if GTEST_HAS_DEATH_TEST
+
+// Returns the message describing the last system error, regardless of the
+// platform.
+String GetLastSystemErrorMessage();
+
+#if GTEST_OS_WINDOWS
+// Provides leak-safe Windows kernel handle ownership.
+class AutoHandle {
+ public:
+  AutoHandle() : handle_(INVALID_HANDLE_VALUE) {}
+  explicit AutoHandle(HANDLE handle) : handle_(handle) {}
+
+  ~AutoHandle() { Reset(); }
+
+  HANDLE Get() const { return handle_; }
+  void Reset() { Reset(INVALID_HANDLE_VALUE); }
+  void Reset(HANDLE handle) {
+    if (handle != handle_) {
+      if (handle_ != INVALID_HANDLE_VALUE)
+        ::CloseHandle(handle_);
+      handle_ = handle;
+    }
+  }
+
+ private:
+  HANDLE handle_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
+};
+#endif  // GTEST_OS_WINDOWS
+
+// Attempts to parse a string into a positive integer pointed to by the
+// number parameter.  Returns true if that is possible.
+// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
+// it here.
+template <typename Integer>
+bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
+  // Fail fast if the given string does not begin with a digit;
+  // this bypasses strtoXXX's "optional leading whitespace and plus
+  // or minus sign" semantics, which are undesirable here.
+  if (str.empty() || !isdigit(str[0])) {
+    return false;
+  }
+  errno = 0;
+
+  char* end;
+  // BiggestConvertible is the largest integer type that system-provided
+  // string-to-number conversion routines can return.
+#if GTEST_OS_WINDOWS
+  typedef unsigned __int64 BiggestConvertible;
+  const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
+#else
+  typedef unsigned long long BiggestConvertible;  // NOLINT
+  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
+#endif  // GTEST_OS_WINDOWS
+  const bool parse_success = *end == '\0' && errno == 0;
+
+  // TODO(vladl@google.com): Convert this to compile time assertion when it is
+  // available.
+  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
+
+  const Integer result = static_cast<Integer>(parsed);
+  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
+    *number = result;
+    return true;
+  }
+  return false;
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
 }  // namespace internal
 }  // namespace testing
 

src/gtest-port.cc

@@ -35,9 +35,9 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-#if GTEST_HAS_DEATH_TEST
+#if !GTEST_OS_WINDOWS
-#include <regex.h>
+#include <unistd.h>
-#endif  // GTEST_HAS_DEATH_TEST
+#endif  // GTEST_OS_WINDOWS
 
 #if GTEST_USES_SIMPLE_RE
 #include <string.h>
@@ -63,6 +63,13 @@
 namespace testing {
 namespace internal {
 
+#if GTEST_OS_WINDOWS
+// Microsoft does not provide a definition of STDERR_FILENO.
+const int kStdErrFileno = 2;
+#else
+const int kStdErrFileno = STDERR_FILENO;
+#endif  // GTEST_OS_WINDOWS
+
 #if GTEST_USES_POSIX_RE
 
 // Implements RE.  Currently only needed for death tests.
@@ -105,7 +112,13 @@ void RE::Init(const char* regex) {
   // previous expression returns false.  Otherwise partial_regex_ may
   // not be properly initialized can may cause trouble when it's
   // freed.
-  is_valid_ = (regcomp(&partial_regex_, regex, REG_EXTENDED) == 0) && is_valid_;
+  //
+  // Some implementation of POSIX regex (e.g. on at least some
+  // versions of Cygwin) doesn't accept the empty string as a valid
+  // regex.  We change it to an equivalent form "()" to be safe.
+  const char* const partial_regex = (*regex == '\0') ? "()" : regex;
+  is_valid_ = (regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0)
+      && is_valid_;
   EXPECT_TRUE(is_valid_)
       << "Regular expression \"" << regex
       << "\" is not a valid POSIX Extended regular expression.";
@@ -379,11 +392,19 @@ void GTestLog(GTestLogSeverity severity, const char* file,
       severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
   fprintf(stderr, "\n%s %s:%d: %s\n", marker, file, line, msg);
   if (severity == GTEST_FATAL) {
+    fflush(NULL);  // abort() is not guaranteed to flush open file streams.
     abort();
   }
 }
 
-#if GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_STD_STRING
+
+// Disable Microsoft deprecation warnings for POSIX functions called from
+// this class (creat, dup, dup2, and close)
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4996)
+#endif  // _MSC_VER
 
 // Defines the stderr capturer.
 
@@ -391,16 +412,26 @@ class CapturedStderr {
  public:
   // The ctor redirects stderr to a temporary file.
   CapturedStderr() {
-    uncaptured_fd_ = dup(STDERR_FILENO);
+    uncaptured_fd_ = dup(kStdErrFileno);
 
+#if GTEST_OS_WINDOWS
+    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+
+    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
+    ::GetTempFileNameA(temp_dir_path, "gtest_redir", 0, temp_file_path);
+    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
+    filename_ = temp_file_path;
+#else
     // There's no guarantee that a test has write access to the
     // current directory, so we create the temporary file in the /tmp
     // directory instead.
     char name_template[] = "/tmp/captured_stderr.XXXXXX";
     const int captured_fd = mkstemp(name_template);
     filename_ = name_template;
+#endif  // GTEST_OS_WINDOWS
     fflush(NULL);
-    dup2(captured_fd, STDERR_FILENO);
+    dup2(captured_fd, kStdErrFileno);
     close(captured_fd);
   }
 
@@ -412,7 +443,7 @@ class CapturedStderr {
   void StopCapture() {
     // Restores the original stream.
     fflush(NULL);
-    dup2(uncaptured_fd_, STDERR_FILENO);
+    dup2(uncaptured_fd_, kStdErrFileno);
     close(uncaptured_fd_);
     uncaptured_fd_ = -1;
   }
@@ -427,6 +458,10 @@ class CapturedStderr {
   ::std::string filename_;
 };
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
+
 static CapturedStderr* g_captured_stderr = NULL;
 
 // Returns the size (in bytes) of a file.
@@ -436,8 +471,6 @@ static size_t GetFileSize(FILE * file) {
 }
 
 // Reads the entire content of a file as a string.
-// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can
-// use it here.
 static ::std::string ReadEntireFile(FILE * file) {
   const size_t file_size = GetFileSize(file);
   char* const buffer = new char[file_size];
@@ -473,9 +506,18 @@ void CaptureStderr() {
 // use it here.
 ::std::string GetCapturedStderr() {
   g_captured_stderr->StopCapture();
+
+// Disables Microsoft deprecation warning for fopen and fclose.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4996)
+#endif  // _MSC_VER
   FILE* const file = fopen(g_captured_stderr->filename().c_str(), "r");
   const ::std::string content = ReadEntireFile(file);
   fclose(file);
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
 
   delete g_captured_stderr;
   g_captured_stderr = NULL;
@@ -483,6 +525,10 @@ void CaptureStderr() {
   return content;
 }
 
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_DEATH_TEST
+
 // A copy of all command line arguments.  Set by InitGoogleTest().
 ::std::vector<String> g_argvs;
 

src/gtest.cc

@@ -3300,17 +3300,43 @@ void UnitTest::RecordPropertyForCurrentTest(const char* key,
 int UnitTest::Run() {
 #if GTEST_OS_WINDOWS
 
+  const bool in_death_test_child_process =
+      internal::GTEST_FLAG(internal_run_death_test).GetLength() > 0;
+
+  // Either the user wants Google Test to catch exceptions thrown by the
+  // tests or this is executing in the context of death test child
+  // process. In either case the user does not want to see pop-up dialogs
+  // about crashes - they are expected..
+  if (GTEST_FLAG(catch_exceptions) || in_death_test_child_process) {
 #if !defined(_WIN32_WCE)
     // SetErrorMode doesn't exist on CE.
-  if (GTEST_FLAG(catch_exceptions)) {
-    // The user wants Google Test to catch exceptions thrown by the tests.
-
-    // This lets fatal errors be handled by us, instead of causing pop-ups.
     SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
                  SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
-  }
 #endif  // _WIN32_WCE
 
+    // Death test children can be terminated with _abort().  On Windows,
+    // _abort() can show a dialog with a warning message.  This forces the
+    // abort message to go to stderr instead.
+    _set_error_mode(_OUT_TO_STDERR);
+
+    // In the debug version, Visual Studio pops up a separate dialog
+    // offering a choice to debug the aborted program. We need to suppress
+    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
+    // executed. Google Test will notify the user of any unexpected
+    // failure via stderr.
+#if _MSC_VER >= 1400
+    // VC++ doesn't define _set_abort_behavior() prior to the version 8.0.
+    // Users of prior VC versions shall suffer the agony and pain of
+    // clicking through the countless debug dialogs.
+    // TODO(vladl@google.com): find a way to suppress the abort dialog() in the
+    // debug mode when compiled with VC 7.1 or lower.
+    if (!GTEST_FLAG(break_on_failure))
+      _set_abort_behavior(
+          0x0,                                    // Clear the following flags:
+          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
+#endif  // _MSC_VER >= 1400
+  }
+
   __try {
     return impl_->RunAllTests();
   } __except(internal::UnitTestOptions::GTestShouldProcessSEH(

test/gtest-death-test_test.cc

@@ -36,8 +36,16 @@
 
 #if GTEST_HAS_DEATH_TEST
 
-#include <stdio.h>
+#if GTEST_OS_WINDOWS
+#include <direct.h>          // For chdir().
+#else
 #include <unistd.h>
+#include <limits>            // For std::numeric_limits.
+#endif  // GTEST_OS_WINDOWS
+
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
 #include <gtest/gtest-spi.h>
 
 // Indicates that this translation unit is part of Google Test's
@@ -49,8 +57,13 @@
 #include "src/gtest-internal-inl.h"
 #undef GTEST_IMPLEMENTATION_
 
+using testing::Message;
+
 using testing::internal::DeathTest;
 using testing::internal::DeathTestFactory;
+using testing::internal::GetLastSystemErrorMessage;
+using testing::internal::ParseNaturalNumber;
+using testing::internal::String;
 
 namespace testing {
 namespace internal {
@@ -88,6 +101,7 @@ class TestForDeathTest : public testing::Test {
   // A static member function that's expected to die.
   static void StaticMemberFunction() {
     fprintf(stderr, "%s", "death inside StaticMemberFunction().");
+    fflush(stderr);
     // We call _exit() instead of exit(), as the former is a direct
     // system call and thus safer in the presence of threads.  exit()
     // will invoke user-defined exit-hooks, which may do dangerous
@@ -99,6 +113,7 @@ class TestForDeathTest : public testing::Test {
   void MemberFunction() {
     if (should_die_) {
       fprintf(stderr, "%s", "death inside MemberFunction().");
+      fflush(stderr);
       _exit(1);
     }
   }
@@ -165,6 +180,21 @@ int DieInDebugElse12(int* sideeffect) {
   return 12;
 }
 
+#if GTEST_OS_WINDOWS
+
+// Tests the ExitedWithCode predicate.
+TEST(ExitStatusPredicateTest, ExitedWithCode) {
+  // On Windows, the process's exit code is the same as its exit status,
+  // so the predicate just compares the its input with its parameter.
+  EXPECT_TRUE(testing::ExitedWithCode(0)(0));
+  EXPECT_TRUE(testing::ExitedWithCode(1)(1));
+  EXPECT_TRUE(testing::ExitedWithCode(42)(42));
+  EXPECT_FALSE(testing::ExitedWithCode(0)(1));
+  EXPECT_FALSE(testing::ExitedWithCode(1)(0));
+}
+
+#else
+
 // Returns the exit status of a process that calls _exit(2) with a
 // given exit code.  This is a helper function for the
 // ExitStatusPredicateTest test suite.
@@ -222,6 +252,8 @@ TEST(ExitStatusPredicateTest, KilledBySignal) {
   EXPECT_FALSE(pred_kill(status_segv));
 }
 
+#endif  // GTEST_OS_WINDOWS
+
 // Tests that the death test macros expand to code which may or may not
 // be followed by operator<<, and that in either case the complete text
 // comprises only a single C++ statement.
@@ -248,6 +280,7 @@ TEST_F(TestForDeathTest, SingleStatement) {
 
 void DieWithEmbeddedNul() {
   fprintf(stderr, "Hello%cworld.\n", '\0');
+  fflush(stderr);
   _exit(1);
 }
 
@@ -263,6 +296,13 @@ TEST_F(TestForDeathTest, DISABLED_EmbeddedNulInMessage) {
 // Tests that death test macros expand to code which interacts well with switch
 // statements.
 TEST_F(TestForDeathTest, SwitchStatement) {
+// Microsoft compiler usually complains about switch statements without
+// case labels. We suppress that warning for this test.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4065)
+#endif  // _MSC_VER
+
   switch (0)
     default:
       ASSERT_DEATH(_exit(1), "") << "exit in default switch handler";
@@ -270,6 +310,10 @@ TEST_F(TestForDeathTest, SwitchStatement) {
   switch (0)
     case 0:
       EXPECT_DEATH(_exit(1), "") << "exit in switch case";
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
 }
 
 // Tests that a static member function can be used in a "fast" style
@@ -287,15 +331,23 @@ TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
   EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
 }
 
+void ChangeToRootDir() {
+#if GTEST_OS_WINDOWS
+  _chdir("\\");
+#else
+  chdir("/");
+#endif  // GTEST_OS_WINDOWS
+}
+
 // Tests that death tests work even if the current directory has been
 // changed.
 TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
   testing::GTEST_FLAG(death_test_style) = "fast";
 
-  chdir("/");
+  ChangeToRootDir();
   EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
 
-  chdir("/");
+  ChangeToRootDir();
   ASSERT_DEATH(_exit(1), "");
 }
 
@@ -322,10 +374,10 @@ TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
 TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
 
-  chdir("/");
+  ChangeToRootDir();
   EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
 
-  chdir("/");
+  ChangeToRootDir();
   ASSERT_DEATH(_exit(1), "");
 }
 
@@ -346,6 +398,8 @@ void SetPthreadFlag() {
 
 }  // namespace
 
+#if !GTEST_OS_WINDOWS
+
 TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
   if (!testing::GTEST_FLAG(death_test_use_fork)) {
     testing::GTEST_FLAG(death_test_style) = "threadsafe";
@@ -356,6 +410,8 @@ TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
   }
 }
 
+#endif  // !GTEST_OS_WINDOWS
+
 // Tests that a method of another class can be used in a death test.
 TEST_F(TestForDeathTest, MethodOfAnotherClass) {
   const MayDie x(true);
@@ -537,6 +593,30 @@ void ExpectDebugDeathHelper(bool* aborted) {
   *aborted = false;
 }
 
+#if GTEST_OS_WINDOWS
+TEST(TestForPopUps, DoesNotShowPopUpOnAbort) {
+  printf("This test should be considered failing if it shows "
+         "any pop-up dialogs.\n");
+  fflush(stdout);
+
+  EXPECT_DEATH({
+    testing::GTEST_FLAG(catch_exceptions) = false;
+    abort();
+  }, "");
+}
+
+TEST(TestForPopUps, DoesNotShowPopUpOnThrow) {
+  printf("This test should be considered failing if it shows "
+         "any pop-up dialogs.\n");
+  fflush(stdout);
+
+  EXPECT_DEATH({
+    testing::GTEST_FLAG(catch_exceptions) = false;
+    throw 1;
+  }, "");
+}
+#endif  // GTEST_OS_WINDOWS
+
 // Tests that EXPECT_DEBUG_DEATH in debug mode does not abort
 // the function.
 TEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) {
@@ -566,18 +646,38 @@ TEST_F(TestForDeathTest, AssertDebugDeathAborts) {
 static void TestExitMacros() {
   EXPECT_EXIT(_exit(1),  testing::ExitedWithCode(1),  "");
   ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");
-  EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo";
+
-  ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar";
+#if GTEST_OS_WINDOWS
+  EXPECT_EXIT({
+    testing::GTEST_FLAG(catch_exceptions) = false;
+    *static_cast<int*>(NULL) = 1;
+  }, testing::ExitedWithCode(0xC0000005), "") << "foo";
 
   EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
+    EXPECT_EXIT({
-        << "This failure is expected.";
+      testing::GTEST_FLAG(catch_exceptions) = false;
+      *static_cast<int*>(NULL) = 1;
+    }, testing::ExitedWithCode(0), "") << "This failure is expected.";
   }, "This failure is expected.");
 
+  // Of all signals effects on the process exit code, only those of SIGABRT
+  // are documented on Windows.
+  // See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx.
+  EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "");
+#else
+  EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo";
+  ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar";
+
   EXPECT_FATAL_FAILURE({  // NOLINT
     ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
         << "This failure is expected, too.";
   }, "This failure is expected, too.");
+#endif  // GTEST_OS_WINDOWS
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
+        << "This failure is expected.";
+  }, "This failure is expected.");
 }
 
 TEST_F(TestForDeathTest, ExitMacros) {
@@ -873,6 +973,156 @@ TEST(StreamingAssertionsDeathTest, DeathTest) {
   }, "expected failure");
 }
 
+// Tests that GetLastSystemErrorMessage returns an empty string when the
+// last error is 0 and non-empty string when it is non-zero.
+TEST(GetLastSystemErrorMessageTest, GetLastSystemErrorMessageWorks) {
+#if GTEST_OS_WINDOWS
+  ::SetLastError(ERROR_FILE_NOT_FOUND);
+  EXPECT_STRNE("", GetLastSystemErrorMessage().c_str());
+  ::SetLastError(0);
+  EXPECT_STREQ("", GetLastSystemErrorMessage().c_str());
+#else
+  errno = ENOENT;
+  EXPECT_STRNE("", GetLastSystemErrorMessage().c_str());
+  errno = 0;
+  EXPECT_STREQ("", GetLastSystemErrorMessage().c_str());
+#endif
+}
+
+#if GTEST_OS_WINDOWS
+TEST(AutoHandleTest, AutoHandleWorks) {
+  HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+  ASSERT_NE(INVALID_HANDLE_VALUE, handle);
+
+  // Tests that the AutoHandle is correctly initialized with a handle.
+  testing::internal::AutoHandle auto_handle(handle);
+  EXPECT_EQ(handle, auto_handle.Get());
+
+  // Tests that Reset assigns INVALID_HANDLE_VALUE.
+  // Note that this cannot verify whether the original handle is closed.
+  auto_handle.Reset();
+  EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get());
+
+  // Tests that Reset assigns the new handle.
+  // Note that this cannot verify whether the original handle is closed.
+  handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+  ASSERT_NE(INVALID_HANDLE_VALUE, handle);
+  auto_handle.Reset(handle);
+  EXPECT_EQ(handle, auto_handle.Get());
+
+  // Tests that AutoHandle contains INVALID_HANDLE_VALUE by default.
+  testing::internal::AutoHandle auto_handle2;
+  EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get());
+}
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_WINDOWS
+typedef unsigned __int64 BiggestParsable;
+typedef signed __int64 BiggestSignedParsable;
+const BiggestParsable kBiggestParsableMax = ULLONG_MAX;
+const BiggestParsable kBiggestSignedParsableMax = LLONG_MAX;
+#else
+typedef unsigned long long BiggestParsable;
+typedef signed long long BiggestSignedParsable;
+const BiggestParsable kBiggestParsableMax =
+    ::std::numeric_limits<BiggestParsable>::max();
+const BiggestSignedParsable kBiggestSignedParsableMax =
+    ::std::numeric_limits<BiggestSignedParsable>::max();
+#endif  // GTEST_OS_WINDOWS
+
+TEST(ParseNaturalNumberTest, RejectsInvalidFormat) {
+  BiggestParsable result = 0;
+
+  // Rejects non-numbers.
+  EXPECT_FALSE(ParseNaturalNumber(String("non-number string"), &result));
+
+  // Rejects numbers with whitespace prefix.
+  EXPECT_FALSE(ParseNaturalNumber(String(" 123"), &result));
+
+  // Rejects negative numbers.
+  EXPECT_FALSE(ParseNaturalNumber(String("-123"), &result));
+
+  // Rejects numbers starting with a plus sign.
+  EXPECT_FALSE(ParseNaturalNumber(String("+123"), &result));
+  errno = 0;
+}
+
+TEST(ParseNaturalNumberTest, RejectsOverflownNumbers) {
+  BiggestParsable result = 0;
+
+  EXPECT_FALSE(ParseNaturalNumber(String("99999999999999999999999"), &result));
+
+  signed char char_result = 0;
+  EXPECT_FALSE(ParseNaturalNumber(String("200"), &char_result));
+  errno = 0;
+}
+
+TEST(ParseNaturalNumberTest, AcceptsValidNumbers) {
+  BiggestParsable result = 0;
+
+  result = 0;
+  ASSERT_TRUE(ParseNaturalNumber(String("123"), &result));
+  EXPECT_EQ(123, result);
+
+  // Check 0 as an edge case.
+  result = 1;
+  ASSERT_TRUE(ParseNaturalNumber(String("0"), &result));
+  EXPECT_EQ(0, result);
+
+  result = 1;
+  ASSERT_TRUE(ParseNaturalNumber(String("00000"), &result));
+  EXPECT_EQ(0, result);
+}
+
+TEST(ParseNaturalNumberTest, AcceptsTypeLimits) {
+  Message msg;
+  msg << kBiggestParsableMax;
+
+  BiggestParsable result = 0;
+  EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result));
+  EXPECT_EQ(kBiggestParsableMax, result);
+
+  Message msg2;
+  msg2 << kBiggestSignedParsableMax;
+
+  BiggestSignedParsable signed_result = 0;
+  EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result));
+  EXPECT_EQ(kBiggestSignedParsableMax, signed_result);
+
+  Message msg3;
+  msg3 << INT_MAX;
+
+  int int_result = 0;
+  EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result));
+  EXPECT_EQ(INT_MAX, int_result);
+
+  Message msg4;
+  msg4 << UINT_MAX;
+
+  unsigned int uint_result = 0;
+  EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result));
+  EXPECT_EQ(UINT_MAX, uint_result);
+}
+
+TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
+  short short_result = 0;
+  ASSERT_TRUE(ParseNaturalNumber(String("123"), &short_result));
+  EXPECT_EQ(123, short_result);
+
+  signed char char_result = 0;
+  ASSERT_TRUE(ParseNaturalNumber(String("123"), &char_result));
+  EXPECT_EQ(123, char_result);
+}
+
+#if GTEST_OS_WINDOWS
+TEST(EnvironmentTest, HandleFitsIntoSizeT) {
+  // TODO(vladl@google.com): Remove this test after this condition is verified
+  // in a static assertion in gtest-death-test.cc in the function
+  // GetStatusFileDescriptor.
+  ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t));
+}
+#endif  // GTEST_OS_WINDOWS
+
 #endif  // GTEST_HAS_DEATH_TEST
 
 // Tests that a test case whose name ends with "DeathTest" works fine

test/gtest-port_test.cc

@@ -80,13 +80,15 @@ TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
 
 TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
   const bool a_false_condition = false;
-  EXPECT_DEATH(GTEST_CHECK_(a_false_condition) << "Extra info",
+  const char regex[] =
 #ifdef _MSC_VER
-               "gtest-port_test\\.cc\\([0-9]+\\):"
+     "gtest-port_test\\.cc\\(\\d+\\):"
 #else
      "gtest-port_test\\.cc:[0-9]+"
 #endif  // _MSC_VER
-                   ".*a_false_condition.*Extra info.*");
+     ".*a_false_condition.*Extra info.*";
+
+  EXPECT_DEATH(GTEST_CHECK_(a_false_condition) << "Extra info", regex);
 }
 
 TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
@@ -575,25 +577,25 @@ TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {
 
 // Tests RE's implicit constructors.
 TEST(RETest, ImplicitConstructorWorks) {
-  const RE empty = "";
+  const RE empty("");
   EXPECT_STREQ("", empty.pattern());
 
-  const RE simple = "hello";
+  const RE simple("hello");
   EXPECT_STREQ("hello", simple.pattern());
 }
 
 // Tests that RE's constructors reject invalid regular expressions.
 TEST(RETest, RejectsInvalidRegex) {
   EXPECT_NONFATAL_FAILURE({
-    const RE normal = NULL;
+    const RE normal(NULL);
   }, "NULL is not a valid simple regular expression");
 
   EXPECT_NONFATAL_FAILURE({
-    const RE normal = ".*(\\w+";
+    const RE normal(".*(\\w+");
   }, "'(' is unsupported");
 
   EXPECT_NONFATAL_FAILURE({
-    const RE invalid = "^?";
+    const RE invalid("^?");
   }, "'?' can only follow a repeatable token");
 }
 
@@ -603,10 +605,10 @@ TEST(RETest, FullMatchWorks) {
   EXPECT_TRUE(RE::FullMatch("", empty));
   EXPECT_FALSE(RE::FullMatch("a", empty));
 
-  const RE re1 = "a";
+  const RE re1("a");
   EXPECT_TRUE(RE::FullMatch("a", re1));
 
-  const RE re = "a.*z";
+  const RE re("a.*z");
   EXPECT_TRUE(RE::FullMatch("az", re));
   EXPECT_TRUE(RE::FullMatch("axyz", re));
   EXPECT_FALSE(RE::FullMatch("baz", re));
@@ -615,11 +617,11 @@ TEST(RETest, FullMatchWorks) {
 
 // Tests RE::PartialMatch().
 TEST(RETest, PartialMatchWorks) {
-  const RE empty = "";
+  const RE empty("");
   EXPECT_TRUE(RE::PartialMatch("", empty));
   EXPECT_TRUE(RE::PartialMatch("a", empty));
 
-  const RE re = "a.*z";
+  const RE re("a.*z");
   EXPECT_TRUE(RE::PartialMatch("az", re));
   EXPECT_TRUE(RE::PartialMatch("axyz", re));
   EXPECT_TRUE(RE::PartialMatch("baz", re));
@@ -629,5 +631,15 @@ TEST(RETest, PartialMatchWorks) {
 
 #endif  // GTEST_USES_POSIX_RE
 
+#if GTEST_HAS_STD_STRING
+
+TEST(CaptureStderrTest, CapturesStdErr) {
+  CaptureStderr();
+  fprintf(stderr, "abc");
+  ASSERT_EQ("abc", GetCapturedStderr());
+}
+
+#endif  // GTEST_HAS_STD_STRING
+
 }  // namespace internal
 }  // namespace testing

test/gtest_output_test_.cc

@@ -988,7 +988,18 @@ int main(int argc, char **argv) {
   if (testing::internal::GTEST_FLAG(internal_run_death_test) != "") {
     // Skip the usual output capturing if we're running as the child
     // process of an threadsafe-style death test.
+#if GTEST_OS_WINDOWS
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4996)
+#endif  // _MSC_VER
+    freopen("nul:", "w", stdout);
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
+#else
     freopen("/dev/null", "w", stdout);
+#endif  // GTEST_OS_WINDOWS
     return RUN_ALL_TESTS();
   }
 #endif  // GTEST_HAS_DEATH_TEST

test/gtest_output_test_golden_win.txt

@@ -5,10 +5,25 @@ gtest_output_test_.cc:#: error: Value of: false
 Expected: true
 gtest_output_test_.cc:#: error: Value of: 3
 Expected: 2
-[==========] Running 52 tests from 21 test cases.
+[==========] Running 57 tests from 26 test cases.
 [----------] Global test environment set-up.
 FooEnvironment::SetUp() called.
 BarEnvironment::SetUp() called.
+[----------] 1 test from ADeathTest
+[ RUN      ] ADeathTest.ShouldRunFirst
+[       OK ] ADeathTest.ShouldRunFirst
+[----------] 1 test from ATypedDeathTest/0, where TypeParam = int
+[ RUN      ] ATypedDeathTest/0.ShouldRunFirst
+[       OK ] ATypedDeathTest/0.ShouldRunFirst
+[----------] 1 test from ATypedDeathTest/1, where TypeParam = double
+[ RUN      ] ATypedDeathTest/1.ShouldRunFirst
+[       OK ] ATypedDeathTest/1.ShouldRunFirst
+[----------] 1 test from My/ATypeParamDeathTest/0, where TypeParam = int
+[ RUN      ] My/ATypeParamDeathTest/0.ShouldRunFirst
+[       OK ] My/ATypeParamDeathTest/0.ShouldRunFirst
+[----------] 1 test from My/ATypeParamDeathTest/1, where TypeParam = double
+[ RUN      ] My/ATypeParamDeathTest/1.ShouldRunFirst
+[       OK ] My/ATypeParamDeathTest/1.ShouldRunFirst
 [----------] 2 tests from PassingTest
 [ RUN      ] PassingTest.PassingTest1
 [       OK ] PassingTest.PassingTest1
@@ -445,8 +460,8 @@ Expected non-fatal failure.
 FooEnvironment::TearDown() called.
 gtest_output_test_.cc:#: error: Failed
 Expected fatal failure.
-[==========] 52 tests from 21 test cases ran.
+[==========] 57 tests from 26 test cases ran.
-[  PASSED  ] 16 tests.
+[  PASSED  ] 21 tests.
 [  FAILED  ] 36 tests, listed below:
 [  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
 [  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine