Cleans up macro definitions.

18 files changed, 243 insertions, 237 deletions

diff --git a/test/gtest-death-test_test.cc b/test/gtest-death-test_test.cc
index 204ec413..6d8a3f89 100644
--- a/test/gtest-death-test_test.cc
+++ b/test/gtest-death-test_test.cc
@@ -34,7 +34,7 @@
 #include <gtest/gtest-death-test.h>
 #include <gtest/gtest.h>
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
 
 #include <stdio.h>
 #include <unistd.h>
@@ -45,9 +45,9 @@
 // included, or there will be a compiler error.  This trick is to
 // prevent a user from accidentally including gtest-internal-inl.h in
 // his code.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 using testing::internal::DeathTest;
 using testing::internal::DeathTestFactory;
diff --git a/test/gtest-filepath_test.cc b/test/gtest-filepath_test.cc
index ee80f0d9..dfbd5f02 100644
--- a/test/gtest-filepath_test.cc
+++ b/test/gtest-filepath_test.cc
@@ -46,19 +46,19 @@
 // included, or there will be a compiler error.  This trick is to
 // prevent a user from accidentally including gtest-internal-inl.h in
 // his code.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 #ifdef _WIN32_WCE
 #include <windows.h>  // NOLINT
 #else
 #include <direct.h>  // NOLINT
 #endif  // _WIN32_WCE
-#define PATH_SEP "\\"
+#define GTEST_PATH_SEP_ "\\"
 #else
-#define PATH_SEP "/"
+#define GTEST_PATH_SEP_ "/"
 #endif  // GTEST_OS_WINDOWS
 
 namespace testing {
@@ -90,16 +90,16 @@ int _rmdir(const char* path) {
 TEST(GetCurrentDirTest, ReturnsCurrentDir) {
   EXPECT_FALSE(FilePath::GetCurrentDir().IsEmpty());
 
-#ifdef GTEST_OS_WINDOWS
-  _chdir(PATH_SEP);
+#if GTEST_OS_WINDOWS
+  _chdir(GTEST_PATH_SEP_);
   const FilePath cwd = FilePath::GetCurrentDir();
   // Skips the ":".
   const char* const cwd_without_drive = strchr(cwd.c_str(), ':');
   ASSERT_TRUE(cwd_without_drive != NULL);
-  EXPECT_STREQ(PATH_SEP, cwd_without_drive + 1);
+  EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);
 #else
-  chdir(PATH_SEP);
-  EXPECT_STREQ(PATH_SEP, FilePath::GetCurrentDir().c_str());
+  chdir(GTEST_PATH_SEP_);
+  EXPECT_STREQ(GTEST_PATH_SEP_, FilePath::GetCurrentDir().c_str());
 #endif
 }
 
@@ -131,25 +131,25 @@ TEST(RemoveDirectoryNameTest, ButNoDirectory) {
 // RemoveDirectoryName "/afile" -> "afile"
 TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {
   EXPECT_STREQ("afile",
-      FilePath(PATH_SEP "afile").RemoveDirectoryName().c_str());
+      FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());
 }
 
 // RemoveDirectoryName "adir/" -> ""
 TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {
   EXPECT_STREQ("",
-      FilePath("adir" PATH_SEP).RemoveDirectoryName().c_str());
+      FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().c_str());
 }
 
 // RemoveDirectoryName "adir/afile" -> "afile"
 TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {
   EXPECT_STREQ("afile",
-      FilePath("adir" PATH_SEP "afile").RemoveDirectoryName().c_str());
+      FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());
 }
 
 // RemoveDirectoryName "adir/subdir/afile" -> "afile"
 TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
   EXPECT_STREQ("afile",
-      FilePath("adir" PATH_SEP "subdir" PATH_SEP "afile")
+      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
       .RemoveDirectoryName().c_str());
 }
 
@@ -158,63 +158,63 @@ TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
 TEST(RemoveFileNameTest, EmptyName) {
 #ifdef _WIN32_WCE
   // On Windows CE, we use the root as the current directory.
-  EXPECT_STREQ(PATH_SEP,
+  EXPECT_STREQ(GTEST_PATH_SEP_,
       FilePath("").RemoveFileName().c_str());
 #else
-  EXPECT_STREQ("." PATH_SEP,
+  EXPECT_STREQ("." GTEST_PATH_SEP_,
       FilePath("").RemoveFileName().c_str());
 #endif
 }
 
 // RemoveFileName "adir/" -> "adir/"
 TEST(RemoveFileNameTest, ButNoFile) {
-  EXPECT_STREQ("adir" PATH_SEP,
-      FilePath("adir" PATH_SEP).RemoveFileName().c_str());
+  EXPECT_STREQ("adir" GTEST_PATH_SEP_,
+      FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().c_str());
 }
 
 // RemoveFileName "adir/afile" -> "adir/"
 TEST(RemoveFileNameTest, GivesDirName) {
-  EXPECT_STREQ("adir" PATH_SEP,
-      FilePath("adir" PATH_SEP "afile")
+  EXPECT_STREQ("adir" GTEST_PATH_SEP_,
+      FilePath("adir" GTEST_PATH_SEP_ "afile")
       .RemoveFileName().c_str());
 }
 
 // RemoveFileName "adir/subdir/afile" -> "adir/subdir/"
 TEST(RemoveFileNameTest, GivesDirAndSubDirName) {
-  EXPECT_STREQ("adir" PATH_SEP "subdir" PATH_SEP,
-      FilePath("adir" PATH_SEP "subdir" PATH_SEP "afile")
+  EXPECT_STREQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
+      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
       .RemoveFileName().c_str());
 }
 
 // RemoveFileName "/afile" -> "/"
 TEST(RemoveFileNameTest, GivesRootDir) {
-  EXPECT_STREQ(PATH_SEP,
-      FilePath(PATH_SEP "afile").RemoveFileName().c_str());
+  EXPECT_STREQ(GTEST_PATH_SEP_,
+      FilePath(GTEST_PATH_SEP_ "afile").RemoveFileName().c_str());
 }
 
 
 TEST(MakeFileNameTest, GenerateWhenNumberIsZero) {
   FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
       0, "xml");
-  EXPECT_STREQ("foo" PATH_SEP "bar.xml", actual.c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
 }
 
 TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {
   FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
       12, "xml");
-  EXPECT_STREQ("foo" PATH_SEP "bar_12.xml", actual.c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());
 }
 
 TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {
-  FilePath actual = FilePath::MakeFileName(FilePath("foo" PATH_SEP),
+  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
       FilePath("bar"), 0, "xml");
-  EXPECT_STREQ("foo" PATH_SEP "bar.xml", actual.c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
 }
 
 TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {
-  FilePath actual = FilePath::MakeFileName(FilePath("foo" PATH_SEP),
+  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
       FilePath("bar"), 12, "xml");
-  EXPECT_STREQ("foo" PATH_SEP "bar_12.xml", actual.c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());
 }
 
 TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {
@@ -232,13 +232,13 @@ TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {
 TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {
   FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
                                           FilePath("bar.xml"));
-  EXPECT_STREQ("foo" PATH_SEP "bar.xml", actual.c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
 }
 
 TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo" PATH_SEP),
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),
                                           FilePath("bar.xml"));
-  EXPECT_STREQ("foo" PATH_SEP "bar.xml", actual.c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
 }
 
 TEST(ConcatPathsTest, Path1BeingEmpty) {
@@ -250,7 +250,7 @@ TEST(ConcatPathsTest, Path1BeingEmpty) {
 TEST(ConcatPathsTest, Path2BeingEmpty) {
   FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
                                           FilePath(""));
-  EXPECT_STREQ("foo" PATH_SEP, actual.c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_, actual.c_str());
 }
 
 TEST(ConcatPathsTest, BothPathBeingEmpty) {
@@ -260,21 +260,24 @@ TEST(ConcatPathsTest, BothPathBeingEmpty) {
 }
 
 TEST(ConcatPathsTest, Path1ContainsPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo" PATH_SEP "bar"),
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_ "bar"),
                                           FilePath("foobar.xml"));
-  EXPECT_STREQ("foo" PATH_SEP "bar" PATH_SEP "foobar.xml", actual.c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "foobar.xml",
+               actual.c_str());
 }
 
 TEST(ConcatPathsTest, Path2ContainsPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo" PATH_SEP),
-                                          FilePath("bar" PATH_SEP "bar.xml"));
-  EXPECT_STREQ("foo" PATH_SEP "bar" PATH_SEP "bar.xml", actual.c_str());
+  FilePath actual = FilePath::ConcatPaths(
+      FilePath("foo" GTEST_PATH_SEP_),
+      FilePath("bar" GTEST_PATH_SEP_ "bar.xml"));
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "bar.xml",
+               actual.c_str());
 }
 
 TEST(ConcatPathsTest, Path2EndsWithPathSep) {
   FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
-                                          FilePath("bar" PATH_SEP));
-  EXPECT_STREQ("foo" PATH_SEP "bar" PATH_SEP, actual.c_str());
+                                          FilePath("bar" GTEST_PATH_SEP_));
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.c_str());
 }
 
 // RemoveTrailingPathSeparator "" -> ""
