Adds missing gtest DLL exports.

6 files changed, 51 insertions, 620 deletions

diff --git a/test/gtest-filepath_test.cc b/test/gtest-filepath_test.cc
index c5f58f4..6250282 100644
--- a/test/gtest-filepath_test.cc
+++ b/test/gtest-filepath_test.cc
@@ -688,5 +688,3 @@ TEST(FilePathTest, IsRootDirectory) {
 }  // namespace
 }  // namespace internal
 }  // namespace testing
-
-#undef GTEST_PATH_SEP_
diff --git a/test/gtest-options_test.cc b/test/gtest-options_test.cc
index 31ae327..2e2cbc9 100644
--- a/test/gtest-options_test.cc
+++ b/test/gtest-options_test.cc
@@ -89,61 +89,38 @@ TEST(XmlOutputTest, GetOutputFileSingleFile) {
 }
 
 TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
-#if GTEST_OS_WINDOWS
-  GTEST_FLAG(output) = "xml:path\\";
+  GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
+  const std::string expected_output_file =
+      GetAbsolutePathOf(
+          FilePath(std::string("path") + GTEST_PATH_SEP_ +
+                   GetCurrentExecutableName().c_str() + ".xml")).c_str();
   const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
-  EXPECT_TRUE(
-      _strcmpi(output_file.c_str(),
-               GetAbsolutePathOf(
-                   FilePath("path\\gtest-options_test.xml")).c_str()) == 0 ||
-      _strcmpi(output_file.c_str(),
-               GetAbsolutePathOf(
-                   FilePath("path\\gtest-options-ex_test.xml")).c_str()) == 0 ||
-      _strcmpi(output_file.c_str(),
-               GetAbsolutePathOf(
-                   FilePath("path\\gtest_all_test.xml")).c_str()) == 0)
-                       << " output_file = " << output_file;
+#if GTEST_OS_WINDOWS
+  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
 #else
-  GTEST_FLAG(output) = "xml:path/";
-  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
-  // TODO(wan@google.com): libtool causes the test binary file to be
-  //   named lt-gtest-options_test.  Therefore the output file may be
-  //   named .../lt-gtest-options_test.xml.  We should remove this
-  //   hard-coded logic when Chandler Carruth's libtool replacement is
-  //   ready.
-  EXPECT_TRUE(output_file ==
-              GetAbsolutePathOf(
-                  FilePath("path/gtest-options_test.xml")).c_str() ||
-              output_file ==
-              GetAbsolutePathOf(
-                  FilePath("path/lt-gtest-options_test.xml")).c_str() ||
-              output_file ==
-              GetAbsolutePathOf(
-                  FilePath("path/gtest_all_test.xml")).c_str() ||
-              output_file ==
-              GetAbsolutePathOf(
-                  FilePath("path/lt-gtest_all_test.xml")).c_str())
-                      << " output_file = " << output_file;
+  EXPECT_EQ(expected_output_file, output_file.c_str());
 #endif
 }
 
 TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
-  const FilePath executable = GetCurrentExecutableName();
-  const char* const exe_str = executable.c_str();
+  const std::string exe_str = GetCurrentExecutableName().c_str();
 #if GTEST_OS_WINDOWS
-  ASSERT_TRUE(_strcmpi("gtest-options_test", exe_str) == 0 ||
-              _strcmpi("gtest-options-ex_test", exe_str) == 0 ||
-              _strcmpi("gtest_all_test", exe_str) == 0)
-              << "GetCurrentExecutableName() returns " << exe_str;
+  const bool success =
+      _strcmpi("gtest-options_test", exe_str.c_str()) == 0 ||
+      _strcmpi("gtest-options-ex_test", exe_str.c_str()) == 0 ||
+      _strcmpi("gtest_all_test", exe_str.c_str()) == 0 ||
+      _strcmpi("gtest_dll_test", exe_str.c_str()) == 0;
 #else
   // TODO(wan@google.com): remove the hard-coded "lt-" prefix when
   //   Chandler Carruth's libtool replacement is ready.