@@ -291,25 +294,27 @@ TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {
 
 // RemoveTrailingPathSeparator "foo/" -> "foo"
 TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
-  EXPECT_STREQ("foo",
-      FilePath("foo" PATH_SEP).RemoveTrailingPathSeparator().c_str());
+  EXPECT_STREQ(
+      "foo",
+      FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().c_str());
 }
 
 // RemoveTrailingPathSeparator "foo/bar/" -> "foo/bar/"
 TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {
-  EXPECT_STREQ("foo" PATH_SEP "bar",
-      FilePath("foo" PATH_SEP "bar" PATH_SEP).RemoveTrailingPathSeparator()
-      .c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
+               FilePath("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_)
+               .RemoveTrailingPathSeparator().c_str());
 }
 
 // RemoveTrailingPathSeparator "foo/bar" -> "foo/bar"
 TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {
-  EXPECT_STREQ("foo" PATH_SEP "bar",
-      FilePath("foo" PATH_SEP "bar").RemoveTrailingPathSeparator().c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
+               FilePath("foo" GTEST_PATH_SEP_ "bar")
+               .RemoveTrailingPathSeparator().c_str());
 }
 
 TEST(DirectoryTest, RootDirectoryExists) {
-#ifdef GTEST_OS_WINDOWS  // We are on Windows.
+#if GTEST_OS_WINDOWS  // We are on Windows.
   char current_drive[_MAX_PATH];  // NOLINT
   current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1);
   current_drive[1] = ':';
@@ -321,7 +326,7 @@ TEST(DirectoryTest, RootDirectoryExists) {
 #endif  // GTEST_OS_WINDOWS
 }
 
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {
   const int saved_drive_ = _getdrive();
   // Find a drive that doesn't exist. Start with 'Z' to avoid common ones.
@@ -347,7 +352,7 @@ TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
 #endif  // ! _WIN32_WCE
 
 TEST(DirectoryTest, CurrentDirectoryExists) {
-#ifdef GTEST_OS_WINDOWS  // We are on Windows.
+#if GTEST_OS_WINDOWS  // We are on Windows.
 #ifndef _WIN32_CE  // Windows CE doesn't have a current directory.
   EXPECT_TRUE(FilePath(".").DirectoryExists());
   EXPECT_TRUE(FilePath(".\\").DirectoryExists());
@@ -365,32 +370,33 @@ TEST(NormalizeTest, NullStringsEqualEmptyDirectory) {
 
 // "foo/bar" == foo//bar" == "foo///bar"
 TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {
-  EXPECT_STREQ("foo" PATH_SEP "bar",
-    FilePath("foo" PATH_SEP "bar").c_str());
-  EXPECT_STREQ("foo" PATH_SEP "bar",
-    FilePath("foo" PATH_SEP PATH_SEP "bar").c_str());
-  EXPECT_STREQ("foo" PATH_SEP "bar",
-    FilePath("foo" PATH_SEP PATH_SEP PATH_SEP "bar").c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
+               FilePath("foo" GTEST_PATH_SEP_ "bar").c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
+               FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",
+               FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_
+                        GTEST_PATH_SEP_ "bar").c_str());
 }
 
 // "/bar" == //bar" == "///bar"
 TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringStart) {
-  EXPECT_STREQ(PATH_SEP "bar",
-    FilePath(PATH_SEP "bar").c_str());
-  EXPECT_STREQ(PATH_SEP "bar",
-    FilePath(PATH_SEP PATH_SEP "bar").c_str());
-  EXPECT_STREQ(PATH_SEP "bar",
-    FilePath(PATH_SEP PATH_SEP PATH_SEP "bar").c_str());
+  EXPECT_STREQ(GTEST_PATH_SEP_ "bar",
+    FilePath(GTEST_PATH_SEP_ "bar").c_str());
+  EXPECT_STREQ(GTEST_PATH_SEP_ "bar",
+    FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());
+  EXPECT_STREQ(GTEST_PATH_SEP_ "bar",
+    FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());
 }
 
 // "foo/" == foo//" == "foo///"
 TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringEnd) {
-  EXPECT_STREQ("foo" PATH_SEP,
-    FilePath("foo" PATH_SEP).c_str());
-  EXPECT_STREQ("foo" PATH_SEP,
-    FilePath("foo" PATH_SEP PATH_SEP).c_str());
-  EXPECT_STREQ("foo" PATH_SEP,
-    FilePath("foo" PATH_SEP PATH_SEP PATH_SEP).c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_,
+    FilePath("foo" GTEST_PATH_SEP_).c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_,
+    FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_).c_str());
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_,
+    FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_).c_str());
 }
 
 TEST(AssignmentOperatorTest, DefaultAssignedToNonDefault) {
@@ -421,7 +427,7 @@ class DirectoryCreationTest : public Test {
   virtual void SetUp() {
     testdata_path_.Set(FilePath(String::Format("%s%s%s",
         TempDir().c_str(), GetCurrentExecutableName().c_str(),
-        "_directory_creation" PATH_SEP "test" PATH_SEP)));
+        "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_)));
     testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());
 
     unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
@@ -432,7 +438,7 @@ class DirectoryCreationTest : public Test {
     remove(testdata_file_.c_str());
     remove(unique_file0_.c_str());
     remove(unique_file1_.c_str());
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
     _rmdir(testdata_path_.c_str());
 #else
     rmdir(testdata_path_.c_str());
@@ -443,7 +449,7 @@ class DirectoryCreationTest : public Test {
     remove(testdata_file_.c_str());
     remove(unique_file0_.c_str());
     remove(unique_file1_.c_str());
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
     _rmdir(testdata_path_.c_str());
 #else
     rmdir(testdata_path_.c_str());
@@ -454,7 +460,7 @@ class DirectoryCreationTest : public Test {
 #ifdef _WIN32_WCE
     return String("\\temp\\");
 
-#elif defined(GTEST_OS_WINDOWS)
+#elif GTEST_OS_WINDOWS
     // MSVC 8 deprecates getenv(), so we want to suppress warning 4996
     // (deprecated function) there.
 #pragma warning(push)          // Saves the current warning state.
@@ -474,7 +480,7 @@ class DirectoryCreationTest : public Test {
   }
 
   void CreateTextFile(const char* filename) {
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
     // MSVC 8 deprecates fopen(), so we want to suppress warning 4996
     // (deprecated function) there.#pragma warning(push)
 #pragma warning(push)          // Saves the current warning state.
@@ -585,18 +591,18 @@ TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {
 
 TEST(FilePathTest, IsDirectory) {
   EXPECT_FALSE(FilePath("cola").IsDirectory());
-  EXPECT_TRUE(FilePath("koala" PATH_SEP).IsDirectory());
+  EXPECT_TRUE(FilePath("koala" GTEST_PATH_SEP_).IsDirectory());
 }
 
 TEST(FilePathTest, IsAbsolutePath) {
-  EXPECT_FALSE(FilePath("is" PATH_SEP "relative").IsAbsolutePath());
+  EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());
   EXPECT_FALSE(FilePath("").IsAbsolutePath());
-#ifdef GTEST_OS_WINDOWS
-    EXPECT_TRUE(FilePath("c:\\" PATH_SEP "is_not" PATH_SEP "relative")
-                .IsAbsolutePath());
-    EXPECT_FALSE(FilePath("c:foo" PATH_SEP "bar").IsAbsolutePath());
+#if GTEST_OS_WINDOWS
+  EXPECT_TRUE(FilePath("c:\\" GTEST_PATH_SEP_ "is_not"
+                       GTEST_PATH_SEP_ "relative").IsAbsolutePath());
+  EXPECT_FALSE(FilePath("c:foo" GTEST_PATH_SEP_ "bar").IsAbsolutePath());
 #else
-  EXPECT_TRUE(FilePath(PATH_SEP "is_not" PATH_SEP "relative")
+  EXPECT_TRUE(FilePath(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
               .IsAbsolutePath());
 #endif  // GTEST_OS_WINDOWS
 }
@@ -605,4 +611,4 @@ TEST(FilePathTest, IsAbsolutePath) {
 }  // namespace internal
 }  // namespace testing
 
-#undef PATH_SEP
+#undef GTEST_PATH_SEP_
diff --git a/test/gtest-options_test.cc b/test/gtest-options_test.cc
index e3e7bd79..5f24e7e3 100644
--- a/test/gtest-options_test.cc
+++ b/test/gtest-options_test.cc
@@ -42,7 +42,7 @@
 
 #ifdef _WIN32_WCE
 #include <windows.h>
-#elif defined(GTEST_OS_WINDOWS)
+#elif GTEST_OS_WINDOWS
 #include <direct.h>
 #endif  // _WIN32_WCE
 
@@ -51,9 +51,9 @@
 // included, or there will be a compiler error.  This trick is to
 // prevent a user from accidentally including gtest-internal-inl.h in
 // his code.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 namespace testing {
 namespace internal {
@@ -89,7 +89,7 @@ TEST(XmlOutputTest, GetOutputFileSingleFile) {
 }
 
 TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
   GTEST_FLAG(output) = "xml:path\\";
   const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
   EXPECT_TRUE(
@@ -121,7 +121,7 @@ TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
 TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
   const FilePath executable = GetCurrentExecutableName();
   const char* const exe_str = executable.c_str();
-#if defined(_WIN32_WCE) || defined(GTEST_OS_WINDOWS)
+#if defined(_WIN32_WCE) || GTEST_OS_WINDOWS
   ASSERT_TRUE(_strcmpi("gtest-options_test", exe_str) == 0 ||
               _strcmpi("gtest-options-ex_test", exe_str) == 0)
               << "GetCurrentExecutableName() returns " << exe_str;
@@ -149,7 +149,7 @@ class XmlOutputChangeDirTest : public Test {
   }
 
   void ChDir(const char* dir) {
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
     _chdir(dir);
 #else
     chdir(dir);
@@ -181,7 +181,7 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) {
 }
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
   GTEST_FLAG(output) = "xml:path\\";
   const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
   EXPECT_TRUE(
@@ -211,7 +211,7 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
 }
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
   GTEST_FLAG(output) = "xml:c:\\tmp\\filename.abc";
   EXPECT_STREQ(FilePath("c:\\tmp\\filename.abc").c_str(),
                UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
@@ -223,7 +223,7 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
 }
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) {
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
   GTEST_FLAG(output) = "xml:c:\\tmp\\";
   const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
   EXPECT_TRUE(
diff --git a/test/gtest-param-test2_test.cc b/test/gtest-param-test2_test.cc
index 4e54206d..ccb6cfac 100644
--- a/test/gtest-param-test2_test.cc
+++ b/test/gtest-param-test2_test.cc
@@ -36,7 +36,7 @@
 
 #include "test/gtest-param-test_test.h"
 
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
 
 using ::testing::Values;
 using ::testing::internal::ParamGenerator;
diff --git a/test/gtest-param-test_test.cc b/test/gtest-param-test_test.cc
index 22ba1a34..63080216 100644
--- a/test/gtest-param-test_test.cc
+++ b/test/gtest-param-test_test.cc
@@ -35,7 +35,7 @@
 
 #include <gtest/gtest.h>
 
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
 
 #include <algorithm>
 #include <iostream>
@@ -43,9 +43,9 @@
 #include <vector>
 
 // To include gtest-internal-inl.h.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"  // for UnitTestOptions
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 #include "test/gtest-param-test_test.h"
 
@@ -60,7 +60,7 @@ using ::testing::TestWithParam;
 using ::testing::Values;
 using ::testing::ValuesIn;
 
-#ifdef GTEST_HAS_COMBINE
+#if GTEST_HAS_COMBINE
 using ::testing::Combine;
 using ::std::tr1::get;
 using ::std::tr1::make_tuple;
@@ -398,7 +398,7 @@ TEST(BoolTest, BoolWorks) {
   VerifyGenerator(gen, expected_values);
 }
 
-#ifdef GTEST_HAS_COMBINE
+#if GTEST_HAS_COMBINE
 
 template <typename T1, typename T2>
 ::std::ostream& operator<<(::std::ostream& stream, const tuple<T1, T2>& value) {
@@ -774,13 +774,13 @@ INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));
 #endif  // GTEST_HAS_PARAM_TEST
 
 TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
-#if defined(GTEST_HAS_COMBINE) && !defined(GTEST_HAS_PARAM_TEST)
+#if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST
   FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n"
 #endif
 }
 
 int main(int argc, char **argv) {
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
   // Used in TestGenerationTest test case.
   AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
   // Used in GeneratorEvaluationTest test case.
diff --git a/test/gtest-param-test_test.h b/test/gtest-param-test_test.h
index ee7bea00..b7f94936 100644
--- a/test/gtest-param-test_test.h
+++ b/test/gtest-param-test_test.h
@@ -39,7 +39,7 @@
 
 #include <gtest/gtest.h>
 
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
 
 // Test fixture for testing definition and instantiation of a test
 // in separate translation units.
diff --git a/test/gtest-port_test.cc b/test/gtest-port_test.cc
index 0041c911..40d36bd1 100644
--- a/test/gtest-port_test.cc
+++ b/test/gtest-port_test.cc
@@ -40,9 +40,9 @@
 // included, or there will be a compiler error.  This trick is to
 // prevent a user from accidentally including gtest-internal-inl.h in
 // his code.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 namespace testing {
 namespace internal {
@@ -76,7 +76,7 @@ TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
       GTEST_CHECK_(true) << "Check failed in switch case";
 }
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
 
 TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
   const bool a_false_condition = false;
diff --git a/test/gtest-test-part_test.cc b/test/gtest-test-part_test.cc
index f4f0d1d5..f9e2e5d3 100644
--- a/test/gtest-test-part_test.cc
+++ b/test/gtest-test-part_test.cc
@@ -117,7 +117,7 @@ TEST_F(TestPartResultArrayTest, ContainsGivenResultsAfterTwoAppends) {
   EXPECT_STREQ("Failure 2", results.GetTestPartResult(1).message());
 }
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
 
 typedef TestPartResultArrayTest TestPartResultArrayDeathTest;
 
diff --git a/test/gtest-typed-test2_test.cc b/test/gtest-typed-test2_test.cc
index 7dabe760..79a8a87d 100644
--- a/test/gtest-typed-test2_test.cc
+++ b/test/gtest-typed-test2_test.cc
@@ -34,7 +34,7 @@
 #include "test/gtest-typed-test_test.h"
 #include <gtest/gtest.h>
 
-#ifdef GTEST_HAS_TYPED_TEST_P
+#if GTEST_HAS_TYPED_TEST_P
 
 // Tests that the same type-parameterized test case can be
 // instantiated in different translation units linked together.
diff --git a/test/gtest-typed-test_test.cc b/test/gtest-typed-test_test.cc
index ec03c95d..9ba9675f 100644
--- a/test/gtest-typed-test_test.cc
+++ b/test/gtest-typed-test_test.cc
@@ -82,7 +82,7 @@ template <typename T>
 T* CommonTest<T>::shared_ = NULL;
 
 // This #ifdef block tests typed tests.
-#ifdef GTEST_HAS_TYPED_TEST
+#if GTEST_HAS_TYPED_TEST
 
 using testing::Types;
 
@@ -166,7 +166,7 @@ TYPED_TEST(NumericTest, DefaultIsZero) {
 #endif  // GTEST_HAS_TYPED_TEST
 
 // This #ifdef block tests type-parameterized tests.
-#ifdef GTEST_HAS_TYPED_TEST_P
+#if GTEST_HAS_TYPED_TEST_P
 
 using testing::Types;
 using testing::internal::TypedTestCasePState;
@@ -198,7 +198,7 @@ TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) {
             state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
 }
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
 
 typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest;
 
diff --git a/test/gtest-typed-test_test.h b/test/gtest-typed-test_test.h
index 2e89dc4b..ecbe5b31 100644
--- a/test/gtest-typed-test_test.h
+++ b/test/gtest-typed-test_test.h
@@ -34,7 +34,7 @@
 
 #include <gtest/gtest.h>
 
-#ifdef GTEST_HAS_TYPED_TEST_P
+#if GTEST_HAS_TYPED_TEST_P
 
 using testing::Test;
 
diff --git a/test/gtest_break_on_failure_unittest_.cc b/test/gtest_break_on_failure_unittest_.cc
index 84c4a2ee..26b5bd3c 100644
--- a/test/gtest_break_on_failure_unittest_.cc
+++ b/test/gtest_break_on_failure_unittest_.cc
@@ -41,7 +41,7 @@
 
 #include <gtest/gtest.h>
 
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 #include <windows.h>
 #endif
 
@@ -56,7 +56,7 @@ TEST(Foo, Bar) {
 
 
 int main(int argc, char **argv) {
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
   // Suppresses display of the Windows error dialog upon encountering
   // a general protection fault (segment violation).
   SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
diff --git a/test/gtest_env_var_test_.cc b/test/gtest_env_var_test_.cc
index bbccd462..dd820e44 100644
--- a/test/gtest_env_var_test_.cc
+++ b/test/gtest_env_var_test_.cc
@@ -36,9 +36,9 @@
 
 #include <iostream>
 
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 using ::std::cout;
 
diff --git a/test/gtest_filter_unittest_.cc b/test/gtest_filter_unittest_.cc
index 22638e0d..dd4f7167 100644
--- a/test/gtest_filter_unittest_.cc
+++ b/test/gtest_filter_unittest_.cc
@@ -94,7 +94,7 @@ TEST(BazTest, DISABLED_TestC) {
 // Test case HasDeathTest
 
 TEST(HasDeathTest, Test1) {
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
   EXPECT_DEATH({exit(1);},
     ".*");
 #endif  // GTEST_HAS_DEATH_TEST
@@ -103,7 +103,7 @@ TEST(HasDeathTest, Test1) {
 // We need at least two death tests to make sure that the all death tests
 // aren't on the first shard.
 TEST(HasDeathTest, Test2) {
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
   EXPECT_DEATH({exit(1);},
     ".*");
 #endif  // GTEST_HAS_DEATH_TEST
@@ -126,7 +126,7 @@ TEST(DISABLED_FoobarbazTest, TestA) {
   FAIL() << "Expected failure.";
 }
 
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
 class ParamTest : public testing::TestWithParam<int> {
 };
 
diff --git a/test/gtest_output_test_.cc b/test/gtest_output_test_.cc
index f5748d17..a8ffa412 100644
--- a/test/gtest_output_test_.cc
+++ b/test/gtest_output_test_.cc
@@ -40,9 +40,9 @@
 // included, or there will be a compiler error.  This trick is to
 // prevent a user from accidentally including gtest-internal-inl.h in
 // his code.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 #include <stdlib.h>
 
@@ -50,7 +50,7 @@
 #include <pthread.h>
 #endif  // GTEST_HAS_PTHREAD
 
-#ifdef GTEST_OS_LINUX
+#if GTEST_OS_LINUX
 #include <string.h>
 #include <signal.h>
 #include <string>
@@ -355,7 +355,7 @@ TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {
          << "We should never get here, as SetUp() failed.";
 }
 
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 
 // This group of tests verifies that Google Test handles SEH and C++
 // exceptions correctly.
@@ -722,7 +722,7 @@ TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {
 #endif  // GTEST_HAS_EXCEPTIONS
 
 // This #ifdef block tests the output of typed tests.
-#ifdef GTEST_HAS_TYPED_TEST
+#if GTEST_HAS_TYPED_TEST
 
 template <typename T>
 class TypedTest : public testing::Test {
@@ -741,7 +741,7 @@ TYPED_TEST(TypedTest, Failure) {
 #endif  // GTEST_HAS_TYPED_TEST
 
 // This #ifdef block tests the output of type-parameterized tests.
-#ifdef GTEST_HAS_TYPED_TEST_P
+#if GTEST_HAS_TYPED_TEST_P
 
 template <typename T>
 class TypedTestP : public testing::Test {
@@ -764,7 +764,7 @@ INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes);
 
 #endif  // GTEST_HAS_TYPED_TEST_P
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
 
 // We rely on the golden file to verify that tests whose test case
 // name ends with DeathTest are run first.
@@ -772,7 +772,7 @@ INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes);
 TEST(ADeathTest, ShouldRunFirst) {
 }
 
-#ifdef GTEST_HAS_TYPED_TEST
+#if GTEST_HAS_TYPED_TEST
 
 // We rely on the golden file to verify that typed tests whose test
 // case name ends with DeathTest are run first.
@@ -789,7 +789,7 @@ TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {
 
 #endif  // GTEST_HAS_TYPED_TEST
 
-#ifdef GTEST_HAS_TYPED_TEST_P
+#if GTEST_HAS_TYPED_TEST_P
 
 
 // We rely on the golden file to verify that type-parameterized tests
@@ -984,7 +984,7 @@ int main(int argc, char **argv) {
       String(argv[1]) == "--gtest_internal_skip_environment_and_ad_hoc_tests")
     GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests) = true;
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
   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.
diff --git a/test/gtest_repeat_test.cc b/test/gtest_repeat_test.cc
index 65298bfa..39a0601d 100644
--- a/test/gtest_repeat_test.cc
+++ b/test/gtest_repeat_test.cc
@@ -40,9 +40,9 @@
 // included, or there will be a compiler error.  This trick is to
 // prevent a user from accidentally including gtest-internal-inl.h in
 // his code.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 namespace testing {
 
@@ -112,7 +112,7 @@ int g_death_test_count = 0;
 TEST(BarDeathTest, ThreadSafeAndFast) {
   g_death_test_count++;
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
   GTEST_FLAG(death_test_style) = "threadsafe";
   EXPECT_DEATH(abort(), "");
 
@@ -121,7 +121,7 @@ TEST(BarDeathTest, ThreadSafeAndFast) {
 #endif  // GTEST_HAS_DEATH_TEST
 }
 
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
 int g_param_test_count = 0;
 
 const int kNumberOfParamTests = 10;
@@ -146,7 +146,7 @@ void ResetCounts() {
   g_should_fail_count = 0;
   g_should_pass_count = 0;
   g_death_test_count = 0;
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
   g_param_test_count = 0;
 #endif  // GTEST_HAS_PARAM_TEST
 }
@@ -158,7 +158,7 @@ void CheckCounts(int expected) {
   GTEST_CHECK_INT_EQ_(expected, g_should_fail_count);
   GTEST_CHECK_INT_EQ_(expected, g_should_pass_count);
   GTEST_CHECK_INT_EQ_(expected, g_death_test_count);
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
   GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count);
 #endif  // GTEST_HAS_PARAM_TEST
 }
@@ -203,7 +203,7 @@ void TestRepeatWithFilterForSuccessfulTests(int repeat) {
   GTEST_CHECK_INT_EQ_(0, g_should_fail_count);
   GTEST_CHECK_INT_EQ_(repeat, g_should_pass_count);
   GTEST_CHECK_INT_EQ_(repeat, g_death_test_count);
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
   GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count);
 #endif  // GTEST_HAS_PARAM_TEST
 }
@@ -221,7 +221,7 @@ void TestRepeatWithFilterForFailedTests(int repeat) {
   GTEST_CHECK_INT_EQ_(repeat, g_should_fail_count);
   GTEST_CHECK_INT_EQ_(0, g_should_pass_count);
   GTEST_CHECK_INT_EQ_(0, g_death_test_count);
-#ifdef GTEST_HAS_PARAM_TEST
+#if GTEST_HAS_PARAM_TEST
   GTEST_CHECK_INT_EQ_(0, g_param_test_count);
 #endif  // GTEST_HAS_PARAM_TEST
 }
diff --git a/test/gtest_stress_test.cc b/test/gtest_stress_test.cc
index c58f56ca..55e8bf42 100644
--- a/test/gtest_stress_test.cc
+++ b/test/gtest_stress_test.cc
@@ -38,9 +38,9 @@
 // We must define this macro in order to #include
 // gtest-internal-inl.h.  This is how Google Test prevents a user from
 // accidentally depending on its internal implementation.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 namespace testing {
 namespace {
diff --git a/test/gtest_unittest.cc b/test/gtest_unittest.cc
index f8dbff0f..8dabcc9a 100644
--- a/test/gtest_unittest.cc
+++ b/test/gtest_unittest.cc
@@ -59,9 +59,9 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
 // included, or there will be a compiler error.  This trick is to
 // prevent a user from accidentally including gtest-internal-inl.h in
 // his code.
-#define GTEST_IMPLEMENTATION
+#define GTEST_IMPLEMENTATION_ 1
 #include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION
+#undef GTEST_IMPLEMENTATION_
 
 #include <stdlib.h>
 
@@ -69,7 +69,7 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
 #include <pthread.h>
 #endif  // GTEST_HAS_PTHREAD
 
-#ifdef GTEST_OS_LINUX
+#if GTEST_OS_LINUX
 #include <string.h>
 #include <signal.h>
 #include <sys/stat.h>
@@ -201,7 +201,7 @@ TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
   EXPECT_STREQ("-3", FormatTimeInMillisAsSeconds(-3000));
 }
 
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
 // NULL testing does not work with Symbian compilers.
 
 // Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null
@@ -225,7 +225,7 @@ TEST(NullLiteralTest, IsFalseForNonNullLiterals) {
   EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL)));
 }
 
-#endif  // GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 //
 // Tests CodePointToUtf8().
 
@@ -266,7 +266,7 @@ TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
   EXPECT_STREQ("\xEC\x9D\x8D", CodePointToUtf8(L'\xC74D', buffer));
 }
 
-#ifndef GTEST_WIDE_STRING_USES_UTF16_
+#if !GTEST_WIDE_STRING_USES_UTF16_
 // Tests in this group require a wchar_t to hold > 16 bits, and thus
 // are skipped on Windows, Cygwin, and Symbian, where a wchar_t is
 // 16-bit wide. This code may not compile on those systems.
@@ -292,7 +292,7 @@ TEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) {
                CodePointToUtf8(L'\x1234ABCD', buffer));
 }
 
-#endif  // GTEST_WIDE_STRING_USES_UTF16_
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
 
 // Tests WideStringToUtf8().
 
@@ -346,7 +346,7 @@ TEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) {
 }
 
 
-#ifndef GTEST_WIDE_STRING_USES_UTF16_
+#if !GTEST_WIDE_STRING_USES_UTF16_
 // Tests that Unicode code-points that have 17 to 21 bits are encoded
 // as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile
 // on the systems using UTF-16 encoding.
@@ -365,7 +365,7 @@ TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
   EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",
                WideStringToUtf8(L"\xABCDFF", -1).c_str());
 }
-#else
+#else  // !GTEST_WIDE_STRING_USES_UTF16_
 // Tests that surrogate pairs are encoded correctly on the systems using
 // UTF-16 encoding in the wide strings.
 TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
@@ -383,10 +383,10 @@ TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
   // Trailing surrogate appearas without a leading surrogate.
   EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(L"\xDC00PQR", -1).c_str());
 }
-#endif  // GTEST_WIDE_STRING_USES_UTF16_
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
 
 // Tests that codepoint concatenation works correctly.
-#ifndef GTEST_WIDE_STRING_USES_UTF16_
+#if !GTEST_WIDE_STRING_USES_UTF16_
 TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
   EXPECT_STREQ(
       "\xF4\x88\x98\xB4"
@@ -403,7 +403,7 @@ TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
       "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
       WideStringToUtf8(L"\xC74D\n\x576\x8D3", -1).c_str());
 }
-#endif  // GTEST_WIDE_STRING_USES_UTF16_
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
 
 // Tests the List template class.
 
@@ -725,7 +725,7 @@ TEST(StringTest, CanBeAssignedSelf) {
   EXPECT_STREQ("hello", dest.c_str());
 }
 
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 
 // Tests String::ShowWideCString().
 TEST(StringTest, ShowWideCString) {
@@ -1265,7 +1265,7 @@ static void SetEnv(const char* name, const char* value) {
 #ifdef _WIN32_WCE
   // Environment variables are not supported on Windows CE.
   return;
-#elif defined(GTEST_OS_WINDOWS)  // If we are on Windows proper.
+#elif GTEST_OS_WINDOWS  // If we are on Windows proper.
   _putenv((Message() << name << "=" << value).GetString().c_str());
 #else
   if (*value == '\0') {
@@ -1286,7 +1286,7 @@ using testing::internal::Int32FromGTestEnv;
 // Tests that Int32FromGTestEnv() returns the default value when the
 // environment variable is not set.
 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "");
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "");
   EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));
 }
 
@@ -1295,10 +1295,10 @@ TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {
   printf("(expecting 2 warnings)\n");
 
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "12345678987654321");
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321");
   EXPECT_EQ(20, Int32FromGTestEnv("temp", 20));
 
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "-12345678987654321");
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321");
   EXPECT_EQ(30, Int32FromGTestEnv("temp", 30));
 }
 
@@ -1307,10 +1307,10 @@ TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {
 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
   printf("(expecting 2 warnings)\n");
 
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "A1");
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1");
   EXPECT_EQ(40, Int32FromGTestEnv("temp", 40));
 
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "12X");
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X");
   EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));
 }
 
@@ -1318,10 +1318,10 @@ TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
 // environment variable when it represents a valid decimal integer in
 // the range of an Int32.
 TEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) {
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "123");
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123");
   EXPECT_EQ(123, Int32FromGTestEnv("temp", 0));
 
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "-321");
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321");
   EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0));
 }
 #endif  // !defined(_WIN32_WCE)
@@ -1371,38 +1371,38 @@ TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
 // the range of an Int32.
 TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
   Int32 value = 123;
-  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX "abc=456", "abc", &value));
+  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
   EXPECT_EQ(456, value);
 
-  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX "abc=-789", "abc", &value));
+  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789", "abc", &value));
   EXPECT_EQ(-789, value);
 }
 
 // Tests that Int32FromEnvOrDie() parses the value of the var or
 // returns the correct default.
 TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
-  EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER "UnsetVar", 333));
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "UnsetVar", "123");
-  EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER "UnsetVar", 333));
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "UnsetVar", "-123");
-  EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER "UnsetVar", 333));
+  EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123");
+  EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123");
+  EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
 }
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
 
 // Tests that Int32FromEnvOrDie() aborts with an error message
 // if the variable is not an Int32.
 TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "VAR", "xxx");