-  EXPECT_TRUE(String(exe_str) == "gtest-options_test" ||
-              String(exe_str) == "lt-gtest-options_test" ||
-              String(exe_str) == "gtest_all_test" ||
-              String(exe_str) == "lt-gtest_all_test")
-                  << "GetCurrentExecutableName() returns " << exe_str;
+  const bool success =
+      exe_str == "gtest-options_test" ||
+      exe_str == "gtest_all_test" ||
+      exe_str == "lt-gtest_all_test" ||
+      exe_str == "gtest_dll_test";
 #endif  // GTEST_OS_WINDOWS
+  if (!success)
+    FAIL() << "GetCurrentExecutableName() returns " << exe_str;
 }
 
 class XmlOutputChangeDirTest : public Test {
@@ -185,40 +162,17 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) {
 }
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
-#if GTEST_OS_WINDOWS
-  GTEST_FLAG(output) = "xml:path\\";
+  GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
+  const std::string expected_output_file =
+      FilePath::ConcatPaths(
+          original_working_dir_,
+          FilePath(std::string("path") + GTEST_PATH_SEP_ +
+                   GetCurrentExecutableName().c_str() + ".xml")).c_str();
   const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
-  EXPECT_TRUE(
-      _strcmpi(output_file.c_str(),
-               FilePath::ConcatPaths(
-                   original_working_dir_,
-                   FilePath("path\\gtest-options_test.xml")).c_str()) == 0 ||
-      _strcmpi(output_file.c_str(),
-               FilePath::ConcatPaths(
-                   original_working_dir_,
-                   FilePath("path\\gtest-options-ex_test.xml")).c_str()) == 0 ||
-      _strcmpi(output_file.c_str(),
-               FilePath::ConcatPaths(
-                   original_working_dir_,
-                   FilePath("path\\gtest_all_test.xml")).c_str()) == 0)
-                       << " output_file = " << output_file;
+#if GTEST_OS_WINDOWS
+  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
 #else
-  GTEST_FLAG(output) = "xml:path/";
-  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
-  // TODO(wan@google.com): libtool causes the test binary file to be
-  //   named lt-gtest-options_test.  Therefore the output file may be
-  //   named .../lt-gtest-options_test.xml.  We should remove this
-  //   hard-coded logic when Chandler Carruth's libtool replacement is
-  //   ready.
-  EXPECT_TRUE(output_file == FilePath::ConcatPaths(original_working_dir_,
-                      FilePath("path/gtest-options_test.xml")).c_str() ||
-              output_file == FilePath::ConcatPaths(original_working_dir_,
-                      FilePath("path/lt-gtest-options_test.xml")).c_str() ||
-              output_file == FilePath::ConcatPaths(original_working_dir_,
-                      FilePath("path/gtest_all_test.xml")).c_str() ||
-              output_file == FilePath::ConcatPaths(original_working_dir_,
-                      FilePath("path/lt-gtest_all_test.xml")).c_str())
-                  << " output_file = " << output_file;
+  EXPECT_EQ(expected_output_file, output_file.c_str());
 #endif
 }
 
@@ -236,29 +190,20 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) {
 #if GTEST_OS_WINDOWS
-  GTEST_FLAG(output) = "xml:c:\\tmp\\";
-  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
-  EXPECT_TRUE(
-      _strcmpi(output_file.c_str(),
-               FilePath("c:\\tmp\\gtest-options_test.xml").c_str()) == 0 ||
-      _strcmpi(output_file.c_str(),
-               FilePath("c:\\tmp\\gtest-options-ex_test.xml").c_str()) == 0 ||
-      _strcmpi(output_file.c_str(),
-               FilePath("c:\\tmp\\gtest_all_test.xml").c_str()) == 0)
-                   << " output_file = " << output_file;
+  const std::string path = "c:\\tmp\\";
 #else
-  GTEST_FLAG(output) = "xml:/tmp/";
+  const std::string path = "/tmp/";
+#endif
+
+  GTEST_FLAG(output) = "xml:" + path;
+  const std::string expected_output_file =
+      path + GetCurrentExecutableName().c_str() + ".xml";
   const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
-  // TODO(wan@google.com): libtool causes the test binary file to be
-  //   named lt-gtest-options_test.  Therefore the output file may be
-  //   named .../lt-gtest-options_test.xml.  We should remove this
-  //   hard-coded logic when Chandler Carruth's libtool replacement is
-  //   ready.
-  EXPECT_TRUE(output_file == "/tmp/gtest-options_test.xml" ||
-              output_file == "/tmp/lt-gtest-options_test.xml" ||
-              output_file == "/tmp/gtest_all_test.xml" ||
-              output_file == "/tmp/lt-gtest_all_test.xml")
-                  << " output_file = " << output_file;
+
+#if GTEST_OS_WINDOWS
+  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
+#else
+  EXPECT_EQ(expected_output_file, output_file.c_str());
 #endif
 }
 
diff --git a/test/gtest_all_test.cc b/test/gtest_all_test.cc
index 955aa62..e1edb08 100644
--- a/test/gtest_all_test.cc
+++ b/test/gtest_all_test.cc
@@ -45,3 +45,4 @@
 #include "test/gtest-typed-test2_test.cc"
 #include "test/gtest_unittest.cc"
 #include "test/production.cc"
+#include "src/gtest_main.cc"
diff --git a/test/gtest_color_test_.cc b/test/gtest_color_test_.cc
index 305aeb9..58d377c 100644
--- a/test/gtest_color_test_.cc
+++ b/test/gtest_color_test_.cc
@@ -37,11 +37,14 @@
 
 #include <gtest/gtest.h>
 
-namespace testing {
-namespace internal {
-bool ShouldUseColor(bool stdout_is_tty);
-}  // namespace internal
-}  // namespace testing
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// 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_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
 
 using testing::internal::ShouldUseColor;
 