-  EXPECT_DEATH({Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER "VAR", 123);},
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx");
+  EXPECT_DEATH({Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123);},
                ".*");
 }
 
 // Tests that Int32FromEnvOrDie() aborts with an error message
 // if the variable cannot be represnted by an Int32.
 TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
-  SetEnv(GTEST_FLAG_PREFIX_UPPER "VAR", "1234567891234567891234");
-  EXPECT_DEATH({Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER "VAR", 123);},
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234");
+  EXPECT_DEATH({Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123);},
                ".*");
 }
 
@@ -1422,8 +1422,8 @@ TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) {
 class ShouldShardTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    index_var_ = GTEST_FLAG_PREFIX_UPPER "INDEX";
-    total_var_ = GTEST_FLAG_PREFIX_UPPER "TOTAL";
+    index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX";
+    total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL";
   }
 
   virtual void TearDown() {
@@ -1472,7 +1472,7 @@ TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {
   EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
 }
 
-#ifdef GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST
 
 // Tests that we exit in error if the sharding values are not valid.
 TEST_F(ShouldShardTest, AbortsWhenShardingEnvVarsAreInvalid) {
@@ -2243,7 +2243,7 @@ TEST_F(FloatTest, LargeDiff) {
 TEST_F(FloatTest, Infinity) {
   EXPECT_FLOAT_EQ(infinity_, close_to_infinity_);
   EXPECT_FLOAT_EQ(-infinity_, -close_to_infinity_);
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
   // Nokia's STLport crashes if we try to output infinity or NaN.
   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(infinity_, -infinity_),
                           "-infinity_");
@@ -2252,12 +2252,12 @@ TEST_F(FloatTest, Infinity) {
   // are only 1 DLP apart.
   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(infinity_, nan1_),
                           "nan1_");
-#endif  // ! GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 }
 
 // Tests that comparing with NAN always returns false.
 TEST_F(FloatTest, NaN) {
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
 // Nokia's STLport crashes if we try to output infinity or NaN.
   EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(nan1_, nan1_),
                           "nan1_");
@@ -2268,7 +2268,7 @@ TEST_F(FloatTest, NaN) {
 
   EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(nan1_, infinity_),
                        "infinity_");
-#endif  // ! GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 }
 
 // Tests that *_FLOAT_EQ are reflexive.
@@ -2330,7 +2330,7 @@ TEST_F(FloatTest, FloatLEFails) {
     EXPECT_PRED_FORMAT2(FloatLE, further_from_one_, 1.0f);
   }, "(further_from_one_) <= (1.0f)");
 
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
   // Nokia's STLport crashes if we try to output infinity or NaN.
   // or when either val1 or val2 is NaN.
   EXPECT_NONFATAL_FAILURE({  // NOLINT
@@ -2343,7 +2343,7 @@ TEST_F(FloatTest, FloatLEFails) {
   EXPECT_FATAL_FAILURE({  // NOLINT
     ASSERT_PRED_FORMAT2(FloatLE, nan1_, nan1_);
   }, "(nan1_) <= (nan1_)");
-#endif  // ! GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 }
 
 // Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
@@ -2398,7 +2398,7 @@ TEST_F(DoubleTest, LargeDiff) {
 TEST_F(DoubleTest, Infinity) {
   EXPECT_DOUBLE_EQ(infinity_, close_to_infinity_);
   EXPECT_DOUBLE_EQ(-infinity_, -close_to_infinity_);
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
   // Nokia's STLport crashes if we try to output infinity or NaN.
   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(infinity_, -infinity_),
                           "-infinity_");
@@ -2407,29 +2407,29 @@ TEST_F(DoubleTest, Infinity) {
   // are only 1 DLP apart.
   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(infinity_, nan1_),
                           "nan1_");
-#endif  // ! GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 }
 
 // Tests that comparing with NAN always returns false.
 TEST_F(DoubleTest, NaN) {
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
   // Nokia's STLport crashes if we try to output infinity or NaN.
   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(nan1_, nan1_),
                           "nan1_");
   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(nan1_, nan2_), "nan2_");
   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, nan1_), "nan1_");
   EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(nan1_, infinity_), "infinity_");
-#endif  // ! GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 }
 
 // Tests that *_DOUBLE_EQ are reflexive.
 TEST_F(DoubleTest, Reflexive) {
   EXPECT_DOUBLE_EQ(0.0, 0.0);
   EXPECT_DOUBLE_EQ(1.0, 1.0);
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
   // Nokia's STLport crashes if we try to output infinity or NaN.
   ASSERT_DOUBLE_EQ(infinity_, infinity_);
-#endif  // ! GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 }
 
 // Tests that *_DOUBLE_EQ are commutative.
@@ -2483,7 +2483,7 @@ TEST_F(DoubleTest, DoubleLEFails) {
     EXPECT_PRED_FORMAT2(DoubleLE, further_from_one_, 1.0);
   }, "(further_from_one_) <= (1.0)");
 
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
   // Nokia's STLport crashes if we try to output infinity or NaN.
   // or when either val1 or val2 is NaN.
   EXPECT_NONFATAL_FAILURE({  // NOLINT
@@ -2495,7 +2495,7 @@ TEST_F(DoubleTest, DoubleLEFails) {
   EXPECT_FATAL_FAILURE({  // NOLINT
     ASSERT_PRED_FORMAT2(DoubleLE, nan1_, nan1_);
   }, "(nan1_) <= (nan1_)");
-#endif  // ! GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 }
 
 
@@ -2551,7 +2551,7 @@ TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
 
 // Tests that disabled typed tests aren't run.
 
-#ifdef GTEST_HAS_TYPED_TEST
+#if GTEST_HAS_TYPED_TEST
 
 template <typename T>
 class TypedTest : public Test {
@@ -2578,7 +2578,7 @@ TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
 
 // Tests that disabled type-parameterized tests aren't run.
 
-#ifdef GTEST_HAS_TYPED_TEST_P
+#if GTEST_HAS_TYPED_TEST_P
 
 template <typename T>
 class TypedTestP : public Test {
@@ -2956,7 +2956,7 @@ TEST(AssertionTest, ASSERT_EQ) {
 }
 
 // Tests ASSERT_EQ(NULL, pointer).
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
 // The NULL-detection template magic fails to compile with
 // the Nokia compiler and crashes the ARM compiler, hence
 // not testing on Symbian.
@@ -2970,7 +2970,7 @@ TEST(AssertionTest, ASSERT_EQ_NULL) {
   EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
                        "Value of: &n\n");
 }
-#endif  // GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 
 // Tests ASSERT_EQ(0, non_pointer).  Since the literal 0 can be
 // treated as a null pointer by the compiler, we need to make sure
@@ -3145,12 +3145,12 @@ TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
 // The version of gcc used in XCode 2.2 has a bug and doesn't allow
 // anonymous enums in assertions.  Therefore the following test is
 // done only on Linux and Windows.
-#if defined(GTEST_OS_LINUX) || defined(GTEST_OS_WINDOWS)
+#if GTEST_OS_LINUX || GTEST_OS_WINDOWS
 
 // Tests using assertions with anonymous enums.
 enum {
   CASE_A = -1,
-#ifdef GTEST_OS_LINUX
+#if GTEST_OS_LINUX
   // We want to test the case where the size of the anonymous enum is
   // larger than sizeof(int), to make sure our implementation of the
   // assertions doesn't truncate the enums.  However, MSVC
@@ -3167,7 +3167,7 @@ enum {
 };
 
 TEST(AssertionTest, AnonymousEnum) {
-#ifdef GTEST_OS_LINUX
+#if GTEST_OS_LINUX
   EXPECT_EQ(static_cast<int>(CASE_A), static_cast<int>(CASE_B));
 #endif  // GTEST_OS_LINUX
 
@@ -3190,9 +3190,9 @@ TEST(AssertionTest, AnonymousEnum) {
                        "Value of: CASE_B");
 }
 
-#endif  // defined(GTEST_OS_LINUX) || defined(GTEST_OS_WINDOWS)
+#endif  // GTEST_OS_LINUX || GTEST_OS_WINDOWS
 
-#if defined(GTEST_OS_WINDOWS)
+#if GTEST_OS_WINDOWS
 
 static HRESULT UnexpectedHRESULTFailure() {
   return E_UNEXPECTED;
@@ -3274,7 +3274,7 @@ TEST(HRESULTAssertionTest, Streaming) {
       "expected failure");
 }
 
-#endif  // defined(GTEST_OS_WINDOWS)
+#endif  // GTEST_OS_WINDOWS
 
 // Tests that the assertion macros behave like single statements.
 TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
@@ -3493,7 +3493,7 @@ TEST(ExpectTest, EXPECT_EQ_Double) {
                           "5.1");
 }
 
-#ifndef GTEST_OS_SYMBIAN
+#if !GTEST_OS_SYMBIAN
 // Tests EXPECT_EQ(NULL, pointer).
 TEST(ExpectTest, EXPECT_EQ_NULL) {
   // A success.
@@ -3505,7 +3505,7 @@ TEST(ExpectTest, EXPECT_EQ_NULL) {
   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
                           "Value of: &n\n");
 }
-#endif  // GTEST_OS_SYMBIAN
+#endif  // !GTEST_OS_SYMBIAN
 
 // Tests EXPECT_EQ(0, non_pointer).  Since the literal 0 can be
 // treated as a null pointer by the compiler, we need to make sure
@@ -4469,7 +4469,7 @@ class InitGoogleTestTest : public Test {
 
   // This macro wraps TestParsingFlags s.t. the user doesn't need
   // to specify the array sizes.
-#define TEST_PARSING_FLAGS(argv1, argv2, expected) \
+#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected) \
   TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
                    sizeof(argv2)/sizeof(*argv2) - 1, argv2, expected)
 };
@@ -4484,7 +4484,7 @@ TEST_F(InitGoogleTestTest, Empty) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags());
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());
 }
 
 // Tests parsing a command line that has no flag.
@@ -4499,7 +4499,7 @@ TEST_F(InitGoogleTestTest, NoFlag) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags());
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());
 }
 
 // Tests parsing a bad --gtest_filter flag.