diff --git a/test/gtest_dll_test_.cc b/test/gtest_dll_test_.cc
deleted file mode 100644
index 3bb3c76..0000000
--- a/test/gtest_dll_test_.cc
+++ /dev/null
@@ -1,509 +0,0 @@
-// Copyright 2009 Google Inc.  All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: vladl@google.com (Vlad Losev)
-//
-// Tests for Google Test itself.  This verifies that Google Test can be
-// linked into an executable successfully when built as a shared library (a
-// DLL on Windows).  The test is not meant to check the success of test
-// assertions employed in it.  It only checks that constructs in them can be
-// successfully linked.
-//
-// If you add new features to Google Test's documented interface, you need to
-// add tests exercising them to this file.
-//
-// If you start having 'unresolved external symbol' linker errors in this file
-// after the changes you have made, you have to modify your source code to
-// export the new symbols.
-
-#include <gtest/gtest.h>
-#include <gtest/gtest-spi.h>
-
-#if GTEST_OS_WINDOWS
-#include <windows.h>
-#endif
-#include <vector>
-
-using ::std::vector;
-using ::std::tr1::tuple;
-
-
-using ::testing::AddGlobalTestEnvironment;
-using ::testing::AssertionFailure;
-using ::testing::AssertionResult;
-using ::testing::AssertionSuccess;
-using ::testing::DoubleLE;
-using ::testing::EmptyTestEventListener;
-using ::testing::Environment;
-using ::testing::ExitedWithCode;
-using ::testing::FloatLE;
-using ::testing::GTEST_FLAG(also_run_disabled_tests);
-using ::testing::GTEST_FLAG(break_on_failure);
-using ::testing::GTEST_FLAG(catch_exceptions);
-using ::testing::GTEST_FLAG(color);
-using ::testing::GTEST_FLAG(filter);
-using ::testing::GTEST_FLAG(output);
-using ::testing::GTEST_FLAG(print_time);
-using ::testing::GTEST_FLAG(random_seed);
-using ::testing::GTEST_FLAG(repeat);
-using ::testing::GTEST_FLAG(shuffle);
-using ::testing::GTEST_FLAG(stack_trace_depth);
-using ::testing::GTEST_FLAG(throw_on_failure);
-using ::testing::InitGoogleTest;
-using ::testing::Message;
-using ::testing::Test;
-using ::testing::TestCase;
-using ::testing::TestEventListener;
-using ::testing::TestEventListeners;
-using ::testing::TestInfo;
-using ::testing::TestPartResult;
-using ::testing::TestProperty;
-using ::testing::TestResult;
-using ::testing::UnitTest;
-using ::testing::internal::AlwaysTrue;
-using ::testing::internal::AlwaysFalse;
-
-#if GTEST_HAS_PARAM_TEST
-using ::testing::Bool;
-using ::testing::Combine;
-using ::testing::TestWithParam;
-using ::testing::Values;
-using ::testing::ValuesIn;
-#endif  // GTEST_HAS_PARAM_TEST
-
-#if GTEST_HAS_TYPED_TEST
-using ::testing::Types;
-#endif   // GTEST_HAS_TYPED_TEST
-
-// Tests linking of TEST constructs.
-TEST(TestMacroTest, LinksSuccessfully) {
-}
-
-// Tests linking of TEST_F constructs.
-class FixtureTest : public Test {
-};
-
-TEST_F(FixtureTest, LinksSuccessfully) {
-}
-
-// Tests linking of value parameterized tests.
-#if GTEST_HAS_PARAM_TEST
-class IntParamTest : public TestWithParam<int> {};
-
-TEST_P(IntParamTest, LinksSuccessfully) {}
-
-const int c_array[] = {1, 2};
-INSTANTIATE_TEST_CASE_P(ValuesInCArrayTest, IntParamTest, ValuesIn(c_array));
-
-INSTANTIATE_TEST_CASE_P(ValuesInIteratorPairTest, IntParamTest,
-                        ValuesIn(c_array, c_array + 2));
-
-vector<int> stl_vector(c_array, c_array + 2);
-INSTANTIATE_TEST_CASE_P(ValuesInStlVectorTest, IntParamTest,
-                        ValuesIn(stl_vector));
-
-class BoolParamTest : public TestWithParam<bool> {};
-
-INSTANTIATE_TEST_CASE_P(BoolTest, BoolParamTest, Bool());
-
-INSTANTIATE_TEST_CASE_P(ValuesTest, IntParamTest, Values(1, 2));
-
-#if GTEST_HAS_COMBINE
-class CombineTest : public TestWithParam<tuple<int, bool> > {};
-
-INSTANTIATE_TEST_CASE_P(CombineTest, CombineTest, Combine(Values(1), Bool()));
-#endif  // GTEST_HAS_COMBINE
-#endif  // GTEST_HAS_PARAM_TEST
-
-// Tests linking of typed tests.
-#if GTEST_HAS_TYPED_TEST
-template <typename T> class TypedTest : public Test {};
-
-TYPED_TEST_CASE(TypedTest, Types<int>);
-
-TYPED_TEST(TypedTest, LinksSuccessfully) {}
-#endif   // GTEST_HAS_TYPED_TEST
-
-// Tests linking of type-parameterized tests.
-#if GTEST_HAS_TYPED_TEST_P
-template <typename T> class TypeParameterizedTest : public Test {};
-
-TYPED_TEST_CASE_P(TypeParameterizedTest);
-
-TYPED_TEST_P(TypeParameterizedTest, LinksSuccessfully) {}
-
-REGISTER_TYPED_TEST_CASE_P(TypeParameterizedTest, LinksSuccessfully);
-
-INSTANTIATE_TYPED_TEST_CASE_P(Char, TypeParameterizedTest, Types<char>);
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-// Tests linking of explicit success or failure.
-TEST(ExplicitSuccessFailureTest, ExplicitSuccessAndFailure) {
-  if (AlwaysTrue())
-    SUCCEED() << "This is a success statement";
-  if (AlwaysFalse()) {
-    ADD_FAILURE() << "This is a non-fatal failure assertion";
-    FAIL() << "This is a fatal failure assertion";
-  }
-}
-
-// Tests linking of Boolean assertions.
-AssertionResult IsEven(int n) {
-  if (n % 2 == 0)
-    return AssertionSuccess() << n << " is even";
-  else
-    return AssertionFailure() << n << " is odd";
-}
-
-TEST(BooleanAssertionTest, LinksSuccessfully) {
-  EXPECT_TRUE(true) << "true is true";
-  EXPECT_FALSE(false) << "false is not true";
-  ASSERT_TRUE(true);
-  ASSERT_FALSE(false);
-  EXPECT_TRUE(IsEven(2));
-  EXPECT_FALSE(IsEven(3));
-}
-
-// Tests linking of predicate assertions.
-bool IsOdd(int n) { return n % 2 != 0; }
-
-bool Ge(int val1, int val2) { return val1 >= val2; }
-
-TEST(PredicateAssertionTest, LinksSuccessfully) {
-  EXPECT_PRED1(IsOdd, 1);
-  EXPECT_PRED2(Ge, 2, 1);
-}
-
-AssertionResult AddToFive(const char* val1_expr,
-                          const char* val2_expr,
-                          int val1,
-                          int val2) {
-  if (val1 + val2 == 5)
-    return AssertionSuccess();
-
-  return AssertionFailure() << val1_expr << " and " << val2_expr
-                            << " (" << val1 << " and " << val2 << ") "
-                            << "do not add up to five, as their sum is "
-                            << val1 + val2;
-}
-
-TEST(PredicateFormatterAssertionTest, LinksSuccessfully) {
-  EXPECT_PRED_FORMAT2(AddToFive, 1 + 2, 2);
-}
-
-
-// Tests linking of comparison assertions.
-TEST(ComparisonAssertionTest, LinksSuccessfully) {
-  EXPECT_EQ(1, 1);
-  EXPECT_NE(1, 2);
-  EXPECT_LT(1, 2);
-  EXPECT_LE(1, 1);
-  EXPECT_GT(2, 1);
-  EXPECT_GE(2, 1);
-
-  EXPECT_EQ('\n', '\n');
-  EXPECT_NE('\n', '\r');
-  EXPECT_LT('\n', 'a');
-  EXPECT_LE('\n', 'b');
-  EXPECT_GT('a', '\t');
-  EXPECT_GE('b', '\t');
-}
-
-TEST(StringComparisonAssertionTest, LinksSuccessfully) {
-  EXPECT_STREQ("test", "test");
-  EXPECT_STRNE("test", "prod");
-
-  char test_str[5] = "test";
-  char prod_str[5] = "prod";
-
-  EXPECT_STREQ(test_str, test_str);
-  EXPECT_STRNE(test_str, prod_str);
-
-  EXPECT_STRCASEEQ("test", "TEST");
-  EXPECT_STRCASENE("test", "prod");
-
-  wchar_t test_wstr[5] = L"test";
-  wchar_t prod_wstr[5] = L"prod";
-
-  EXPECT_STREQ(L"test", L"test");
-  EXPECT_STRNE(L"test", L"prod");
-
-  EXPECT_STREQ(test_wstr, test_wstr);
-  EXPECT_STRNE(test_wstr, prod_wstr);
-
-#if GTEST_HAS_STD_STRING
-  EXPECT_EQ("test", ::std::string("test"));
-  EXPECT_NE("test", ::std::string("prod"));
-
-  EXPECT_EQ(::std::string("test"), "test");
-  EXPECT_NE(::std::string("prod"), "test");
-
-  EXPECT_EQ(test_str, ::std::string("test"));
-  EXPECT_NE(test_str, ::std::string("prod"));
-
-  EXPECT_EQ(::std::string("test"), test_str);
-  EXPECT_NE(::std::string("prod"), test_str);
-
-  EXPECT_EQ(::std::string("test"), ::std::string("test"));
-  EXPECT_NE(::std::string("test"), ::std::string("prod"));
-#endif  // GTEST_HAS_STD_STRING
-
-#if GTEST_HAS_STD_WSTRING
-  EXPECT_EQ(L"test", ::std::wstring(L"test"));
-  EXPECT_NE(L"test", ::std::wstring(L"prod"));
-
-  EXPECT_EQ(::std::wstring(L"test"), L"test");
-  EXPECT_NE(::std::wstring(L"prod"), L"test");
-
-  EXPECT_EQ(test_wstr, ::std::wstring(L"test"));
-  EXPECT_NE(test_wstr, ::std::wstring(L"prod"));
-
-  EXPECT_EQ(::std::wstring(L"test"), test_wstr);
-  EXPECT_NE(::std::wstring(L"prod"), test_wstr);
-
-  EXPECT_EQ(::std::wstring(L"test"), ::std::wstring(L"test"));
-  EXPECT_NE(::std::wstring(L"test"), ::std::wstring(L"prod"));
-#endif  // GTEST_HAS_STD_WSTRING
-}
-
-// Tests linking of floating point assertions.
-TEST(FloatingPointComparisonAssertionTest, LinksSuccessfully) {
-  EXPECT_FLOAT_EQ(0.0f, 0.0f);
-  EXPECT_DOUBLE_EQ(0.0, 0.0);
-  EXPECT_NEAR(0.0, 0.1, 0.2);
-  EXPECT_PRED_FORMAT2(::testing::FloatLE, 0.0f, 0.01f);
-  EXPECT_PRED_FORMAT2(::testing::DoubleLE, 0.0, 0.001);
-}
-
-#if GTEST_OS_WINDOWS
-// Tests linking of HRESULT assertions.
-TEST(HresultAssertionTest, LinksSuccessfully) {
-  EXPECT_HRESULT_SUCCEEDED(S_OK);
-  EXPECT_HRESULT_FAILED(E_FAIL);
-}
-#endif  // GTEST_OS_WINDOWS
-
-#if GTEST_HAS_EXCEPTIONS
-// Tests linking of exception assertions.
-TEST(ExceptionAssertionTest, LinksSuccessfully) {
-  EXPECT_THROW(throw 1, int);
-  EXPECT_ANY_THROW(throw 1);
-  EXPECT_NO_THROW(std::vector<int> v);
-}
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// Tests linking of death test assertions.
-TEST(DeathTestAssertionDeathTest, LinksSuccessfully) {
-  EXPECT_DEATH_IF_SUPPORTED(exit(1), "");
-
-#if GTEST_HAS_DEATH_TEST
-  EXPECT_EXIT(exit(1), ExitedWithCode(1), "");
-#endif  // GTEST_HAS_DEATH_TEST
-}
-
-// Tests linking of SCOPED_TRACE.
-void Sub() { EXPECT_EQ(1, 1); }
-
-TEST(ScopedTraceTest, LinksSuccessfully) {
-  SCOPED_TRACE("X");
-  Sub();
-}
-
-// Tests linking of failure absence assertions.
-TEST(NoFailureAssertionTest, LinksSuccessfully) {
-  EXPECT_NO_FATAL_FAILURE(IsEven(2));
-}
-
-// Tests linking of HasFatalFailure.
-TEST(HasFatalFailureTest, LinksSuccessfully) {
-  EXPECT_FALSE(HasFatalFailure());
-  EXPECT_FALSE(HasNonfatalFailure());
-  EXPECT_FALSE(HasFailure());
-}
-
-// Tests linking of RecordProperty.
-TEST(RecordPropertyTest, LinksSuccessfully) {
-  RecordProperty("DummyPropery", "DummyValue");
-}
-
-// Tests linking of environments.
-class MyEnvironment : public Environment {};
-
-Environment* const environment = AddGlobalTestEnvironment(new MyEnvironment);
-
-// Tests linking of flags.
-TEST(FlagTest, LinksSuccessfully) {
-  Message message;
-
-  message << GTEST_FLAG(filter);
-  message << GTEST_FLAG(also_run_disabled_tests);
-  message << GTEST_FLAG(repeat);
-  message << GTEST_FLAG(shuffle);
-  message << GTEST_FLAG(random_seed);
-  message << GTEST_FLAG(color);
-  message << GTEST_FLAG(print_time);
-  message << GTEST_FLAG(output);
-  message << GTEST_FLAG(break_on_failure);
-  message << GTEST_FLAG(throw_on_failure);
-  message << GTEST_FLAG(catch_exceptions);
-  message << GTEST_FLAG(stack_trace_depth);
-}
-
-// Tests linking of failure catching assertions.
-void FunctionWithFailure() { FAIL(); }
-
-TEST(FailureCatchingAssertionTest, LinksCorrectly) {
-  EXPECT_FATAL_FAILURE(FunctionWithFailure(), "");
-  EXPECT_NONFATAL_FAILURE(ADD_FAILURE(), "");
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FunctionWithFailure(), "");
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(ADD_FAILURE(), "");
-}
-
-// Tests linking of the reflection API.
-TEST(ReflectionApiTest, LinksCorrectly) {
-  // UnitTest API.
-  UnitTest* unit_test = UnitTest::GetInstance();
-
-  unit_test->original_working_dir();
-  EXPECT_TRUE(unit_test->current_test_case() != NULL);
-  EXPECT_TRUE(unit_test->current_test_info() != NULL);
-  EXPECT_NE(0, unit_test->random_seed());
-  EXPECT_GE(unit_test->successful_test_case_count(), 0);
-  EXPECT_EQ(0, unit_test->failed_test_case_count());
-  EXPECT_GE(unit_test->total_test_case_count(), 0);
-  EXPECT_GT(unit_test->test_case_to_run_count(), 0);
-  EXPECT_GE(unit_test->successful_test_count(), 0);
-  EXPECT_EQ(0, unit_test->failed_test_count());
-  EXPECT_EQ(0, unit_test->disabled_test_count());
-  EXPECT_GT(unit_test->total_test_count(), 0);
-  EXPECT_GT(unit_test->test_to_run_count(), 0);
-  EXPECT_GE(unit_test->elapsed_time(), 0);
-  EXPECT_TRUE(unit_test->Passed());
-  EXPECT_FALSE(unit_test->Failed());
-  EXPECT_TRUE(unit_test->GetTestCase(0) != NULL);
-
-  // TestCase API.
-  const TestCase*const  test_case = unit_test->current_test_case();
-
-  EXPECT_STRNE("", test_case->name());
-  const char* const test_case_comment = test_case->comment();
-  EXPECT_TRUE(test_case->should_run());
-  EXPECT_GE(test_case->successful_test_count(), 0);
-  EXPECT_EQ(0, test_case->failed_test_count());
-  EXPECT_EQ(0, test_case->disabled_test_count());
-  EXPECT_GT(test_case->test_to_run_count(), 0);
-  EXPECT_GT(test_case->total_test_count(), 0);
-  EXPECT_TRUE(test_case->Passed());
-  EXPECT_FALSE(test_case->Failed());
-  EXPECT_GE(test_case->elapsed_time(), 0);
-  EXPECT_TRUE(test_case->GetTestInfo(0) != NULL);
-
-  // TestInfo API.
-  const TestInfo* const test_info = unit_test->current_test_info();
-
-  EXPECT_STRNE("", test_info->test_case_name());
-  EXPECT_STRNE("", test_info->name());
-  EXPECT_STREQ(test_case_comment, test_info->test_case_comment());
-  const char* const comment = test_info->comment();
-  EXPECT_TRUE(comment == NULL || strlen(comment) >= 0);
-  EXPECT_TRUE(test_info->should_run());
-  EXPECT_TRUE(test_info->result() != NULL);
-
-  // TestResult API.
-  const TestResult* const test_result = test_info->result();
-
-  SUCCEED() << "This generates a successful test part instance for API testing";
-  RecordProperty("Test Name", "Test Value");
-  EXPECT_EQ(1, test_result->total_part_count());
-  EXPECT_EQ(1, test_result->test_property_count());
-  EXPECT_TRUE(test_result->Passed());
-  EXPECT_FALSE(test_result->Failed());
-  EXPECT_FALSE(test_result->HasFatalFailure());
-  EXPECT_FALSE(test_result->HasNonfatalFailure());
-  EXPECT_GE(test_result->elapsed_time(), 0);
-  const TestPartResult& test_part_result = test_result->GetTestPartResult(0);
-  const TestProperty& test_property = test_result->GetTestProperty(0);
-
-  // TestPartResult API.
-  EXPECT_EQ(TestPartResult::kSuccess, test_part_result.type());
-  EXPECT_STRNE("", test_part_result.file_name());
-  EXPECT_GT(test_part_result.line_number(), 0);
-  EXPECT_STRNE("", test_part_result.summary());
-  EXPECT_STRNE("", test_part_result.message());
-  EXPECT_TRUE(test_part_result.passed());
-  EXPECT_FALSE(test_part_result.failed());
-  EXPECT_FALSE(test_part_result.nonfatally_failed());
-  EXPECT_FALSE(test_part_result.fatally_failed());
-
-  // TestProperty API.
-  EXPECT_STREQ("Test Name", test_property.key());
-  EXPECT_STREQ("Test Value", test_property.value());
-}
-
-// Tests linking of the event listener API.
-class MyListener : public TestEventListener {
-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
-                                    int /*iteration*/) {}
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
-  virtual void OnTestStart(const TestInfo& /*test_info*/) {}
-  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
-  virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
-  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
-                                  int /*iteration*/) {}
-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
-};
-
-class MyOtherListener : public EmptyTestEventListener {};
-
-int main(int argc, char **argv) {
-  testing::InitGoogleTest(&argc, argv);
-
-  void (*wide_init_google_test)(int*, wchar_t**) = &testing::InitGoogleTest;
-
-  // Ensures the linker doesn't throw away reference to wide InitGoogleTest.
-  GTEST_CHECK_(wide_init_google_test != NULL);
-
-  TestEventListeners& listeners =  UnitTest::GetInstance()->listeners();
-  TestEventListener* listener = new MyListener;
-
-  listeners.Append(listener);
-  listeners.Release(listener);
-  listeners.Append(new MyOtherListener);
-  listener = listeners.default_result_printer();
-  listener = listeners.default_xml_generator();
-
-  int ret_val = RUN_ALL_TESTS();
-  static_cast<void>(ret_val);
-  return  0;
-}
diff --git a/test/gtest_unittest.cc b/test/gtest_unittest.cc
index bd10ae0..199b254 100644
--- a/test/gtest_unittest.cc
+++ b/test/gtest_unittest.cc
@@ -76,13 +76,6 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
 namespace testing {
 namespace internal {
 
-bool ShouldUseColor(bool stdout_is_tty);
-::std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
-bool ParseInt32Flag(const char* str, const char* flag, Int32* value);
-
-// Used for testing the flag parsing.
-extern bool g_help_flag;
-
 // Provides access to otherwise private parts of the TestEventListeners class
 // that are needed to test it.
 class TestEventListenersAccessor {