@@ -4516,7 +4516,7 @@ TEST_F(InitGoogleTestTest, FilterBad) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::Filter(""));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""));
 }
 
 // Tests parsing an empty --gtest_filter flag.
@@ -4532,7 +4532,7 @@ TEST_F(InitGoogleTestTest, FilterEmpty) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::Filter(""));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""));
 }
 
 // Tests parsing a non-empty --gtest_filter flag.
@@ -4548,7 +4548,7 @@ TEST_F(InitGoogleTestTest, FilterNonEmpty) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::Filter("abc"));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"));
 }
 
 // Tests parsing --gtest_break_on_failure.
@@ -4564,7 +4564,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureNoDef) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(true));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true));
 }
 
 // Tests parsing --gtest_break_on_failure=0.
@@ -4580,7 +4580,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(false));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));
 }
 
 // Tests parsing --gtest_break_on_failure=f.
@@ -4596,7 +4596,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(false));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));
 }
 
 // Tests parsing --gtest_break_on_failure=F.
@@ -4612,7 +4612,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(false));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));
 }
 
 // Tests parsing a --gtest_break_on_failure flag that has a "true"
@@ -4629,7 +4629,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureTrue) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(true));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true));
 }
 
 // Tests parsing --gtest_catch_exceptions.
@@ -4645,7 +4645,7 @@ TEST_F(InitGoogleTestTest, CatchExceptions) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::CatchExceptions(true));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true));
 }
 
 // Tests parsing --gtest_death_test_use_fork.
@@ -4661,7 +4661,7 @@ TEST_F(InitGoogleTestTest, DeathTestUseFork) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::DeathTestUseFork(true));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true));
 }
 
 // Tests having the same flag twice with different values.  The
@@ -4679,7 +4679,7 @@ TEST_F(InitGoogleTestTest, DuplicatedFlags) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::Filter("b"));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"));
 }
 
 // Tests having an unrecognized flag on the command line.
@@ -4701,7 +4701,7 @@ TEST_F(InitGoogleTestTest, UnrecognizedFlag) {
   Flags flags;
   flags.break_on_failure = true;
   flags.filter = "b";
-  TEST_PARSING_FLAGS(argv, argv2, flags);
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags);
 }
 
 // Tests having a --gtest_list_tests flag
@@ -4717,7 +4717,7 @@ TEST_F(InitGoogleTestTest, ListTestsFlag) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(true));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true));
 }
 
 // Tests having a --gtest_list_tests flag with a "true" value
@@ -4733,7 +4733,7 @@ TEST_F(InitGoogleTestTest, ListTestsTrue) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(true));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true));
 }
 
 // Tests having a --gtest_list_tests flag with a "false" value
@@ -4749,7 +4749,7 @@ TEST_F(InitGoogleTestTest, ListTestsFalse) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(false));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));
 }
 
 // Tests parsing --gtest_list_tests=f.
@@ -4765,7 +4765,7 @@ TEST_F(InitGoogleTestTest, ListTestsFalse_f) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(false));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));
 }
 
 // Tests parsing --gtest_break_on_failure=F.
@@ -4781,7 +4781,7 @@ TEST_F(InitGoogleTestTest, ListTestsFalse_F) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(false));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));
 }
 
 // Tests parsing --gtest_output (invalid).
@@ -4798,7 +4798,7 @@ TEST_F(InitGoogleTestTest, OutputEmpty) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags());
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());
 }
 
 // Tests parsing --gtest_output=xml
@@ -4814,7 +4814,7 @@ TEST_F(InitGoogleTestTest, OutputXml) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::Output("xml"));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"));
 }
 
 // Tests parsing --gtest_output=xml:file
@@ -4830,7 +4830,7 @@ TEST_F(InitGoogleTestTest, OutputXmlFile) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::Output("xml:file"));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"));
 }
 
 // Tests parsing --gtest_output=xml:directory/path/
@@ -4846,7 +4846,7 @@ TEST_F(InitGoogleTestTest, OutputXmlDirectory) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::Output("xml:directory/path/"));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:directory/path/"));
 }
 
 // Tests having a --gtest_print_time flag
@@ -4862,7 +4862,7 @@ TEST_F(InitGoogleTestTest, PrintTimeFlag) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(true));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true));
 }
 
 // Tests having a --gtest_print_time flag with a "true" value
@@ -4878,7 +4878,7 @@ TEST_F(InitGoogleTestTest, PrintTimeTrue) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(true));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true));
 }
 
 // Tests having a --gtest_print_time flag with a "false" value
@@ -4894,7 +4894,7 @@ TEST_F(InitGoogleTestTest, PrintTimeFalse) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(false));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));
 }
 
 // Tests parsing --gtest_print_time=f.
@@ -4910,7 +4910,7 @@ TEST_F(InitGoogleTestTest, PrintTimeFalse_f) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(false));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));
 }
 
 // Tests parsing --gtest_print_time=F.
@@ -4926,7 +4926,7 @@ TEST_F(InitGoogleTestTest, PrintTimeFalse_F) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(false));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));
 }
 
 // Tests parsing --gtest_repeat=number
@@ -4942,7 +4942,7 @@ TEST_F(InitGoogleTestTest, Repeat) {
     NULL
   };
 
-  TEST_PARSING_FLAGS(argv, argv2, Flags::Repeat(1000));
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000));
 }
 
 // Tests having a --gtest_also_run_disabled_tests flag
@@ -4958,7 +4958,7 @@ TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::AlsoRunDisabledTests(true));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true));
 }
 
 // Tests having a --gtest_also_run_disabled_tests flag with a "true" value
@@ -4974,7 +4974,7 @@ TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::AlsoRunDisabledTests(true));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true));
 }
 
 // Tests having a --gtest_also_run_disabled_tests flag with a "false" value
@@ -4990,10 +4990,10 @@ TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) {
       NULL
     };
 
-    TEST_PARSING_FLAGS(argv, argv2, Flags::AlsoRunDisabledTests(false));
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(false));
 }
 
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 // Tests parsing wide strings.
 TEST_F(InitGoogleTestTest, WideStrings) {
   const wchar_t* argv[] = {
@@ -5016,7 +5016,7 @@ TEST_F(InitGoogleTestTest, WideStrings) {
   expected_flags.filter = "Foo*";
   expected_flags.list_tests = true;
 
-  TEST_PARSING_FLAGS(argv, argv2, expected_flags);
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags);
 }
 #endif  // GTEST_OS_WINDOWS
 
@@ -5304,7 +5304,7 @@ TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
 TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
   GTEST_FLAG(color) = "auto";
 
-#ifdef GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
   // On Windows, we ignore the TERM variable as it's usually not set.
 
   SetEnv("TERM", "dumb");