Line-ending fixes for most of the remaining files.

Fixes line-endings for files with extensions vcd, cc, txt, bat, fxc, inc, lst,
proto, mak, mm, cfg, res, rc, def, vmt, vsh, vbsp, inl, asm, m4, vcproj,
vcxproj, sln, in, java, la, manifest, am, and rad.

Also fixes README, CONTRIBUTING, CONTRIBUTORS, LICENSE, CHANGES, COPYING, and
gitignore.

Finally, fixes executable bits.

41 files changed, 18565 insertions, 18565 deletions

diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-death-test_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-death-test_test.cc
index 068e6b8f..288c70a0 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-death-test_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-death-test_test.cc
@@ -1,1248 +1,1248 @@
-// Copyright 2005, 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: [email protected] (Zhanyong Wan)

-//

-// Tests for death tests.

-

-#include <gtest/gtest-death-test.h>

-#include <gtest/gtest.h>

-#include <gtest/internal/gtest-filepath.h>

-

-using testing::internal::AlwaysFalse;

-using testing::internal::AlwaysTrue;

-

-#if GTEST_HAS_DEATH_TEST

-

-#if GTEST_OS_WINDOWS

-#include <direct.h>          // For chdir().

-#else

-#include <unistd.h>

-#include <sys/wait.h>        // For waitpid.

-#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

-// 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_

-

-namespace posix = ::testing::internal::posix;

-

-using testing::Message;

-using testing::internal::DeathTest;

-using testing::internal::DeathTestFactory;

-using testing::internal::FilePath;

-using testing::internal::GetLastErrnoDescription;

-using testing::internal::GetUnitTestImpl;

-using testing::internal::ParseNaturalNumber;

-using testing::internal::String;

-

-namespace testing {

-namespace internal {

-

-// A helper class whose objects replace the death test factory for a

-// single UnitTest object during their lifetimes.

-class ReplaceDeathTestFactory {

- public:

-  explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory)

-      : unit_test_impl_(GetUnitTestImpl()) {

-    old_factory_ = unit_test_impl_->death_test_factory_.release();

-    unit_test_impl_->death_test_factory_.reset(new_factory);

-  }

-

-  ~ReplaceDeathTestFactory() {

-    unit_test_impl_->death_test_factory_.release();

-    unit_test_impl_->death_test_factory_.reset(old_factory_);

-  }

- private:

-  // Prevents copying ReplaceDeathTestFactory objects.

-  ReplaceDeathTestFactory(const ReplaceDeathTestFactory&);

-  void operator=(const ReplaceDeathTestFactory&);

-

-  UnitTestImpl* unit_test_impl_;

-  DeathTestFactory* old_factory_;

-};

-

-}  // namespace internal

-}  // namespace testing

-

-// Tests that death tests work.

-

-class TestForDeathTest : public testing::Test {

- protected:

-  TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {}

-

-  virtual ~TestForDeathTest() {

-    posix::ChDir(original_dir_.c_str());

-  }

-

-  // 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

-    // things that conflict with death tests.

-    _exit(1);

-  }

-

-  // A method of the test fixture that may die.

-  void MemberFunction() {

-    if (should_die_) {

-      fprintf(stderr, "%s", "death inside MemberFunction().");

-      fflush(stderr);

-      _exit(1);

-    }

-  }

-

-  // True iff MemberFunction() should die.

-  bool should_die_;

-  const FilePath original_dir_;

-};

-

-// A class with a member function that may die.

-class MayDie {

- public:

-  explicit MayDie(bool should_die) : should_die_(should_die) {}

-

-  // A member function that may die.

-  void MemberFunction() const {

-    if (should_die_) {

-      GTEST_LOG_(FATAL) << "death inside MayDie::MemberFunction().";

-    }

-  }

-

- private:

-  // True iff MemberFunction() should die.

-  bool should_die_;

-};

-

-// A global function that's expected to die.

-void GlobalFunction() {

-  GTEST_LOG_(FATAL) << "death inside GlobalFunction().";

-}

-

-// A non-void function that's expected to die.

-int NonVoidFunction() {

-  GTEST_LOG_(FATAL) << "death inside NonVoidFunction().";

-  return 1;

-}

-

-// A unary function that may die.

-void DieIf(bool should_die) {

-  if (should_die) {

-    GTEST_LOG_(FATAL) << "death inside DieIf().";

-  }

-}

-

-// A binary function that may die.

-bool DieIfLessThan(int x, int y) {

-  if (x < y) {

-    GTEST_LOG_(FATAL) << "death inside DieIfLessThan().";

-  }

-  return true;

-}

-

-// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.

-void DeathTestSubroutine() {

-  EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction");

-  ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction");

-}

-

-// Death in dbg, not opt.

-int DieInDebugElse12(int* sideeffect) {

-  if (sideeffect) *sideeffect = 12;

-#ifndef NDEBUG

-  GTEST_LOG_(FATAL) << "debug death inside DieInDebugElse12()";

-#endif  // NDEBUG

-  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.

-static int NormalExitStatus(int exit_code) {

-  pid_t child_pid = fork();

-  if (child_pid == 0) {

-    _exit(exit_code);

-  }

-  int status;

-  waitpid(child_pid, &status, 0);

-  return status;

-}

-

-// Returns the exit status of a process that raises a given signal.

-// If the signal does not cause the process to die, then it returns

-// instead the exit status of a process that exits normally with exit

-// code 1.  This is a helper function for the ExitStatusPredicateTest

-// test suite.

-static int KilledExitStatus(int signum) {

-  pid_t child_pid = fork();

-  if (child_pid == 0) {

-    raise(signum);

-    _exit(1);

-  }

-  int status;

-  waitpid(child_pid, &status, 0);

-  return status;

-}

-

-// Tests the ExitedWithCode predicate.

-TEST(ExitStatusPredicateTest, ExitedWithCode) {

-  const int status0  = NormalExitStatus(0);

-  const int status1  = NormalExitStatus(1);

-  const int status42 = NormalExitStatus(42);

-  const testing::ExitedWithCode pred0(0);

-  const testing::ExitedWithCode pred1(1);

-  const testing::ExitedWithCode pred42(42);

-  EXPECT_PRED1(pred0,  status0);

-  EXPECT_PRED1(pred1,  status1);

-  EXPECT_PRED1(pred42, status42);

-  EXPECT_FALSE(pred0(status1));

-  EXPECT_FALSE(pred42(status0));

-  EXPECT_FALSE(pred1(status42));

-}

-

-// Tests the KilledBySignal predicate.

-TEST(ExitStatusPredicateTest, KilledBySignal) {

-  const int status_segv = KilledExitStatus(SIGSEGV);

-  const int status_kill = KilledExitStatus(SIGKILL);

-  const testing::KilledBySignal pred_segv(SIGSEGV);

-  const testing::KilledBySignal pred_kill(SIGKILL);

-  EXPECT_PRED1(pred_segv, status_segv);

-  EXPECT_PRED1(pred_kill, status_kill);

-  EXPECT_FALSE(pred_segv(status_kill));

-  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.

-TEST_F(TestForDeathTest, SingleStatement) {

-  if (AlwaysFalse())

-    // This would fail if executed; this is a compilation test only

-    ASSERT_DEATH(return, "");

-

-  if (AlwaysTrue())

-    EXPECT_DEATH(_exit(1), "");

-  else

-    // This empty "else" branch is meant to ensure that EXPECT_DEATH

-    // doesn't expand into an "if" statement without an "else"

-    ;

-

-  if (AlwaysFalse())

-    ASSERT_DEATH(return, "") << "did not die";

-

-  if (AlwaysFalse())

-    ;

-  else

-    EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3;

-}

-

-void DieWithEmbeddedNul() {

-  fprintf(stderr, "Hello%cmy null world.\n", '\0');

-  fflush(stderr);

-  _exit(1);

-}

-

-#if GTEST_USES_PCRE

-// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error

-// message has a NUL character in it.

-TEST_F(TestForDeathTest, EmbeddedNulInMessage) {

-  // TODO([email protected]): <regex.h> doesn't support matching strings

-  // with embedded NUL characters - find a way to workaround it.

-  EXPECT_DEATH(DieWithEmbeddedNul(), "my null world");

-  ASSERT_DEATH(DieWithEmbeddedNul(), "my null world");

-}

-#endif  // GTEST_USES_PCRE

-

-// 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";

-

-  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

-// death test.

-TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {

-  testing::GTEST_FLAG(death_test_style) = "fast";

-  ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");

-}

-

-// Tests that a method of the test fixture can be used in a "fast"

-// style death test.

-TEST_F(TestForDeathTest, MemberFunctionFastStyle) {

-  testing::GTEST_FLAG(death_test_style) = "fast";

-  should_die_ = true;

-  EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");

-}

-

-void ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); }

-

-// Tests that death tests work even if the current directory has been

-// changed.

-TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {

-  testing::GTEST_FLAG(death_test_style) = "fast";

-

-  ChangeToRootDir();

-  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");

-

-  ChangeToRootDir();

-  ASSERT_DEATH(_exit(1), "");

-}

-

-// Repeats a representative sample of death tests in the "threadsafe" style:

-

-TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {

-  testing::GTEST_FLAG(death_test_style) = "threadsafe";

-  ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");

-}

-

-TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {

-  testing::GTEST_FLAG(death_test_style) = "threadsafe";

-  should_die_ = true;

-  EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");

-}

-

-TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {

-  testing::GTEST_FLAG(death_test_style) = "threadsafe";

-

-  for (int i = 0; i < 3; ++i)

-    EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;

-}

-

-TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {

-  testing::GTEST_FLAG(death_test_style) = "threadsafe";

-

-  ChangeToRootDir();

-  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");

-

-  ChangeToRootDir();

-  ASSERT_DEATH(_exit(1), "");

-}

-

-TEST_F(TestForDeathTest, MixedStyles) {

-  testing::GTEST_FLAG(death_test_style) = "threadsafe";

-  EXPECT_DEATH(_exit(1), "");

-  testing::GTEST_FLAG(death_test_style) = "fast";

-  EXPECT_DEATH(_exit(1), "");

-}

-

-namespace {

-

-bool pthread_flag;

-

-void SetPthreadFlag() {

-  pthread_flag = true;

-}

-

-}  // namespace

-

-#if GTEST_HAS_CLONE

-

-TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {

-  if (!testing::GTEST_FLAG(death_test_use_fork)) {

-    testing::GTEST_FLAG(death_test_style) = "threadsafe";

-    pthread_flag = false;

-    ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL));

-    ASSERT_DEATH(_exit(1), "");

-    ASSERT_FALSE(pthread_flag);

-  }

-}

-

-#endif  // GTEST_HAS_CLONE

-

-// Tests that a method of another class can be used in a death test.

-TEST_F(TestForDeathTest, MethodOfAnotherClass) {

-  const MayDie x(true);

-  ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction");

-}

-

-// Tests that a global function can be used in a death test.

-TEST_F(TestForDeathTest, GlobalFunction) {

-  EXPECT_DEATH(GlobalFunction(), "GlobalFunction");

-}

-

-// Tests that any value convertible to an RE works as a second

-// argument to EXPECT_DEATH.

-TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {

-  static const char regex_c_str[] = "GlobalFunction";

-  EXPECT_DEATH(GlobalFunction(), regex_c_str);

-

-  const testing::internal::RE regex(regex_c_str);

-  EXPECT_DEATH(GlobalFunction(), regex);

-

-#if GTEST_HAS_GLOBAL_STRING

-  const string regex_str(regex_c_str);

-  EXPECT_DEATH(GlobalFunction(), regex_str);

-#endif  // GTEST_HAS_GLOBAL_STRING

-

-#if GTEST_HAS_STD_STRING

-  const ::std::string regex_std_str(regex_c_str);

-  EXPECT_DEATH(GlobalFunction(), regex_std_str);

-#endif  // GTEST_HAS_STD_STRING

-}

-

-// Tests that a non-void function can be used in a death test.

-TEST_F(TestForDeathTest, NonVoidFunction) {

-  ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction");

-}

-

-// Tests that functions that take parameter(s) can be used in a death test.

-TEST_F(TestForDeathTest, FunctionWithParameter) {

-  EXPECT_DEATH(DieIf(true), "DieIf\\(\\)");

-  EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan");

-}

-

-// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.

-TEST_F(TestForDeathTest, OutsideFixture) {

-  DeathTestSubroutine();

-}

-

-// Tests that death tests can be done inside a loop.

-TEST_F(TestForDeathTest, InsideLoop) {

-  for (int i = 0; i < 5; i++) {

-    EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i;

-  }

-}

-

-// Tests that a compound statement can be used in a death test.

-TEST_F(TestForDeathTest, CompoundStatement) {

-  EXPECT_DEATH({  // NOLINT

-    const int x = 2;

-    const int y = x + 1;

-    DieIfLessThan(x, y);

-  },

-  "DieIfLessThan");

-}

-

-// Tests that code that doesn't die causes a death test to fail.

-TEST_F(TestForDeathTest, DoesNotDie) {

-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"),

-                          "failed to die");

-}

-

-// Tests that a death test fails when the error message isn't expected.

-TEST_F(TestForDeathTest, ErrorMessageMismatch) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message.";

-  }, "died but not with expected error");

-}

-

-// On exit, *aborted will be true iff the EXPECT_DEATH() statement

-// aborted the function.

-void ExpectDeathTestHelper(bool* aborted) {

-  *aborted = true;

-  EXPECT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.

-  *aborted = false;

-}

-

-// Tests that EXPECT_DEATH doesn't abort the test on failure.

-TEST_F(TestForDeathTest, EXPECT_DEATH) {

-  bool aborted = true;

-  EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted),

-                          "failed to die");

-  EXPECT_FALSE(aborted);

-}

-

-// Tests that ASSERT_DEATH does abort the test on failure.

-TEST_F(TestForDeathTest, ASSERT_DEATH) {

-  static bool aborted;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    aborted = true;

-    ASSERT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.

-    aborted = false;

-  }, "failed to die");

-  EXPECT_TRUE(aborted);

-}

-

-// Tests that EXPECT_DEATH evaluates the arguments exactly once.

-TEST_F(TestForDeathTest, SingleEvaluation) {

-  int x = 3;

-  EXPECT_DEATH(DieIf((++x) == 4), "DieIf");

-

-  const char* regex = "DieIf";

-  const char* regex_save = regex;

-  EXPECT_DEATH(DieIfLessThan(3, 4), regex++);

-  EXPECT_EQ(regex_save + 1, regex);

-}

-

-// Tests that run-away death tests are reported as failures.

-TEST_F(TestForDeathTest, Runaway) {

-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"),

-                          "failed to die.");

-

-  EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"),

-                       "illegal return in test statement.");

-}

-

-

-// Tests that EXPECT_DEBUG_DEATH works as expected,

-// that is, in debug mode, it:

-// 1. Asserts on death.

-// 2. Has no side effect.

-//

-// And in opt mode, it:

-// 1.  Has side effects but does not assert.

-TEST_F(TestForDeathTest, TestExpectDebugDeath) {

-  int sideeffect = 0;

-

-  EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect),

-                     "death.*DieInDebugElse12");

-

-#ifdef NDEBUG

-  // Checks that the assignment occurs in opt mode (sideeffect).

-  EXPECT_EQ(12, sideeffect);

-#else

-  // Checks that the assignment does not occur in dbg mode (no sideeffect).

-  EXPECT_EQ(0, sideeffect);

-#endif

-}

-

-// Tests that ASSERT_DEBUG_DEATH works as expected

-// In debug mode:

-// 1. Asserts on debug death.

-// 2. Has no side effect.

-//

-// In opt mode:

-// 1. Has side effects and returns the expected value (12).

-TEST_F(TestForDeathTest, TestAssertDebugDeath) {

-  int sideeffect = 0;

-

-  ASSERT_DEBUG_DEATH({  // NOLINT

-    // Tests that the return value is 12 in opt mode.

-    EXPECT_EQ(12, DieInDebugElse12(&sideeffect));

-    // Tests that the side effect occurred in opt mode.

-    EXPECT_EQ(12, sideeffect);

-  }, "death.*DieInDebugElse12");

-

-#ifdef NDEBUG

-  // Checks that the assignment occurs in opt mode (sideeffect).

-  EXPECT_EQ(12, sideeffect);

-#else

-  // Checks that the assignment does not occur in dbg mode (no sideeffect).

-  EXPECT_EQ(0, sideeffect);

-#endif

-}

-

-#ifndef NDEBUG

-

-void ExpectDebugDeathHelper(bool* aborted) {

-  *aborted = true;

-  EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail.";

-  *aborted = false;

-}

-

-#if GTEST_OS_WINDOWS

-TEST(PopUpDeathTest, 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(PopUpDeathTest, 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) {

-  bool aborted = true;

-  EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), "");

-  EXPECT_FALSE(aborted);

-}

-

-void AssertDebugDeathHelper(bool* aborted) {

-  *aborted = true;

-  ASSERT_DEBUG_DEATH(return, "") << "This is expected to fail.";

-  *aborted = false;

-}

-

-// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on

-// failure.

-TEST_F(TestForDeathTest, AssertDebugDeathAborts) {

-  static bool aborted;

-  aborted = false;

-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");

-  EXPECT_TRUE(aborted);

-}

-

-#endif  // _NDEBUG

-

-// Tests the *_EXIT family of macros, using a variety of predicates.

-static void TestExitMacros() {

-  EXPECT_EXIT(_exit(1),  testing::ExitedWithCode(1),  "");

-  ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");

-

-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW

-  // MinGW (as of MinGW 5.1.6 and MSYS 1.0.11) does not tag crashed

-  // processes with non-zero exit code and does not honor calls to

-  // SetErrorMode(SEM_NOGPFAULTERRORBOX) that are supposed to suppress

-  // error pop-ups.

-  EXPECT_EXIT({

-    testing::GTEST_FLAG(catch_exceptions) = false;

-    *static_cast<int*>(NULL) = 1;

-  }, testing::ExitedWithCode(0xC0000005), "") << "foo";

-

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_EXIT({

-      testing::GTEST_FLAG(catch_exceptions) = false;

-      *static_cast<int*>(NULL) = 1;

-    }, testing::ExitedWithCode(0), "") << "This failure is expected.";

-  }, "This failure is expected.");

-#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW

-

-#if GTEST_OS_WINDOWS

-  // 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) {

-  TestExitMacros();

-}

-

-TEST_F(TestForDeathTest, ExitMacrosUsingFork) {

-  testing::GTEST_FLAG(death_test_use_fork) = true;

-  TestExitMacros();

-}

-

-TEST_F(TestForDeathTest, InvalidStyle) {

-  testing::GTEST_FLAG(death_test_style) = "rococo";

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_DEATH(_exit(0), "") << "This failure is expected.";

-  }, "This failure is expected.");

-}

-

-// A DeathTestFactory that returns MockDeathTests.

-class MockDeathTestFactory : public DeathTestFactory {

- public:

-  MockDeathTestFactory();

-  virtual bool Create(const char* statement,

-                      const ::testing::internal::RE* regex,

-                      const char* file, int line, DeathTest** test);

-

-  // Sets the parameters for subsequent calls to Create.

-  void SetParameters(bool create, DeathTest::TestRole role,

-                     int status, bool passed);

-

-  // Accessors.

-  int AssumeRoleCalls() const { return assume_role_calls_; }

-  int WaitCalls() const { return wait_calls_; }

-  int PassedCalls() const { return passed_args_.size(); }

-  bool PassedArgument(int n) const { return passed_args_[n]; }

-  int AbortCalls() const { return abort_args_.size(); }

-  DeathTest::AbortReason AbortArgument(int n) const {

-    return abort_args_[n];

-  }

-  bool TestDeleted() const { return test_deleted_; }

-

- private:

-  friend class MockDeathTest;

-  // If true, Create will return a MockDeathTest; otherwise it returns

-  // NULL.

-  bool create_;

-  // The value a MockDeathTest will return from its AssumeRole method.

-  DeathTest::TestRole role_;

-  // The value a MockDeathTest will return from its Wait method.

-  int status_;

-  // The value a MockDeathTest will return from its Passed method.

-  bool passed_;

-

-  // Number of times AssumeRole was called.

-  int assume_role_calls_;

-  // Number of times Wait was called.

-  int wait_calls_;

-  // The arguments to the calls to Passed since the last call to

-  // SetParameters.

-  std::vector<bool> passed_args_;

-  // The arguments to the calls to Abort since the last call to

-  // SetParameters.

-  std::vector<DeathTest::AbortReason> abort_args_;

-  // True if the last MockDeathTest returned by Create has been

-  // deleted.

-  bool test_deleted_;

-};

-

-

-// A DeathTest implementation useful in testing.  It returns values set

-// at its creation from its various inherited DeathTest methods, and

-// reports calls to those methods to its parent MockDeathTestFactory

-// object.

-class MockDeathTest : public DeathTest {

- public:

-  MockDeathTest(MockDeathTestFactory *parent,

-                TestRole role, int status, bool passed) :

-      parent_(parent), role_(role), status_(status), passed_(passed) {

-  }

-  virtual ~MockDeathTest() {

-    parent_->test_deleted_ = true;

-  }

-  virtual TestRole AssumeRole() {

-    ++parent_->assume_role_calls_;

-    return role_;

-  }

-  virtual int Wait() {

-    ++parent_->wait_calls_;

-    return status_;

-  }

-  virtual bool Passed(bool exit_status_ok) {

-    parent_->passed_args_.push_back(exit_status_ok);

-    return passed_;

-  }

-  virtual void Abort(AbortReason reason) {

-    parent_->abort_args_.push_back(reason);

-  }

- private:

-  MockDeathTestFactory* const parent_;

-  const TestRole role_;

-  const int status_;

-  const bool passed_;

-};

-

-

-// MockDeathTestFactory constructor.

-MockDeathTestFactory::MockDeathTestFactory()

-    : create_(true),

-      role_(DeathTest::OVERSEE_TEST),

-      status_(0),

-      passed_(true),

-      assume_role_calls_(0),

-      wait_calls_(0),

-      passed_args_(),

-      abort_args_() {

-}

-

-

-// Sets the parameters for subsequent calls to Create.

-void MockDeathTestFactory::SetParameters(bool create,

-                                         DeathTest::TestRole role,

-                                         int status, bool passed) {

-  create_ = create;

-  role_ = role;

-  status_ = status;

-  passed_ = passed;

-

-  assume_role_calls_ = 0;

-  wait_calls_ = 0;

-  passed_args_.clear();

-  abort_args_.clear();

-}

-

-

-// Sets test to NULL (if create_ is false) or to the address of a new

-// MockDeathTest object with parameters taken from the last call

-// to SetParameters (if create_ is true).  Always returns true.

-bool MockDeathTestFactory::Create(const char* /*statement*/,

-                                  const ::testing::internal::RE* /*regex*/,

-                                  const char* /*file*/,

-                                  int /*line*/,

-                                  DeathTest** test) {

-  test_deleted_ = false;

-  if (create_) {

-    *test = new MockDeathTest(this, role_, status_, passed_);

-  } else {

-    *test = NULL;

-  }

-  return true;

-}

-

-// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro.

-// It installs a MockDeathTestFactory that is used for the duration

-// of the test case.

-class MacroLogicDeathTest : public testing::Test {

- protected:

-  static testing::internal::ReplaceDeathTestFactory* replacer_;

-  static MockDeathTestFactory* factory_;

-

-  static void SetUpTestCase() {

-    factory_ = new MockDeathTestFactory;

-    replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_);

-  }

-

-  static void TearDownTestCase() {

-    delete replacer_;

-    replacer_ = NULL;

-    delete factory_;

-    factory_ = NULL;

-  }

-

-  // Runs a death test that breaks the rules by returning.  Such a death

-  // test cannot be run directly from a test routine that uses a

-  // MockDeathTest, or the remainder of the routine will not be executed.

-  static void RunReturningDeathTest(bool* flag) {

-    ASSERT_DEATH({  // NOLINT

-      *flag = true;

-      return;

-    }, "");

-  }

-};

-

-testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_

-    = NULL;

-MockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL;

-

-

-// Test that nothing happens when the factory doesn't return a DeathTest:

-TEST_F(MacroLogicDeathTest, NothingHappens) {

-  bool flag = false;

-  factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true);

-  EXPECT_DEATH(flag = true, "");

-  EXPECT_FALSE(flag);

-  EXPECT_EQ(0, factory_->AssumeRoleCalls());

-  EXPECT_EQ(0, factory_->WaitCalls());

-  EXPECT_EQ(0, factory_->PassedCalls());

-  EXPECT_EQ(0, factory_->AbortCalls());

-  EXPECT_FALSE(factory_->TestDeleted());

-}

-

-// Test that the parent process doesn't run the death test code,

-// and that the Passed method returns false when the (simulated)

-// child process exits with status 0:

-TEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) {

-  bool flag = false;

-  factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true);

-  EXPECT_DEATH(flag = true, "");

-  EXPECT_FALSE(flag);

-  EXPECT_EQ(1, factory_->AssumeRoleCalls());

-  EXPECT_EQ(1, factory_->WaitCalls());

-  ASSERT_EQ(1, factory_->PassedCalls());

-  EXPECT_FALSE(factory_->PassedArgument(0));

-  EXPECT_EQ(0, factory_->AbortCalls());

-  EXPECT_TRUE(factory_->TestDeleted());

-}

-

-// Tests that the Passed method was given the argument "true" when

-// the (simulated) child process exits with status 1:

-TEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) {

-  bool flag = false;

-  factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true);

-  EXPECT_DEATH(flag = true, "");

-  EXPECT_FALSE(flag);

-  EXPECT_EQ(1, factory_->AssumeRoleCalls());

-  EXPECT_EQ(1, factory_->WaitCalls());

-  ASSERT_EQ(1, factory_->PassedCalls());

-  EXPECT_TRUE(factory_->PassedArgument(0));

-  EXPECT_EQ(0, factory_->AbortCalls());

-  EXPECT_TRUE(factory_->TestDeleted());

-}

-

-// Tests that the (simulated) child process executes the death test

-// code, and is aborted with the correct AbortReason if it

-// executes a return statement.

-TEST_F(MacroLogicDeathTest, ChildPerformsReturn) {

-  bool flag = false;

-  factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);

-  RunReturningDeathTest(&flag);

-  EXPECT_TRUE(flag);

-  EXPECT_EQ(1, factory_->AssumeRoleCalls());

-  EXPECT_EQ(0, factory_->WaitCalls());

-  EXPECT_EQ(0, factory_->PassedCalls());

-  EXPECT_EQ(1, factory_->AbortCalls());

-  EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,

-            factory_->AbortArgument(0));

-  EXPECT_TRUE(factory_->TestDeleted());

-}

-

-// Tests that the (simulated) child process is aborted with the

-// correct AbortReason if it does not die.

-TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {

-  bool flag = false;

-  factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);

-  EXPECT_DEATH(flag = true, "");

-  EXPECT_TRUE(flag);

-  EXPECT_EQ(1, factory_->AssumeRoleCalls());

-  EXPECT_EQ(0, factory_->WaitCalls());

-  EXPECT_EQ(0, factory_->PassedCalls());

-  // This time there are two calls to Abort: one since the test didn't

-  // die, and another from the ReturnSentinel when it's destroyed.  The

-  // sentinel normally isn't destroyed if a test doesn't die, since

-  // _exit(2) is called in that case by ForkingDeathTest, but not by

-  // our MockDeathTest.

-  ASSERT_EQ(2, factory_->AbortCalls());

-  EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE,

-            factory_->AbortArgument(0));

-  EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,

-            factory_->AbortArgument(1));

-  EXPECT_TRUE(factory_->TestDeleted());

-}

-

-// Tests that a successful death test does not register a successful

-// test part.

-TEST(SuccessRegistrationDeathTest, NoSuccessPart) {

-  EXPECT_DEATH(_exit(1), "");

-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());

-}

-

-TEST(StreamingAssertionsDeathTest, DeathTest) {

-  EXPECT_DEATH(_exit(1), "") << "unexpected failure";

-  ASSERT_DEATH(_exit(1), "") << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_DEATH(_exit(0), "") << "expected failure";

-  }, "expected failure");

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_DEATH(_exit(0), "") << "expected failure";

-  }, "expected failure");

-}

-

-// Tests that GetLastErrnoDescription returns an empty string when the

-// last error is 0 and non-empty string when it is non-zero.

-TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {

-  errno = ENOENT;

-  EXPECT_STRNE("", GetLastErrnoDescription().c_str());

-  errno = 0;

-  EXPECT_STREQ("", GetLastErrnoDescription().c_str());

-}

-

-#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(123U, result);

-

-  // Check 0 as an edge case.

-  result = 1;

-  ASSERT_TRUE(ParseNaturalNumber(String("0"), &result));

-  EXPECT_EQ(0U, result);

-

-  result = 1;

-  ASSERT_TRUE(ParseNaturalNumber(String("00000"), &result));

-  EXPECT_EQ(0U, 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([email protected]): 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

-

-// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger

-// failures when death tests are available on the system.

-TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {

-  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(false) << "failure", "false.*failure");

-  ASSERT_DEATH_IF_SUPPORTED(GTEST_CHECK_(false) << "failure", "false.*failure");

-

-  // Empty statement will not crash, which must trigger a failure.

-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), "");

-  EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), "");

-}

-

-#else

-

-using testing::internal::CaptureStderr;

-using testing::internal::GetCapturedStderr;

-using testing::internal::String;

-

-// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still

-// defined but do not trigger failures when death tests are not available on

-// the system.

-TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {

-  // Empty statement will not crash, but that should not trigger a failure

-  // when death tests are not supported.

-  CaptureStderr();

-  EXPECT_DEATH_IF_SUPPORTED(;, "");

-  String output = GetCapturedStderr();

-  ASSERT_TRUE(NULL != strstr(output.c_str(),

-                             "Death tests are not supported on this platform"));

-  ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));

-

-  // The streamed message should not be printed as there is no test failure.

-  CaptureStderr();

-  EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message";

-  output = GetCapturedStderr();

-  ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));

-

-  CaptureStderr();

-  ASSERT_DEATH_IF_SUPPORTED(;, "");  // NOLINT

-  output = GetCapturedStderr();

-  ASSERT_TRUE(NULL != strstr(output.c_str(),

-                             "Death tests are not supported on this platform"));

-  ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));

-

-  CaptureStderr();

-  ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message";  // NOLINT

-  output = GetCapturedStderr();

-  ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));

-}

-

-void FuncWithAssert(int* n) {

-  ASSERT_DEATH_IF_SUPPORTED(return;, "");

-  (*n)++;

-}

-

-// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current

-// function (as ASSERT_DEATH does) if death tests are not supported.

-TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {

-  int n = 0;

-  FuncWithAssert(&n);

-  EXPECT_EQ(1, n);

-}

-#endif  // GTEST_HAS_DEATH_TEST

-

-// 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.

-//

-// The syntax should work whether death tests are available or not.

-TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {

-  if (AlwaysFalse())

-    // This would fail if executed; this is a compilation test only

-    ASSERT_DEATH_IF_SUPPORTED(return, "");

-

-  if (AlwaysTrue())

-    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "");

-  else

-    // This empty "else" branch is meant to ensure that EXPECT_DEATH

-    // doesn't expand into an "if" statement without an "else"

-    ;  // NOLINT

-

-  if (AlwaysFalse())

-    ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die";

-

-  if (AlwaysFalse())

-    ;  // NOLINT

-  else

-    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3;

-}

-

-// Tests that conditional death test macros expand to code which interacts

-// well with switch statements.

-TEST(ConditionalDeathMacrosSyntaxDeathTest, 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_IF_SUPPORTED(_exit(1), "")

-          << "exit in default switch handler";

-

-  switch (0)

-    case 0:

-      EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";

-

-#ifdef _MSC_VER

-#pragma warning(pop)

-#endif  // _MSC_VER

-}

-

-// Tests that a test case whose name ends with "DeathTest" works fine

-// on Windows.

-TEST(NotADeathTest, Test) {

-  SUCCEED();

-}

+// Copyright 2005, 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: [email protected] (Zhanyong Wan)
+//
+// Tests for death tests.
+
+#include <gtest/gtest-death-test.h>
+#include <gtest/gtest.h>
+#include <gtest/internal/gtest-filepath.h>
+
+using testing::internal::AlwaysFalse;
+using testing::internal::AlwaysTrue;
+
+#if GTEST_HAS_DEATH_TEST
+
+#if GTEST_OS_WINDOWS
+#include <direct.h>          // For chdir().
+#else
+#include <unistd.h>
+#include <sys/wait.h>        // For waitpid.
+#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
+// 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_
+
+namespace posix = ::testing::internal::posix;
+
+using testing::Message;
+using testing::internal::DeathTest;
+using testing::internal::DeathTestFactory;
+using testing::internal::FilePath;
+using testing::internal::GetLastErrnoDescription;
+using testing::internal::GetUnitTestImpl;
+using testing::internal::ParseNaturalNumber;
+using testing::internal::String;
+
+namespace testing {
+namespace internal {
+
+// A helper class whose objects replace the death test factory for a
+// single UnitTest object during their lifetimes.
+class ReplaceDeathTestFactory {
+ public:
+  explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory)
+      : unit_test_impl_(GetUnitTestImpl()) {
+    old_factory_ = unit_test_impl_->death_test_factory_.release();
+    unit_test_impl_->death_test_factory_.reset(new_factory);
+  }
+
+  ~ReplaceDeathTestFactory() {
+    unit_test_impl_->death_test_factory_.release();
+    unit_test_impl_->death_test_factory_.reset(old_factory_);
+  }
+ private:
+  // Prevents copying ReplaceDeathTestFactory objects.
+  ReplaceDeathTestFactory(const ReplaceDeathTestFactory&);
+  void operator=(const ReplaceDeathTestFactory&);
+
+  UnitTestImpl* unit_test_impl_;
+  DeathTestFactory* old_factory_;
+};
+
+}  // namespace internal
+}  // namespace testing
+
+// Tests that death tests work.
+
+class TestForDeathTest : public testing::Test {
+ protected:
+  TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {}
+
+  virtual ~TestForDeathTest() {
+    posix::ChDir(original_dir_.c_str());
+  }
+
+  // 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
+    // things that conflict with death tests.
+    _exit(1);
+  }
+
+  // A method of the test fixture that may die.
+  void MemberFunction() {
+    if (should_die_) {
+      fprintf(stderr, "%s", "death inside MemberFunction().");
+      fflush(stderr);
+      _exit(1);
+    }
+  }
+
+  // True iff MemberFunction() should die.
+  bool should_die_;
+  const FilePath original_dir_;
+};
+
+// A class with a member function that may die.
+class MayDie {
+ public:
+  explicit MayDie(bool should_die) : should_die_(should_die) {}
+
+  // A member function that may die.
+  void MemberFunction() const {
+    if (should_die_) {
+      GTEST_LOG_(FATAL) << "death inside MayDie::MemberFunction().";
+    }
+  }
+
+ private:
+  // True iff MemberFunction() should die.
+  bool should_die_;
+};
+
+// A global function that's expected to die.
+void GlobalFunction() {
+  GTEST_LOG_(FATAL) << "death inside GlobalFunction().";
+}
+
+// A non-void function that's expected to die.
+int NonVoidFunction() {
+  GTEST_LOG_(FATAL) << "death inside NonVoidFunction().";
+  return 1;
+}
+
+// A unary function that may die.
+void DieIf(bool should_die) {
+  if (should_die) {
+    GTEST_LOG_(FATAL) << "death inside DieIf().";
+  }
+}
+
+// A binary function that may die.
+bool DieIfLessThan(int x, int y) {
+  if (x < y) {
+    GTEST_LOG_(FATAL) << "death inside DieIfLessThan().";
+  }
+  return true;
+}
+
+// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
+void DeathTestSubroutine() {
+  EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction");
+  ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction");
+}
+
+// Death in dbg, not opt.
+int DieInDebugElse12(int* sideeffect) {
+  if (sideeffect) *sideeffect = 12;
+#ifndef NDEBUG
+  GTEST_LOG_(FATAL) << "debug death inside DieInDebugElse12()";
+#endif  // NDEBUG
+  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.
+static int NormalExitStatus(int exit_code) {
+  pid_t child_pid = fork();
+  if (child_pid == 0) {
+    _exit(exit_code);
+  }
+  int status;
+  waitpid(child_pid, &status, 0);
+  return status;
+}
+
+// Returns the exit status of a process that raises a given signal.
+// If the signal does not cause the process to die, then it returns
+// instead the exit status of a process that exits normally with exit
+// code 1.  This is a helper function for the ExitStatusPredicateTest
+// test suite.
+static int KilledExitStatus(int signum) {
+  pid_t child_pid = fork();
+  if (child_pid == 0) {
+    raise(signum);
+    _exit(1);
+  }
+  int status;
+  waitpid(child_pid, &status, 0);
+  return status;
+}
+
+// Tests the ExitedWithCode predicate.
+TEST(ExitStatusPredicateTest, ExitedWithCode) {
+  const int status0  = NormalExitStatus(0);
+  const int status1  = NormalExitStatus(1);
+  const int status42 = NormalExitStatus(42);
+  const testing::ExitedWithCode pred0(0);
+  const testing::ExitedWithCode pred1(1);
+  const testing::ExitedWithCode pred42(42);
+  EXPECT_PRED1(pred0,  status0);
+  EXPECT_PRED1(pred1,  status1);
+  EXPECT_PRED1(pred42, status42);
+  EXPECT_FALSE(pred0(status1));
+  EXPECT_FALSE(pred42(status0));
+  EXPECT_FALSE(pred1(status42));
+}
+
+// Tests the KilledBySignal predicate.
+TEST(ExitStatusPredicateTest, KilledBySignal) {
+  const int status_segv = KilledExitStatus(SIGSEGV);
+  const int status_kill = KilledExitStatus(SIGKILL);
+  const testing::KilledBySignal pred_segv(SIGSEGV);
+  const testing::KilledBySignal pred_kill(SIGKILL);
+  EXPECT_PRED1(pred_segv, status_segv);
+  EXPECT_PRED1(pred_kill, status_kill);
+  EXPECT_FALSE(pred_segv(status_kill));
+  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.
+TEST_F(TestForDeathTest, SingleStatement) {
+  if (AlwaysFalse())
+    // This would fail if executed; this is a compilation test only
+    ASSERT_DEATH(return, "");
+
+  if (AlwaysTrue())
+    EXPECT_DEATH(_exit(1), "");
+  else
+    // This empty "else" branch is meant to ensure that EXPECT_DEATH
+    // doesn't expand into an "if" statement without an "else"
+    ;
+
+  if (AlwaysFalse())
+    ASSERT_DEATH(return, "") << "did not die";
+
+  if (AlwaysFalse())
+    ;
+  else
+    EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3;
+}
+
+void DieWithEmbeddedNul() {
+  fprintf(stderr, "Hello%cmy null world.\n", '\0');
+  fflush(stderr);
+  _exit(1);
+}
+
+#if GTEST_USES_PCRE
+// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error
+// message has a NUL character in it.
+TEST_F(TestForDeathTest, EmbeddedNulInMessage) {
+  // TODO([email protected]): <regex.h> doesn't support matching strings
+  // with embedded NUL characters - find a way to workaround it.
+  EXPECT_DEATH(DieWithEmbeddedNul(), "my null world");
+  ASSERT_DEATH(DieWithEmbeddedNul(), "my null world");
+}
+#endif  // GTEST_USES_PCRE
+
+// 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";
+
+  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
+// death test.
+TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
+}
+
+// Tests that a method of the test fixture can be used in a "fast"
+// style death test.
+TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  should_die_ = true;
+  EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
+}
+
+void ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); }
+
+// Tests that death tests work even if the current directory has been
+// changed.
+TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+
+  ChangeToRootDir();
+  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
+
+  ChangeToRootDir();
+  ASSERT_DEATH(_exit(1), "");
+}
+
+// Repeats a representative sample of death tests in the "threadsafe" style:
+
+TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
+}
+
+TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  should_die_ = true;
+  EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
+}
+
+TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+
+  for (int i = 0; i < 3; ++i)
+    EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;
+}
+
+TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+
+  ChangeToRootDir();
+  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
+
+  ChangeToRootDir();
+  ASSERT_DEATH(_exit(1), "");
+}
+
+TEST_F(TestForDeathTest, MixedStyles) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  EXPECT_DEATH(_exit(1), "");
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_DEATH(_exit(1), "");
+}
+
+namespace {
+
+bool pthread_flag;
+
+void SetPthreadFlag() {
+  pthread_flag = true;
+}
+
+}  // namespace
+
+#if GTEST_HAS_CLONE
+
+TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
+  if (!testing::GTEST_FLAG(death_test_use_fork)) {
+    testing::GTEST_FLAG(death_test_style) = "threadsafe";
+    pthread_flag = false;
+    ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL));
+    ASSERT_DEATH(_exit(1), "");
+    ASSERT_FALSE(pthread_flag);
+  }
+}
+
+#endif  // GTEST_HAS_CLONE
+
+// Tests that a method of another class can be used in a death test.
+TEST_F(TestForDeathTest, MethodOfAnotherClass) {
+  const MayDie x(true);
+  ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction");
+}
+
+// Tests that a global function can be used in a death test.
+TEST_F(TestForDeathTest, GlobalFunction) {
+  EXPECT_DEATH(GlobalFunction(), "GlobalFunction");
+}
+
+// Tests that any value convertible to an RE works as a second
+// argument to EXPECT_DEATH.
+TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
+  static const char regex_c_str[] = "GlobalFunction";
+  EXPECT_DEATH(GlobalFunction(), regex_c_str);
+
+  const testing::internal::RE regex(regex_c_str);
+  EXPECT_DEATH(GlobalFunction(), regex);
+
+#if GTEST_HAS_GLOBAL_STRING
+  const string regex_str(regex_c_str);
+  EXPECT_DEATH(GlobalFunction(), regex_str);
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#if GTEST_HAS_STD_STRING
+  const ::std::string regex_std_str(regex_c_str);
+  EXPECT_DEATH(GlobalFunction(), regex_std_str);
+#endif  // GTEST_HAS_STD_STRING
+}
+
+// Tests that a non-void function can be used in a death test.
+TEST_F(TestForDeathTest, NonVoidFunction) {
+  ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction");
+}
+
+// Tests that functions that take parameter(s) can be used in a death test.
+TEST_F(TestForDeathTest, FunctionWithParameter) {
+  EXPECT_DEATH(DieIf(true), "DieIf\\(\\)");
+  EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan");
+}
+
+// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
+TEST_F(TestForDeathTest, OutsideFixture) {
+  DeathTestSubroutine();
+}
+
+// Tests that death tests can be done inside a loop.
+TEST_F(TestForDeathTest, InsideLoop) {
+  for (int i = 0; i < 5; i++) {
+    EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i;
+  }
+}
+
+// Tests that a compound statement can be used in a death test.
+TEST_F(TestForDeathTest, CompoundStatement) {
+  EXPECT_DEATH({  // NOLINT
+    const int x = 2;
+    const int y = x + 1;
+    DieIfLessThan(x, y);
+  },
+  "DieIfLessThan");
+}
+
+// Tests that code that doesn't die causes a death test to fail.
+TEST_F(TestForDeathTest, DoesNotDie) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"),
+                          "failed to die");
+}
+
+// Tests that a death test fails when the error message isn't expected.
+TEST_F(TestForDeathTest, ErrorMessageMismatch) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message.";
+  }, "died but not with expected error");
+}
+
+// On exit, *aborted will be true iff the EXPECT_DEATH() statement
+// aborted the function.
+void ExpectDeathTestHelper(bool* aborted) {
+  *aborted = true;
+  EXPECT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
+  *aborted = false;
+}
+
+// Tests that EXPECT_DEATH doesn't abort the test on failure.
+TEST_F(TestForDeathTest, EXPECT_DEATH) {
+  bool aborted = true;
+  EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted),
+                          "failed to die");
+  EXPECT_FALSE(aborted);
+}
+
+// Tests that ASSERT_DEATH does abort the test on failure.
+TEST_F(TestForDeathTest, ASSERT_DEATH) {
+  static bool aborted;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    aborted = true;
+    ASSERT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
+    aborted = false;
+  }, "failed to die");
+  EXPECT_TRUE(aborted);
+}
+
+// Tests that EXPECT_DEATH evaluates the arguments exactly once.
+TEST_F(TestForDeathTest, SingleEvaluation) {
+  int x = 3;
+  EXPECT_DEATH(DieIf((++x) == 4), "DieIf");
+
+  const char* regex = "DieIf";
+  const char* regex_save = regex;
+  EXPECT_DEATH(DieIfLessThan(3, 4), regex++);
+  EXPECT_EQ(regex_save + 1, regex);
+}
+
+// Tests that run-away death tests are reported as failures.
+TEST_F(TestForDeathTest, Runaway) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"),
+                          "failed to die.");
+
+  EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"),
+                       "illegal return in test statement.");
+}
+
+
+// Tests that EXPECT_DEBUG_DEATH works as expected,
+// that is, in debug mode, it:
+// 1. Asserts on death.
+// 2. Has no side effect.
+//
+// And in opt mode, it:
+// 1.  Has side effects but does not assert.
+TEST_F(TestForDeathTest, TestExpectDebugDeath) {
+  int sideeffect = 0;
+
+  EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect),
+                     "death.*DieInDebugElse12");
+
+#ifdef NDEBUG
+  // Checks that the assignment occurs in opt mode (sideeffect).
+  EXPECT_EQ(12, sideeffect);
+#else
+  // Checks that the assignment does not occur in dbg mode (no sideeffect).
+  EXPECT_EQ(0, sideeffect);
+#endif
+}
+
+// Tests that ASSERT_DEBUG_DEATH works as expected
+// In debug mode:
+// 1. Asserts on debug death.
+// 2. Has no side effect.
+//
+// In opt mode:
+// 1. Has side effects and returns the expected value (12).
+TEST_F(TestForDeathTest, TestAssertDebugDeath) {
+  int sideeffect = 0;
+
+  ASSERT_DEBUG_DEATH({  // NOLINT
+    // Tests that the return value is 12 in opt mode.
+    EXPECT_EQ(12, DieInDebugElse12(&sideeffect));
+    // Tests that the side effect occurred in opt mode.
+    EXPECT_EQ(12, sideeffect);
+  }, "death.*DieInDebugElse12");
+
+#ifdef NDEBUG
+  // Checks that the assignment occurs in opt mode (sideeffect).
+  EXPECT_EQ(12, sideeffect);
+#else
+  // Checks that the assignment does not occur in dbg mode (no sideeffect).
+  EXPECT_EQ(0, sideeffect);
+#endif
+}
+
+#ifndef NDEBUG
+
+void ExpectDebugDeathHelper(bool* aborted) {
+  *aborted = true;
+  EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail.";
+  *aborted = false;
+}
+
+#if GTEST_OS_WINDOWS
+TEST(PopUpDeathTest, 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(PopUpDeathTest, 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) {
+  bool aborted = true;
+  EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), "");
+  EXPECT_FALSE(aborted);
+}
+
+void AssertDebugDeathHelper(bool* aborted) {
+  *aborted = true;
+  ASSERT_DEBUG_DEATH(return, "") << "This is expected to fail.";
+  *aborted = false;
+}
+
+// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on
+// failure.
+TEST_F(TestForDeathTest, AssertDebugDeathAborts) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+#endif  // _NDEBUG
+
+// Tests the *_EXIT family of macros, using a variety of predicates.
+static void TestExitMacros() {
+  EXPECT_EXIT(_exit(1),  testing::ExitedWithCode(1),  "");
+  ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+  // MinGW (as of MinGW 5.1.6 and MSYS 1.0.11) does not tag crashed
+  // processes with non-zero exit code and does not honor calls to
+  // SetErrorMode(SEM_NOGPFAULTERRORBOX) that are supposed to suppress
+  // error pop-ups.
+  EXPECT_EXIT({
+    testing::GTEST_FLAG(catch_exceptions) = false;
+    *static_cast<int*>(NULL) = 1;
+  }, testing::ExitedWithCode(0xC0000005), "") << "foo";
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EXIT({
+      testing::GTEST_FLAG(catch_exceptions) = false;
+      *static_cast<int*>(NULL) = 1;
+    }, testing::ExitedWithCode(0), "") << "This failure is expected.";
+  }, "This failure is expected.");
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+
+#if GTEST_OS_WINDOWS
+  // 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) {
+  TestExitMacros();
+}
+
+TEST_F(TestForDeathTest, ExitMacrosUsingFork) {
+  testing::GTEST_FLAG(death_test_use_fork) = true;
+  TestExitMacros();
+}
+
+TEST_F(TestForDeathTest, InvalidStyle) {
+  testing::GTEST_FLAG(death_test_style) = "rococo";
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_DEATH(_exit(0), "") << "This failure is expected.";
+  }, "This failure is expected.");
+}
+
+// A DeathTestFactory that returns MockDeathTests.
+class MockDeathTestFactory : public DeathTestFactory {
+ public:
+  MockDeathTestFactory();
+  virtual bool Create(const char* statement,
+                      const ::testing::internal::RE* regex,
+                      const char* file, int line, DeathTest** test);
+
+  // Sets the parameters for subsequent calls to Create.
+  void SetParameters(bool create, DeathTest::TestRole role,
+                     int status, bool passed);
+
+  // Accessors.
+  int AssumeRoleCalls() const { return assume_role_calls_; }
+  int WaitCalls() const { return wait_calls_; }
+  int PassedCalls() const { return passed_args_.size(); }
+  bool PassedArgument(int n) const { return passed_args_[n]; }
+  int AbortCalls() const { return abort_args_.size(); }
+  DeathTest::AbortReason AbortArgument(int n) const {
+    return abort_args_[n];
+  }
+  bool TestDeleted() const { return test_deleted_; }
+
+ private:
+  friend class MockDeathTest;
+  // If true, Create will return a MockDeathTest; otherwise it returns
+  // NULL.
+  bool create_;
+  // The value a MockDeathTest will return from its AssumeRole method.
+  DeathTest::TestRole role_;
+  // The value a MockDeathTest will return from its Wait method.
+  int status_;
+  // The value a MockDeathTest will return from its Passed method.
+  bool passed_;
+
+  // Number of times AssumeRole was called.
+  int assume_role_calls_;
+  // Number of times Wait was called.
+  int wait_calls_;
+  // The arguments to the calls to Passed since the last call to
+  // SetParameters.
+  std::vector<bool> passed_args_;
+  // The arguments to the calls to Abort since the last call to
+  // SetParameters.
+  std::vector<DeathTest::AbortReason> abort_args_;
+  // True if the last MockDeathTest returned by Create has been
+  // deleted.
+  bool test_deleted_;
+};
+
+
+// A DeathTest implementation useful in testing.  It returns values set
+// at its creation from its various inherited DeathTest methods, and
+// reports calls to those methods to its parent MockDeathTestFactory
+// object.
+class MockDeathTest : public DeathTest {
+ public:
+  MockDeathTest(MockDeathTestFactory *parent,
+                TestRole role, int status, bool passed) :
+      parent_(parent), role_(role), status_(status), passed_(passed) {
+  }
+  virtual ~MockDeathTest() {
+    parent_->test_deleted_ = true;
+  }
+  virtual TestRole AssumeRole() {
+    ++parent_->assume_role_calls_;
+    return role_;
+  }
+  virtual int Wait() {
+    ++parent_->wait_calls_;
+    return status_;
+  }
+  virtual bool Passed(bool exit_status_ok) {
+    parent_->passed_args_.push_back(exit_status_ok);
+    return passed_;
+  }
+  virtual void Abort(AbortReason reason) {
+    parent_->abort_args_.push_back(reason);
+  }
+ private:
+  MockDeathTestFactory* const parent_;
+  const TestRole role_;
+  const int status_;
+  const bool passed_;
+};
+
+
+// MockDeathTestFactory constructor.
+MockDeathTestFactory::MockDeathTestFactory()
+    : create_(true),
+      role_(DeathTest::OVERSEE_TEST),
+      status_(0),
+      passed_(true),
+      assume_role_calls_(0),
+      wait_calls_(0),
+      passed_args_(),
+      abort_args_() {
+}
+
+
+// Sets the parameters for subsequent calls to Create.
+void MockDeathTestFactory::SetParameters(bool create,
+                                         DeathTest::TestRole role,
+                                         int status, bool passed) {
+  create_ = create;
+  role_ = role;
+  status_ = status;
+  passed_ = passed;
+
+  assume_role_calls_ = 0;
+  wait_calls_ = 0;
+  passed_args_.clear();
+  abort_args_.clear();
+}
+
+
+// Sets test to NULL (if create_ is false) or to the address of a new
+// MockDeathTest object with parameters taken from the last call
+// to SetParameters (if create_ is true).  Always returns true.
+bool MockDeathTestFactory::Create(const char* /*statement*/,
+                                  const ::testing::internal::RE* /*regex*/,
+                                  const char* /*file*/,
+                                  int /*line*/,
+                                  DeathTest** test) {
+  test_deleted_ = false;
+  if (create_) {
+    *test = new MockDeathTest(this, role_, status_, passed_);
+  } else {
+    *test = NULL;
+  }
+  return true;
+}
+
+// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro.
+// It installs a MockDeathTestFactory that is used for the duration
+// of the test case.
+class MacroLogicDeathTest : public testing::Test {
+ protected:
+  static testing::internal::ReplaceDeathTestFactory* replacer_;
+  static MockDeathTestFactory* factory_;
+
+  static void SetUpTestCase() {
+    factory_ = new MockDeathTestFactory;
+    replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_);
+  }
+
+  static void TearDownTestCase() {
+    delete replacer_;
+    replacer_ = NULL;
+    delete factory_;
+    factory_ = NULL;
+  }
+
+  // Runs a death test that breaks the rules by returning.  Such a death
+  // test cannot be run directly from a test routine that uses a
+  // MockDeathTest, or the remainder of the routine will not be executed.
+  static void RunReturningDeathTest(bool* flag) {
+    ASSERT_DEATH({  // NOLINT
+      *flag = true;
+      return;
+    }, "");
+  }
+};
+
+testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_
+    = NULL;
+MockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL;
+
+
+// Test that nothing happens when the factory doesn't return a DeathTest:
+TEST_F(MacroLogicDeathTest, NothingHappens) {
+  bool flag = false;
+  factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true);
+  EXPECT_DEATH(flag = true, "");
+  EXPECT_FALSE(flag);
+  EXPECT_EQ(0, factory_->AssumeRoleCalls());
+  EXPECT_EQ(0, factory_->WaitCalls());
+  EXPECT_EQ(0, factory_->PassedCalls());
+  EXPECT_EQ(0, factory_->AbortCalls());
+  EXPECT_FALSE(factory_->TestDeleted());
+}
+
+// Test that the parent process doesn't run the death test code,
+// and that the Passed method returns false when the (simulated)
+// child process exits with status 0:
+TEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) {
+  bool flag = false;
+  factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true);
+  EXPECT_DEATH(flag = true, "");
+  EXPECT_FALSE(flag);
+  EXPECT_EQ(1, factory_->AssumeRoleCalls());
+  EXPECT_EQ(1, factory_->WaitCalls());
+  ASSERT_EQ(1, factory_->PassedCalls());
+  EXPECT_FALSE(factory_->PassedArgument(0));
+  EXPECT_EQ(0, factory_->AbortCalls());
+  EXPECT_TRUE(factory_->TestDeleted());
+}
+
+// Tests that the Passed method was given the argument "true" when
+// the (simulated) child process exits with status 1:
+TEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) {
+  bool flag = false;
+  factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true);
+  EXPECT_DEATH(flag = true, "");
+  EXPECT_FALSE(flag);
+  EXPECT_EQ(1, factory_->AssumeRoleCalls());
+  EXPECT_EQ(1, factory_->WaitCalls());
+  ASSERT_EQ(1, factory_->PassedCalls());
+  EXPECT_TRUE(factory_->PassedArgument(0));
+  EXPECT_EQ(0, factory_->AbortCalls());
+  EXPECT_TRUE(factory_->TestDeleted());
+}
+
+// Tests that the (simulated) child process executes the death test
+// code, and is aborted with the correct AbortReason if it
+// executes a return statement.
+TEST_F(MacroLogicDeathTest, ChildPerformsReturn) {
+  bool flag = false;
+  factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
+  RunReturningDeathTest(&flag);
+  EXPECT_TRUE(flag);
+  EXPECT_EQ(1, factory_->AssumeRoleCalls());
+  EXPECT_EQ(0, factory_->WaitCalls());
+  EXPECT_EQ(0, factory_->PassedCalls());
+  EXPECT_EQ(1, factory_->AbortCalls());
+  EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
+            factory_->AbortArgument(0));
+  EXPECT_TRUE(factory_->TestDeleted());
+}
+
+// Tests that the (simulated) child process is aborted with the
+// correct AbortReason if it does not die.
+TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
+  bool flag = false;
+  factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
+  EXPECT_DEATH(flag = true, "");
+  EXPECT_TRUE(flag);
+  EXPECT_EQ(1, factory_->AssumeRoleCalls());
+  EXPECT_EQ(0, factory_->WaitCalls());
+  EXPECT_EQ(0, factory_->PassedCalls());
+  // This time there are two calls to Abort: one since the test didn't
+  // die, and another from the ReturnSentinel when it's destroyed.  The
+  // sentinel normally isn't destroyed if a test doesn't die, since
+  // _exit(2) is called in that case by ForkingDeathTest, but not by
+  // our MockDeathTest.
+  ASSERT_EQ(2, factory_->AbortCalls());
+  EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE,
+            factory_->AbortArgument(0));
+  EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
+            factory_->AbortArgument(1));
+  EXPECT_TRUE(factory_->TestDeleted());
+}
+
+// Tests that a successful death test does not register a successful
+// test part.
+TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
+  EXPECT_DEATH(_exit(1), "");
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+TEST(StreamingAssertionsDeathTest, DeathTest) {
+  EXPECT_DEATH(_exit(1), "") << "unexpected failure";
+  ASSERT_DEATH(_exit(1), "") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_DEATH(_exit(0), "") << "expected failure";
+  }, "expected failure");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_DEATH(_exit(0), "") << "expected failure";
+  }, "expected failure");
+}
+
+// Tests that GetLastErrnoDescription returns an empty string when the
+// last error is 0 and non-empty string when it is non-zero.
+TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
+  errno = ENOENT;
+  EXPECT_STRNE("", GetLastErrnoDescription().c_str());
+  errno = 0;
+  EXPECT_STREQ("", GetLastErrnoDescription().c_str());
+}
+
+#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(123U, result);
+
+  // Check 0 as an edge case.
+  result = 1;
+  ASSERT_TRUE(ParseNaturalNumber(String("0"), &result));
+  EXPECT_EQ(0U, result);
+
+  result = 1;
+  ASSERT_TRUE(ParseNaturalNumber(String("00000"), &result));
+  EXPECT_EQ(0U, 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([email protected]): 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
+
+// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger
+// failures when death tests are available on the system.
+TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {
+  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(false) << "failure", "false.*failure");
+  ASSERT_DEATH_IF_SUPPORTED(GTEST_CHECK_(false) << "failure", "false.*failure");
+
+  // Empty statement will not crash, which must trigger a failure.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), "");
+  EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), "");
+}
+
+#else
+
+using testing::internal::CaptureStderr;
+using testing::internal::GetCapturedStderr;
+using testing::internal::String;
+
+// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still
+// defined but do not trigger failures when death tests are not available on
+// the system.
+TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {
+  // Empty statement will not crash, but that should not trigger a failure
+  // when death tests are not supported.
+  CaptureStderr();
+  EXPECT_DEATH_IF_SUPPORTED(;, "");
+  String output = GetCapturedStderr();
+  ASSERT_TRUE(NULL != strstr(output.c_str(),
+                             "Death tests are not supported on this platform"));
+  ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
+
+  // The streamed message should not be printed as there is no test failure.
+  CaptureStderr();
+  EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message";
+  output = GetCapturedStderr();
+  ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
+
+  CaptureStderr();
+  ASSERT_DEATH_IF_SUPPORTED(;, "");  // NOLINT
+  output = GetCapturedStderr();
+  ASSERT_TRUE(NULL != strstr(output.c_str(),
+                             "Death tests are not supported on this platform"));
+  ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
+
+  CaptureStderr();
+  ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message";  // NOLINT
+  output = GetCapturedStderr();
+  ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
+}
+
+void FuncWithAssert(int* n) {
+  ASSERT_DEATH_IF_SUPPORTED(return;, "");
+  (*n)++;
+}
+
+// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current
+// function (as ASSERT_DEATH does) if death tests are not supported.
+TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {
+  int n = 0;
+  FuncWithAssert(&n);
+  EXPECT_EQ(1, n);
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// 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.
+//
+// The syntax should work whether death tests are available or not.
+TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
+  if (AlwaysFalse())
+    // This would fail if executed; this is a compilation test only
+    ASSERT_DEATH_IF_SUPPORTED(return, "");
+
+  if (AlwaysTrue())
+    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "");
+  else
+    // This empty "else" branch is meant to ensure that EXPECT_DEATH
+    // doesn't expand into an "if" statement without an "else"
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die";
+
+  if (AlwaysFalse())
+    ;  // NOLINT
+  else
+    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3;
+}
+
+// Tests that conditional death test macros expand to code which interacts
+// well with switch statements.
+TEST(ConditionalDeathMacrosSyntaxDeathTest, 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_IF_SUPPORTED(_exit(1), "")
+          << "exit in default switch handler";
+
+  switch (0)
+    case 0:
+      EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
+}
+
+// Tests that a test case whose name ends with "DeathTest" works fine
+// on Windows.
+TEST(NotADeathTest, Test) {
+  SUCCEED();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-filepath_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-filepath_test.cc
index d4e80e87..5bc4daf2 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-filepath_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-filepath_test.cc
@@ -1,588 +1,588 @@
-// Copyright 2008, 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.

-//

-// Authors: [email protected] (Keith Ray)

-//

-// Google Test filepath utilities

-//

-// This file tests classes and functions used internally by

-// Google Test.  They are subject to change without notice.

-//

-// This file is #included from gtest_unittest.cc, to avoid changing

-// build or make-files for some existing Google Test clients. Do not

-// #include this file anywhere else!

-

-#include <gtest/internal/gtest-filepath.h>

-#include <gtest/gtest.h>

-

-// 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_

-

-#if GTEST_OS_WINDOWS_MOBILE

-#include <windows.h>  // NOLINT

-#elif GTEST_OS_WINDOWS

-#include <direct.h>  // NOLINT

-#endif  // GTEST_OS_WINDOWS_MOBILE

-

-namespace testing {

-namespace internal {

-namespace {

-

-#if GTEST_OS_WINDOWS_MOBILE

-// TODO([email protected]): Move these to the POSIX adapter section in

-// gtest-port.h.

-

-// Windows CE doesn't have the remove C function.

-int remove(const char* path) {

-  LPCWSTR wpath = String::AnsiToUtf16(path);

-  int ret = DeleteFile(wpath) ? 0 : -1;

-  delete [] wpath;

-  return ret;

-}

-// Windows CE doesn't have the _rmdir C function.

-int _rmdir(const char* path) {

-  FilePath filepath(path);

-  LPCWSTR wpath = String::AnsiToUtf16(

-      filepath.RemoveTrailingPathSeparator().c_str());

-  int ret = RemoveDirectory(wpath) ? 0 : -1;

-  delete [] wpath;

-  return ret;

-}

-

-#else

-

-TEST(GetCurrentDirTest, ReturnsCurrentDir) {

-  const FilePath original_dir = FilePath::GetCurrentDir();

-  EXPECT_FALSE(original_dir.IsEmpty());

-

-  posix::ChDir(GTEST_PATH_SEP_);

-  const FilePath cwd = FilePath::GetCurrentDir();

-  posix::ChDir(original_dir.c_str());

-

-#if GTEST_OS_WINDOWS

-  // Skips the ":".

-  const char* const cwd_without_drive = strchr(cwd.c_str(), ':');

-  ASSERT_TRUE(cwd_without_drive != NULL);

-  EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);

-#else

-  EXPECT_STREQ(GTEST_PATH_SEP_, cwd.c_str());

-#endif

-}

-

-#endif  // GTEST_OS_WINDOWS_MOBILE

-

-TEST(IsEmptyTest, ReturnsTrueForEmptyPath) {

-  EXPECT_TRUE(FilePath("").IsEmpty());

-  EXPECT_TRUE(FilePath(NULL).IsEmpty());

-}

-

-TEST(IsEmptyTest, ReturnsFalseForNonEmptyPath) {

-  EXPECT_FALSE(FilePath("a").IsEmpty());

-  EXPECT_FALSE(FilePath(".").IsEmpty());

-  EXPECT_FALSE(FilePath("a/b").IsEmpty());

-  EXPECT_FALSE(FilePath("a\\b\\").IsEmpty());

-}

-

-// RemoveDirectoryName "" -> ""

-TEST(RemoveDirectoryNameTest, WhenEmptyName) {

-  EXPECT_STREQ("", FilePath("").RemoveDirectoryName().c_str());

-}

-

-// RemoveDirectoryName "afile" -> "afile"

-TEST(RemoveDirectoryNameTest, ButNoDirectory) {

-  EXPECT_STREQ("afile",

-      FilePath("afile").RemoveDirectoryName().c_str());

-}

-

-// RemoveDirectoryName "/afile" -> "afile"

-TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {

-  EXPECT_STREQ("afile",

-      FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());

-}

-

-// RemoveDirectoryName "adir/" -> ""

-TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {

-  EXPECT_STREQ("",

-      FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().c_str());

-}

-

-// RemoveDirectoryName "adir/afile" -> "afile"

-TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {

-  EXPECT_STREQ("afile",

-      FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());

-}

-

-// RemoveDirectoryName "adir/subdir/afile" -> "afile"

-TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {

-  EXPECT_STREQ("afile",

-      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")

-      .RemoveDirectoryName().c_str());

-}

-

-

-// RemoveFileName "" -> "./"

-TEST(RemoveFileNameTest, EmptyName) {

-#if GTEST_OS_WINDOWS_MOBILE

-  // On Windows CE, we use the root as the current directory.

-  EXPECT_STREQ(GTEST_PATH_SEP_,

-      FilePath("").RemoveFileName().c_str());

-#else

-  EXPECT_STREQ("." GTEST_PATH_SEP_,

-      FilePath("").RemoveFileName().c_str());

-#endif

-}

-

-// RemoveFileName "adir/" -> "adir/"

-TEST(RemoveFileNameTest, ButNoFile) {

-  EXPECT_STREQ("adir" GTEST_PATH_SEP_,

-      FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().c_str());

-}

-

-// RemoveFileName "adir/afile" -> "adir/"

-TEST(RemoveFileNameTest, GivesDirName) {

-  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" 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(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" GTEST_PATH_SEP_ "bar.xml", actual.c_str());

-}

-

-TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {

-  FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),

-      12, "xml");

-  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());

-}

-

-TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {

-  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),

-      FilePath("bar"), 0, "xml");

-  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());

-}

-

-TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {

-  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),

-      FilePath("bar"), 12, "xml");

-  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());

-}

-

-TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {

-  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),

-      0, "xml");

-  EXPECT_STREQ("bar.xml", actual.c_str());

-}

-

-TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {

-  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),

-      14, "xml");

-  EXPECT_STREQ("bar_14.xml", actual.c_str());

-}

-

-TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {

-  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),

-                                          FilePath("bar.xml"));

-  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());

-}

-

-TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {

-  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),

-                                          FilePath("bar.xml"));

-  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());

-}

-

-TEST(ConcatPathsTest, Path1BeingEmpty) {

-  FilePath actual = FilePath::ConcatPaths(FilePath(""),

-                                          FilePath("bar.xml"));

-  EXPECT_STREQ("bar.xml", actual.c_str());

-}

-

-TEST(ConcatPathsTest, Path2BeingEmpty) {

-  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),

-                                          FilePath(""));

-  EXPECT_STREQ("foo" GTEST_PATH_SEP_, actual.c_str());

-}

-

-TEST(ConcatPathsTest, BothPathBeingEmpty) {

-  FilePath actual = FilePath::ConcatPaths(FilePath(""),

-                                          FilePath(""));

-  EXPECT_STREQ("", actual.c_str());

-}

-

-TEST(ConcatPathsTest, Path1ContainsPathSep) {

-  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_ "bar"),

-                                          FilePath("foobar.xml"));

-  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "foobar.xml",

-               actual.c_str());

-}

-

-TEST(ConcatPathsTest, Path2ContainsPathSep) {

-  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" GTEST_PATH_SEP_));

-  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.c_str());

-}

-

-// RemoveTrailingPathSeparator "" -> ""

-TEST(RemoveTrailingPathSeparatorTest, EmptyString) {

-  EXPECT_STREQ("",

-      FilePath("").RemoveTrailingPathSeparator().c_str());

-}

-

-// RemoveTrailingPathSeparator "foo" -> "foo"

-TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {

-  EXPECT_STREQ("foo",

-      FilePath("foo").RemoveTrailingPathSeparator().c_str());

-}

-

-// RemoveTrailingPathSeparator "foo/" -> "foo"

-TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {

-  EXPECT_STREQ(

-      "foo",

-      FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().c_str());

-}

-

-// RemoveTrailingPathSeparator "foo/bar/" -> "foo/bar/"

-TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {

-  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" GTEST_PATH_SEP_ "bar",

-               FilePath("foo" GTEST_PATH_SEP_ "bar")

-               .RemoveTrailingPathSeparator().c_str());

-}

-

-TEST(DirectoryTest, RootDirectoryExists) {

-#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] = ':';

-  current_drive[2] = '\\';

-  current_drive[3] = '\0';

-  EXPECT_TRUE(FilePath(current_drive).DirectoryExists());

-#else

-  EXPECT_TRUE(FilePath("/").DirectoryExists());

-#endif  // 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.

-  for (char drive = 'Z'; drive >= 'A'; drive--)

-    if (_chdrive(drive - 'A' + 1) == -1) {

-      char non_drive[_MAX_PATH];  // NOLINT

-      non_drive[0] = drive;

-      non_drive[1] = ':';

-      non_drive[2] = '\\';

-      non_drive[3] = '\0';

-      EXPECT_FALSE(FilePath(non_drive).DirectoryExists());

-      break;

-    }

-  _chdrive(saved_drive_);

-}

-#endif  // GTEST_OS_WINDOWS

-

-#if !GTEST_OS_WINDOWS_MOBILE

-// Windows CE _does_ consider an empty directory to exist.

-TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {

-  EXPECT_FALSE(FilePath("").DirectoryExists());

-}

-#endif  // !GTEST_OS_WINDOWS_MOBILE

-

-TEST(DirectoryTest, CurrentDirectoryExists) {

-#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());

-#endif  // _WIN32_CE

-#else

-  EXPECT_TRUE(FilePath(".").DirectoryExists());

-  EXPECT_TRUE(FilePath("./").DirectoryExists());

-#endif  // GTEST_OS_WINDOWS

-}

-

-TEST(NormalizeTest, NullStringsEqualEmptyDirectory) {

-  EXPECT_STREQ("", FilePath(NULL).c_str());

-  EXPECT_STREQ("", FilePath(String(NULL)).c_str());

-}

-

-// "foo/bar" == foo//bar" == "foo///bar"

-TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {

-  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(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" 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) {

-  FilePath default_path;

-  FilePath non_default_path("path");

-  non_default_path = default_path;

-  EXPECT_STREQ("", non_default_path.c_str());

-  EXPECT_STREQ("", default_path.c_str());  // RHS var is unchanged.

-}

-

-TEST(AssignmentOperatorTest, NonDefaultAssignedToDefault) {

-  FilePath non_default_path("path");

-  FilePath default_path;

-  default_path = non_default_path;

-  EXPECT_STREQ("path", default_path.c_str());

-  EXPECT_STREQ("path", non_default_path.c_str());  // RHS var is unchanged.

-}

-

-TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {

-  const FilePath const_default_path("const_path");

-  FilePath non_default_path("path");

-  non_default_path = const_default_path;

-  EXPECT_STREQ("const_path", non_default_path.c_str());

-}

-

-class DirectoryCreationTest : public Test {

- protected:

-  virtual void SetUp() {

-    testdata_path_.Set(FilePath(String::Format("%s%s%s",

-        TempDir().c_str(), GetCurrentExecutableName().c_str(),

-        "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_)));

-    testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());

-

-    unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),

-        0, "txt"));

-    unique_file1_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),

-        1, "txt"));

-

-    remove(testdata_file_.c_str());

-    remove(unique_file0_.c_str());

-    remove(unique_file1_.c_str());

-    posix::RmDir(testdata_path_.c_str());

-  }

-

-  virtual void TearDown() {

-    remove(testdata_file_.c_str());

-    remove(unique_file0_.c_str());

-    remove(unique_file1_.c_str());

-    posix::RmDir(testdata_path_.c_str());

-  }

-

-  String TempDir() const {

-#if GTEST_OS_WINDOWS_MOBILE

-    return String("\\temp\\");

-#elif GTEST_OS_WINDOWS

-    const char* temp_dir = posix::GetEnv("TEMP");

-    if (temp_dir == NULL || temp_dir[0] == '\0')

-      return String("\\temp\\");

-    else if (String(temp_dir).EndsWith("\\"))

-      return String(temp_dir);

-    else

-      return String::Format("%s\\", temp_dir);

-#else

-    return String("/tmp/");

-#endif  // GTEST_OS_WINDOWS_MOBILE

-  }

-

-  void CreateTextFile(const char* filename) {

-    FILE* f = posix::FOpen(filename, "w");

-    fprintf(f, "text\n");

-    fclose(f);

-  }

-

-  // Strings representing a directory and a file, with identical paths

-  // except for the trailing separator character that distinquishes

-  // a directory named 'test' from a file named 'test'. Example names:

-  FilePath testdata_path_;  // "/tmp/directory_creation/test/"

-  FilePath testdata_file_;  // "/tmp/directory_creation/test"

-  FilePath unique_file0_;  // "/tmp/directory_creation/test/unique.txt"

-  FilePath unique_file1_;  // "/tmp/directory_creation/test/unique_1.txt"

-};

-

-TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {

-  EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.c_str();

-  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());

-  EXPECT_TRUE(testdata_path_.DirectoryExists());

-}

-

-TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPath) {

-  EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.c_str();

-  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());

-  // Call 'create' again... should still succeed.

-  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());

-}

-

-TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {

-  FilePath file_path(FilePath::GenerateUniqueFileName(testdata_path_,

-      FilePath("unique"), "txt"));

-  EXPECT_STREQ(unique_file0_.c_str(), file_path.c_str());

-  EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file not there

-

-  testdata_path_.CreateDirectoriesRecursively();

-  EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file still not there

-  CreateTextFile(file_path.c_str());

-  EXPECT_TRUE(file_path.FileOrDirectoryExists());

-

-  FilePath file_path2(FilePath::GenerateUniqueFileName(testdata_path_,

-      FilePath("unique"), "txt"));

-  EXPECT_STREQ(unique_file1_.c_str(), file_path2.c_str());

-  EXPECT_FALSE(file_path2.FileOrDirectoryExists());  // file not there

-  CreateTextFile(file_path2.c_str());

-  EXPECT_TRUE(file_path2.FileOrDirectoryExists());

-}

-

-TEST_F(DirectoryCreationTest, CreateDirectoriesFail) {

-  // force a failure by putting a file where we will try to create a directory.

-  CreateTextFile(testdata_file_.c_str());

-  EXPECT_TRUE(testdata_file_.FileOrDirectoryExists());

-  EXPECT_FALSE(testdata_file_.DirectoryExists());

-  EXPECT_FALSE(testdata_file_.CreateDirectoriesRecursively());

-}

-

-TEST(NoDirectoryCreationTest, CreateNoDirectoriesForDefaultXmlFile) {

-  const FilePath test_detail_xml("test_detail.xml");

-  EXPECT_FALSE(test_detail_xml.CreateDirectoriesRecursively());

-}

-

-TEST(FilePathTest, DefaultConstructor) {

-  FilePath fp;

-  EXPECT_STREQ("", fp.c_str());

-}

-

-TEST(FilePathTest, CharAndCopyConstructors) {

-  const FilePath fp("spicy");

-  EXPECT_STREQ("spicy", fp.c_str());

-

-  const FilePath fp_copy(fp);

-  EXPECT_STREQ("spicy", fp_copy.c_str());

-}

-

-TEST(FilePathTest, StringConstructor) {

-  const FilePath fp(String("cider"));

-  EXPECT_STREQ("cider", fp.c_str());

-}

-

-TEST(FilePathTest, Set) {

-  const FilePath apple("apple");

-  FilePath mac("mac");

-  mac.Set(apple);  // Implement Set() since overloading operator= is forbidden.

-  EXPECT_STREQ("apple", mac.c_str());

-  EXPECT_STREQ("apple", apple.c_str());

-}

-

-TEST(FilePathTest, ToString) {

-  const FilePath file("drink");

-  String str(file.ToString());

-  EXPECT_STREQ("drink", str.c_str());

-}

-

-TEST(FilePathTest, RemoveExtension) {

-  EXPECT_STREQ("app", FilePath("app.exe").RemoveExtension("exe").c_str());

-  EXPECT_STREQ("APP", FilePath("APP.EXE").RemoveExtension("exe").c_str());

-}

-

-TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {

-  EXPECT_STREQ("app", FilePath("app").RemoveExtension("exe").c_str());

-}

-

-TEST(FilePathTest, IsDirectory) {

-  EXPECT_FALSE(FilePath("cola").IsDirectory());

-  EXPECT_TRUE(FilePath("koala" GTEST_PATH_SEP_).IsDirectory());

-}

-

-TEST(FilePathTest, IsAbsolutePath) {

-  EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());

-  EXPECT_FALSE(FilePath("").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(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")

-              .IsAbsolutePath());

-#endif  // GTEST_OS_WINDOWS

-}

-

-}  // namespace

-}  // namespace internal

-}  // namespace testing

-

-#undef GTEST_PATH_SEP_

+// Copyright 2008, 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.
+//
+// Authors: [email protected] (Keith Ray)
+//
+// Google Test filepath utilities
+//
+// This file tests classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included from gtest_unittest.cc, to avoid changing
+// build or make-files for some existing Google Test clients. Do not
+// #include this file anywhere else!
+
+#include <gtest/internal/gtest-filepath.h>
+#include <gtest/gtest.h>
+
+// 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_
+
+#if GTEST_OS_WINDOWS_MOBILE
+#include <windows.h>  // NOLINT
+#elif GTEST_OS_WINDOWS
+#include <direct.h>  // NOLINT
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+namespace testing {
+namespace internal {
+namespace {
+
+#if GTEST_OS_WINDOWS_MOBILE
+// TODO([email protected]): Move these to the POSIX adapter section in
+// gtest-port.h.
+
+// Windows CE doesn't have the remove C function.
+int remove(const char* path) {
+  LPCWSTR wpath = String::AnsiToUtf16(path);
+  int ret = DeleteFile(wpath) ? 0 : -1;
+  delete [] wpath;
+  return ret;
+}
+// Windows CE doesn't have the _rmdir C function.
+int _rmdir(const char* path) {
+  FilePath filepath(path);
+  LPCWSTR wpath = String::AnsiToUtf16(
+      filepath.RemoveTrailingPathSeparator().c_str());
+  int ret = RemoveDirectory(wpath) ? 0 : -1;
+  delete [] wpath;
+  return ret;
+}
+
+#else
+
+TEST(GetCurrentDirTest, ReturnsCurrentDir) {
+  const FilePath original_dir = FilePath::GetCurrentDir();
+  EXPECT_FALSE(original_dir.IsEmpty());
+
+  posix::ChDir(GTEST_PATH_SEP_);
+  const FilePath cwd = FilePath::GetCurrentDir();
+  posix::ChDir(original_dir.c_str());
+
+#if GTEST_OS_WINDOWS
+  // Skips the ":".
+  const char* const cwd_without_drive = strchr(cwd.c_str(), ':');
+  ASSERT_TRUE(cwd_without_drive != NULL);
+  EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);
+#else
+  EXPECT_STREQ(GTEST_PATH_SEP_, cwd.c_str());
+#endif
+}
+
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+TEST(IsEmptyTest, ReturnsTrueForEmptyPath) {
+  EXPECT_TRUE(FilePath("").IsEmpty());
+  EXPECT_TRUE(FilePath(NULL).IsEmpty());
+}
+
+TEST(IsEmptyTest, ReturnsFalseForNonEmptyPath) {
+  EXPECT_FALSE(FilePath("a").IsEmpty());
+  EXPECT_FALSE(FilePath(".").IsEmpty());
+  EXPECT_FALSE(FilePath("a/b").IsEmpty());
+  EXPECT_FALSE(FilePath("a\\b\\").IsEmpty());
+}
+
+// RemoveDirectoryName "" -> ""
+TEST(RemoveDirectoryNameTest, WhenEmptyName) {
+  EXPECT_STREQ("", FilePath("").RemoveDirectoryName().c_str());
+}
+
+// RemoveDirectoryName "afile" -> "afile"
+TEST(RemoveDirectoryNameTest, ButNoDirectory) {
+  EXPECT_STREQ("afile",
+      FilePath("afile").RemoveDirectoryName().c_str());
+}
+
+// RemoveDirectoryName "/afile" -> "afile"
+TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {
+  EXPECT_STREQ("afile",
+      FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());
+}
+
+// RemoveDirectoryName "adir/" -> ""
+TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {
+  EXPECT_STREQ("",
+      FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().c_str());
+}
+
+// RemoveDirectoryName "adir/afile" -> "afile"
+TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {
+  EXPECT_STREQ("afile",
+      FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());
+}
+
+// RemoveDirectoryName "adir/subdir/afile" -> "afile"
+TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
+  EXPECT_STREQ("afile",
+      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
+      .RemoveDirectoryName().c_str());
+}
+
+
+// RemoveFileName "" -> "./"
+TEST(RemoveFileNameTest, EmptyName) {
+#if GTEST_OS_WINDOWS_MOBILE
+  // On Windows CE, we use the root as the current directory.
+  EXPECT_STREQ(GTEST_PATH_SEP_,
+      FilePath("").RemoveFileName().c_str());
+#else
+  EXPECT_STREQ("." GTEST_PATH_SEP_,
+      FilePath("").RemoveFileName().c_str());
+#endif
+}
+
+// RemoveFileName "adir/" -> "adir/"
+TEST(RemoveFileNameTest, ButNoFile) {
+  EXPECT_STREQ("adir" GTEST_PATH_SEP_,
+      FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().c_str());
+}
+
+// RemoveFileName "adir/afile" -> "adir/"
+TEST(RemoveFileNameTest, GivesDirName) {
+  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" 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(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" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
+}
+
+TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {
+  FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
+      12, "xml");
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());
+}
+
+TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {
+  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
+      FilePath("bar"), 0, "xml");
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
+}
+
+TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {
+  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
+      FilePath("bar"), 12, "xml");
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());
+}
+
+TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {
+  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
+      0, "xml");
+  EXPECT_STREQ("bar.xml", actual.c_str());
+}
+
+TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {
+  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
+      14, "xml");
+  EXPECT_STREQ("bar_14.xml", actual.c_str());
+}
+
+TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
+                                          FilePath("bar.xml"));
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
+}
+
+TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),
+                                          FilePath("bar.xml"));
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());
+}
+
+TEST(ConcatPathsTest, Path1BeingEmpty) {
+  FilePath actual = FilePath::ConcatPaths(FilePath(""),
+                                          FilePath("bar.xml"));
+  EXPECT_STREQ("bar.xml", actual.c_str());
+}
+
+TEST(ConcatPathsTest, Path2BeingEmpty) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
+                                          FilePath(""));
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_, actual.c_str());
+}
+
+TEST(ConcatPathsTest, BothPathBeingEmpty) {
+  FilePath actual = FilePath::ConcatPaths(FilePath(""),
+                                          FilePath(""));
+  EXPECT_STREQ("", actual.c_str());
+}
+
+TEST(ConcatPathsTest, Path1ContainsPathSep) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_ "bar"),
+                                          FilePath("foobar.xml"));
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "foobar.xml",
+               actual.c_str());
+}
+
+TEST(ConcatPathsTest, Path2ContainsPathSep) {
+  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" GTEST_PATH_SEP_));
+  EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.c_str());
+}
+
+// RemoveTrailingPathSeparator "" -> ""
+TEST(RemoveTrailingPathSeparatorTest, EmptyString) {
+  EXPECT_STREQ("",
+      FilePath("").RemoveTrailingPathSeparator().c_str());
+}
+
+// RemoveTrailingPathSeparator "foo" -> "foo"
+TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {
+  EXPECT_STREQ("foo",
+      FilePath("foo").RemoveTrailingPathSeparator().c_str());
+}
+
+// RemoveTrailingPathSeparator "foo/" -> "foo"
+TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
+  EXPECT_STREQ(
+      "foo",
+      FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().c_str());
+}
+
+// RemoveTrailingPathSeparator "foo/bar/" -> "foo/bar/"
+TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {
+  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" GTEST_PATH_SEP_ "bar",
+               FilePath("foo" GTEST_PATH_SEP_ "bar")
+               .RemoveTrailingPathSeparator().c_str());
+}
+
+TEST(DirectoryTest, RootDirectoryExists) {
+#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] = ':';
+  current_drive[2] = '\\';
+  current_drive[3] = '\0';
+  EXPECT_TRUE(FilePath(current_drive).DirectoryExists());
+#else
+  EXPECT_TRUE(FilePath("/").DirectoryExists());
+#endif  // 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.
+  for (char drive = 'Z'; drive >= 'A'; drive--)
+    if (_chdrive(drive - 'A' + 1) == -1) {
+      char non_drive[_MAX_PATH];  // NOLINT
+      non_drive[0] = drive;
+      non_drive[1] = ':';
+      non_drive[2] = '\\';
+      non_drive[3] = '\0';
+      EXPECT_FALSE(FilePath(non_drive).DirectoryExists());
+      break;
+    }
+  _chdrive(saved_drive_);
+}
+#endif  // GTEST_OS_WINDOWS
+
+#if !GTEST_OS_WINDOWS_MOBILE
+// Windows CE _does_ consider an empty directory to exist.
+TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
+  EXPECT_FALSE(FilePath("").DirectoryExists());
+}
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+TEST(DirectoryTest, CurrentDirectoryExists) {
+#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());
+#endif  // _WIN32_CE
+#else
+  EXPECT_TRUE(FilePath(".").DirectoryExists());
+  EXPECT_TRUE(FilePath("./").DirectoryExists());
+#endif  // GTEST_OS_WINDOWS
+}
+
+TEST(NormalizeTest, NullStringsEqualEmptyDirectory) {
+  EXPECT_STREQ("", FilePath(NULL).c_str());
+  EXPECT_STREQ("", FilePath(String(NULL)).c_str());
+}
+
+// "foo/bar" == foo//bar" == "foo///bar"
+TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {
+  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(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" 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) {
+  FilePath default_path;
+  FilePath non_default_path("path");
+  non_default_path = default_path;
+  EXPECT_STREQ("", non_default_path.c_str());
+  EXPECT_STREQ("", default_path.c_str());  // RHS var is unchanged.
+}
+
+TEST(AssignmentOperatorTest, NonDefaultAssignedToDefault) {
+  FilePath non_default_path("path");
+  FilePath default_path;
+  default_path = non_default_path;
+  EXPECT_STREQ("path", default_path.c_str());
+  EXPECT_STREQ("path", non_default_path.c_str());  // RHS var is unchanged.
+}
+
+TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {
+  const FilePath const_default_path("const_path");
+  FilePath non_default_path("path");
+  non_default_path = const_default_path;
+  EXPECT_STREQ("const_path", non_default_path.c_str());
+}
+
+class DirectoryCreationTest : public Test {
+ protected:
+  virtual void SetUp() {
+    testdata_path_.Set(FilePath(String::Format("%s%s%s",
+        TempDir().c_str(), GetCurrentExecutableName().c_str(),
+        "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_)));
+    testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());
+
+    unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
+        0, "txt"));
+    unique_file1_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
+        1, "txt"));
+
+    remove(testdata_file_.c_str());
+    remove(unique_file0_.c_str());
+    remove(unique_file1_.c_str());
+    posix::RmDir(testdata_path_.c_str());
+  }
+
+  virtual void TearDown() {
+    remove(testdata_file_.c_str());
+    remove(unique_file0_.c_str());
+    remove(unique_file1_.c_str());
+    posix::RmDir(testdata_path_.c_str());
+  }
+
+  String TempDir() const {
+#if GTEST_OS_WINDOWS_MOBILE
+    return String("\\temp\\");
+#elif GTEST_OS_WINDOWS
+    const char* temp_dir = posix::GetEnv("TEMP");
+    if (temp_dir == NULL || temp_dir[0] == '\0')
+      return String("\\temp\\");
+    else if (String(temp_dir).EndsWith("\\"))
+      return String(temp_dir);
+    else
+      return String::Format("%s\\", temp_dir);
+#else
+    return String("/tmp/");
+#endif  // GTEST_OS_WINDOWS_MOBILE
+  }
+
+  void CreateTextFile(const char* filename) {
+    FILE* f = posix::FOpen(filename, "w");
+    fprintf(f, "text\n");
+    fclose(f);
+  }
+
+  // Strings representing a directory and a file, with identical paths
+  // except for the trailing separator character that distinquishes
+  // a directory named 'test' from a file named 'test'. Example names:
+  FilePath testdata_path_;  // "/tmp/directory_creation/test/"
+  FilePath testdata_file_;  // "/tmp/directory_creation/test"
+  FilePath unique_file0_;  // "/tmp/directory_creation/test/unique.txt"
+  FilePath unique_file1_;  // "/tmp/directory_creation/test/unique_1.txt"
+};
+
+TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {
+  EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.c_str();
+  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
+  EXPECT_TRUE(testdata_path_.DirectoryExists());
+}
+
+TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPath) {
+  EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.c_str();
+  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
+  // Call 'create' again... should still succeed.
+  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
+}
+
+TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {
+  FilePath file_path(FilePath::GenerateUniqueFileName(testdata_path_,
+      FilePath("unique"), "txt"));
+  EXPECT_STREQ(unique_file0_.c_str(), file_path.c_str());
+  EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file not there
+
+  testdata_path_.CreateDirectoriesRecursively();
+  EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file still not there
+  CreateTextFile(file_path.c_str());
+  EXPECT_TRUE(file_path.FileOrDirectoryExists());
+
+  FilePath file_path2(FilePath::GenerateUniqueFileName(testdata_path_,
+      FilePath("unique"), "txt"));
+  EXPECT_STREQ(unique_file1_.c_str(), file_path2.c_str());
+  EXPECT_FALSE(file_path2.FileOrDirectoryExists());  // file not there
+  CreateTextFile(file_path2.c_str());
+  EXPECT_TRUE(file_path2.FileOrDirectoryExists());
+}
+
+TEST_F(DirectoryCreationTest, CreateDirectoriesFail) {
+  // force a failure by putting a file where we will try to create a directory.
+  CreateTextFile(testdata_file_.c_str());
+  EXPECT_TRUE(testdata_file_.FileOrDirectoryExists());
+  EXPECT_FALSE(testdata_file_.DirectoryExists());
+  EXPECT_FALSE(testdata_file_.CreateDirectoriesRecursively());
+}
+
+TEST(NoDirectoryCreationTest, CreateNoDirectoriesForDefaultXmlFile) {
+  const FilePath test_detail_xml("test_detail.xml");
+  EXPECT_FALSE(test_detail_xml.CreateDirectoriesRecursively());
+}
+
+TEST(FilePathTest, DefaultConstructor) {
+  FilePath fp;
+  EXPECT_STREQ("", fp.c_str());
+}
+
+TEST(FilePathTest, CharAndCopyConstructors) {
+  const FilePath fp("spicy");
+  EXPECT_STREQ("spicy", fp.c_str());
+
+  const FilePath fp_copy(fp);
+  EXPECT_STREQ("spicy", fp_copy.c_str());
+}
+
+TEST(FilePathTest, StringConstructor) {
+  const FilePath fp(String("cider"));
+  EXPECT_STREQ("cider", fp.c_str());
+}
+
+TEST(FilePathTest, Set) {
+  const FilePath apple("apple");
+  FilePath mac("mac");
+  mac.Set(apple);  // Implement Set() since overloading operator= is forbidden.
+  EXPECT_STREQ("apple", mac.c_str());
+  EXPECT_STREQ("apple", apple.c_str());
+}
+
+TEST(FilePathTest, ToString) {
+  const FilePath file("drink");
+  String str(file.ToString());
+  EXPECT_STREQ("drink", str.c_str());
+}
+
+TEST(FilePathTest, RemoveExtension) {
+  EXPECT_STREQ("app", FilePath("app.exe").RemoveExtension("exe").c_str());
+  EXPECT_STREQ("APP", FilePath("APP.EXE").RemoveExtension("exe").c_str());
+}
+
+TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {
+  EXPECT_STREQ("app", FilePath("app").RemoveExtension("exe").c_str());
+}
+
+TEST(FilePathTest, IsDirectory) {
+  EXPECT_FALSE(FilePath("cola").IsDirectory());
+  EXPECT_TRUE(FilePath("koala" GTEST_PATH_SEP_).IsDirectory());
+}
+
+TEST(FilePathTest, IsAbsolutePath) {
+  EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());
+  EXPECT_FALSE(FilePath("").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(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
+              .IsAbsolutePath());
+#endif  // GTEST_OS_WINDOWS
+}
+
+}  // namespace
+}  // namespace internal
+}  // namespace testing
+
+#undef GTEST_PATH_SEP_
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-linked_ptr_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-linked_ptr_test.cc
index a81519e6..eae82296 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-linked_ptr_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-linked_ptr_test.cc
@@ -1,154 +1,154 @@
-// Copyright 2003, 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.

-//

-// Authors: Dan Egnor ([email protected])

-// Ported to Windows: Vadim Berman ([email protected])

-

-#include <gtest/internal/gtest-linked_ptr.h>

-

-#include <stdlib.h>

-#include <gtest/gtest.h>

-

-namespace {

-

-using testing::Message;

-using testing::internal::linked_ptr;

-

-int num;

-Message* history = NULL;

-

-// Class which tracks allocation/deallocation

-class A {

- public:

-  A(): mynum(num++) { *history << "A" << mynum << " ctor\n"; }

-  virtual ~A() { *history << "A" << mynum << " dtor\n"; }

-  virtual void Use() { *history << "A" << mynum << " use\n"; }

- protected:

-  int mynum;

-};

-

-// Subclass

-class B : public A {

- public:

-  B() { *history << "B" << mynum << " ctor\n"; }

-  ~B() { *history << "B" << mynum << " dtor\n"; }

-  virtual void Use() { *history << "B" << mynum << " use\n"; }

-};

-

-class LinkedPtrTest : public testing::Test {

- public:

-  LinkedPtrTest() {

-    num = 0;

-    history = new Message;

-  }

-

-  virtual ~LinkedPtrTest() {

-    delete history;

-    history = NULL;

-  }

-};

-

-TEST_F(LinkedPtrTest, GeneralTest) {

-  {

-    linked_ptr<A> a0, a1, a2;

-    a0 = a0;

-    a1 = a2;

-    ASSERT_EQ(a0.get(), static_cast<A*>(NULL));

-    ASSERT_EQ(a1.get(), static_cast<A*>(NULL));

-    ASSERT_EQ(a2.get(), static_cast<A*>(NULL));

-    ASSERT_TRUE(a0 == NULL);

-    ASSERT_TRUE(a1 == NULL);

-    ASSERT_TRUE(a2 == NULL);

-

-    {

-      linked_ptr<A> a3(new A);

-      a0 = a3;

-      ASSERT_TRUE(a0 == a3);

-      ASSERT_TRUE(a0 != NULL);

-      ASSERT_TRUE(a0.get() == a3);

-      ASSERT_TRUE(a0 == a3.get());

-      linked_ptr<A> a4(a0);

-      a1 = a4;

-      linked_ptr<A> a5(new A);

-      ASSERT_TRUE(a5.get() != a3);

-      ASSERT_TRUE(a5 != a3.get());

-      a2 = a5;

-      linked_ptr<B> b0(new B);

-      linked_ptr<A> a6(b0);

-      ASSERT_TRUE(b0 == a6);

-      ASSERT_TRUE(a6 == b0);

-      ASSERT_TRUE(b0 != NULL);

-      a5 = b0;

-      a5 = b0;

-      a3->Use();

-      a4->Use();

-      a5->Use();

-      a6->Use();

-      b0->Use();

-      (*b0).Use();

-      b0.get()->Use();

-    }

-

-    a0->Use();

-    a1->Use();

-    a2->Use();

-

-    a1 = a2;

-    a2.reset(new A);

-    a0.reset();

-

-    linked_ptr<A> a7;

-  }

-

-  ASSERT_STREQ(

-    "A0 ctor\n"

-    "A1 ctor\n"

-    "A2 ctor\n"

-    "B2 ctor\n"

-    "A0 use\n"

-    "A0 use\n"

-    "B2 use\n"

-    "B2 use\n"

-    "B2 use\n"

-    "B2 use\n"

-    "B2 use\n"

-    "B2 dtor\n"

-    "A2 dtor\n"

-    "A0 use\n"

-    "A0 use\n"

-    "A1 use\n"

-    "A3 ctor\n"

-    "A0 dtor\n"

-    "A3 dtor\n"

-    "A1 dtor\n",

-    history->GetString().c_str()

-  );

-}

-

-}  // Unnamed namespace

+// Copyright 2003, 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.
+//
+// Authors: Dan Egnor ([email protected])
+// Ported to Windows: Vadim Berman ([email protected])
+
+#include <gtest/internal/gtest-linked_ptr.h>
+
+#include <stdlib.h>
+#include <gtest/gtest.h>
+
+namespace {
+
+using testing::Message;
+using testing::internal::linked_ptr;
+
+int num;
+Message* history = NULL;
+
+// Class which tracks allocation/deallocation
+class A {
+ public:
+  A(): mynum(num++) { *history << "A" << mynum << " ctor\n"; }
+  virtual ~A() { *history << "A" << mynum << " dtor\n"; }
+  virtual void Use() { *history << "A" << mynum << " use\n"; }
+ protected:
+  int mynum;
+};
+
+// Subclass
+class B : public A {
+ public:
+  B() { *history << "B" << mynum << " ctor\n"; }
+  ~B() { *history << "B" << mynum << " dtor\n"; }
+  virtual void Use() { *history << "B" << mynum << " use\n"; }
+};
+
+class LinkedPtrTest : public testing::Test {
+ public:
+  LinkedPtrTest() {
+    num = 0;
+    history = new Message;
+  }
+
+  virtual ~LinkedPtrTest() {
+    delete history;
+    history = NULL;
+  }
+};
+
+TEST_F(LinkedPtrTest, GeneralTest) {
+  {
+    linked_ptr<A> a0, a1, a2;
+    a0 = a0;
+    a1 = a2;
+    ASSERT_EQ(a0.get(), static_cast<A*>(NULL));
+    ASSERT_EQ(a1.get(), static_cast<A*>(NULL));
+    ASSERT_EQ(a2.get(), static_cast<A*>(NULL));
+    ASSERT_TRUE(a0 == NULL);
+    ASSERT_TRUE(a1 == NULL);
+    ASSERT_TRUE(a2 == NULL);
+
+    {
+      linked_ptr<A> a3(new A);
+      a0 = a3;
+      ASSERT_TRUE(a0 == a3);
+      ASSERT_TRUE(a0 != NULL);
+      ASSERT_TRUE(a0.get() == a3);
+      ASSERT_TRUE(a0 == a3.get());
+      linked_ptr<A> a4(a0);
+      a1 = a4;
+      linked_ptr<A> a5(new A);
+      ASSERT_TRUE(a5.get() != a3);
+      ASSERT_TRUE(a5 != a3.get());
+      a2 = a5;
+      linked_ptr<B> b0(new B);
+      linked_ptr<A> a6(b0);
+      ASSERT_TRUE(b0 == a6);
+      ASSERT_TRUE(a6 == b0);
+      ASSERT_TRUE(b0 != NULL);
+      a5 = b0;
+      a5 = b0;
+      a3->Use();
+      a4->Use();
+      a5->Use();
+      a6->Use();
+      b0->Use();
+      (*b0).Use();
+      b0.get()->Use();
+    }
+
+    a0->Use();
+    a1->Use();
+    a2->Use();
+
+    a1 = a2;
+    a2.reset(new A);
+    a0.reset();
+
+    linked_ptr<A> a7;
+  }
+
+  ASSERT_STREQ(
+    "A0 ctor\n"
+    "A1 ctor\n"
+    "A2 ctor\n"
+    "B2 ctor\n"
+    "A0 use\n"
+    "A0 use\n"
+    "B2 use\n"
+    "B2 use\n"
+    "B2 use\n"
+    "B2 use\n"
+    "B2 use\n"
+    "B2 dtor\n"
+    "A2 dtor\n"
+    "A0 use\n"
+    "A0 use\n"
+    "A1 use\n"
+    "A3 ctor\n"
+    "A0 dtor\n"
+    "A3 dtor\n"
+    "A1 dtor\n",
+    history->GetString().c_str()
+  );
+}
+
+}  // Unnamed namespace
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-listener_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-listener_test.cc
index e6a11633..f12f5188 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-listener_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-listener_test.cc
@@ -1,322 +1,322 @@
-// 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: [email protected] (Vlad Losev)

-//

-// The Google C++ Testing Framework (Google Test)

-//

-// This file verifies Google Test event listeners receive events at the

-// right times.

-

-#include <gtest/gtest.h>

-

-// 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"  // For Vector.

-#undef GTEST_IMPLEMENTATION_

-

-using ::testing::AddGlobalTestEnvironment;

-using ::testing::Environment;

-using ::testing::InitGoogleTest;

-using ::testing::Test;

-using ::testing::TestCase;

-using ::testing::TestEventListener;

-using ::testing::TestInfo;

-using ::testing::TestPartResult;

-using ::testing::UnitTest;

-using ::testing::internal::String;

-using ::testing::internal::Vector;

-

-// Used by tests to register their events.

-Vector<String>* g_events = NULL;

-

-namespace testing {

-namespace internal {

-

-class EventRecordingListener : public TestEventListener {

- public:

-  EventRecordingListener(const char* name) : name_(name) {}

-

- protected:

-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {

-    g_events->PushBack(GetFullMethodName("OnTestProgramStart"));

-  }

-

-  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,

-                                    int iteration) {

-    Message message;

-    message << GetFullMethodName("OnTestIterationStart")

-            << "(" << iteration << ")";

-    g_events->PushBack(message.GetString());

-  }

-

-  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {

-    g_events->PushBack(GetFullMethodName("OnEnvironmentsSetUpStart"));

-  }

-

-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {

-    g_events->PushBack(GetFullMethodName("OnEnvironmentsSetUpEnd"));

-  }

-

-  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {

-    g_events->PushBack(GetFullMethodName("OnTestCaseStart"));

-  }

-

-  virtual void OnTestStart(const TestInfo& /*test_info*/) {

-    g_events->PushBack(GetFullMethodName("OnTestStart"));

-  }

-

-  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {

-    g_events->PushBack(GetFullMethodName("OnTestPartResult"));

-  }

-

-  virtual void OnTestEnd(const TestInfo& /*test_info*/) {

-    g_events->PushBack(GetFullMethodName("OnTestEnd"));

-  }

-

-  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {

-    g_events->PushBack(GetFullMethodName("OnTestCaseEnd"));

-  }

-

-  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {

-    g_events->PushBack(GetFullMethodName("OnEnvironmentsTearDownStart"));

-  }

-

-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {

-    g_events->PushBack(GetFullMethodName("OnEnvironmentsTearDownEnd"));

-  }

-

-  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,

-                                  int iteration) {

-    Message message;

-    message << GetFullMethodName("OnTestIterationEnd")

-            << "("  << iteration << ")";

-    g_events->PushBack(message.GetString());

-  }

-

-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {

-    g_events->PushBack(GetFullMethodName("OnTestProgramEnd"));

-  }

-

- private:

-  String GetFullMethodName(const char* name) {

-    Message message;

-    message << name_ << "." << name;

-    return message.GetString();

-  }

-

-  String name_;

-};

-

-class EnvironmentInvocationCatcher : public Environment {

- protected:

-  virtual void SetUp() {

-    g_events->PushBack(String("Environment::SetUp"));

-  }

-

-  virtual void TearDown() {

-    g_events->PushBack(String("Environment::TearDown"));

-  }

-};

-

-class ListenerTest : public Test {

- protected:

-  static void SetUpTestCase() {

-    g_events->PushBack(String("ListenerTest::SetUpTestCase"));

-  }

-

-  static void TearDownTestCase() {

-    g_events->PushBack(String("ListenerTest::TearDownTestCase"));

-  }

-

-  virtual void SetUp() {

-    g_events->PushBack(String("ListenerTest::SetUp"));

-  }

-

-  virtual void TearDown() {

-    g_events->PushBack(String("ListenerTest::TearDown"));

-  }

-};

-

-TEST_F(ListenerTest, DoesFoo) {

-  // Test execution order within a test case is not guaranteed so we are not

-  // recording the test name.

-  g_events->PushBack(String("ListenerTest::* Test Body"));

-  SUCCEED();  // Triggers OnTestPartResult.

-}

-

-TEST_F(ListenerTest, DoesBar) {

-  g_events->PushBack(String("ListenerTest::* Test Body"));

-  SUCCEED();  // Triggers OnTestPartResult.

-}

-

-}  // namespace internal

-

-}  // namespace testing

-

-using ::testing::internal::EnvironmentInvocationCatcher;

-using ::testing::internal::EventRecordingListener;

-

-void VerifyResults(const Vector<String>& data,

-                   const char* const* expected_data,

-                   int expected_data_size) {

-  const int actual_size = data.size();

-  // If the following assertion fails, a new entry will be appended to

-  // data.  Hence we save data.size() first.

-  EXPECT_EQ(expected_data_size, actual_size);

-

-  // Compares the common prefix.

-  const int shorter_size = expected_data_size <= actual_size ?

-      expected_data_size : actual_size;

-  int i = 0;

-  for (; i < shorter_size; ++i) {

-    ASSERT_STREQ(expected_data[i], data.GetElement(i).c_str())

-        << "at position " << i;

-  }

-

-  // Prints extra elements in the actual data.

-  for (; i < actual_size; ++i) {

-    printf("  Actual event #%d: %s\n", i, data.GetElement(i).c_str());

-  }

-}

-

-int main(int argc, char **argv) {

-  Vector<String> events;

-  g_events = &events;

-  InitGoogleTest(&argc, argv);

-

-  UnitTest::GetInstance()->listeners().Append(

-      new EventRecordingListener("1st"));

-  UnitTest::GetInstance()->listeners().Append(

-      new EventRecordingListener("2nd"));

-

-  AddGlobalTestEnvironment(new EnvironmentInvocationCatcher);

-

-  GTEST_CHECK_(events.size() == 0)

-      << "AddGlobalTestEnvironment should not generate any events itself.";

-

-  ::testing::GTEST_FLAG(repeat) = 2;

-  int ret_val = RUN_ALL_TESTS();

-

-  const char* const expected_events[] = {

-    "1st.OnTestProgramStart",

-    "2nd.OnTestProgramStart",

-    "1st.OnTestIterationStart(0)",

-    "2nd.OnTestIterationStart(0)",

-    "1st.OnEnvironmentsSetUpStart",

-    "2nd.OnEnvironmentsSetUpStart",

-    "Environment::SetUp",

-    "2nd.OnEnvironmentsSetUpEnd",

-    "1st.OnEnvironmentsSetUpEnd",

-    "1st.OnTestCaseStart",

-    "2nd.OnTestCaseStart",

-    "ListenerTest::SetUpTestCase",

-    "1st.OnTestStart",

-    "2nd.OnTestStart",

-    "ListenerTest::SetUp",

-    "ListenerTest::* Test Body",

-    "1st.OnTestPartResult",

-    "2nd.OnTestPartResult",

-    "ListenerTest::TearDown",

-    "2nd.OnTestEnd",

-    "1st.OnTestEnd",

-    "1st.OnTestStart",

-    "2nd.OnTestStart",

-    "ListenerTest::SetUp",

-    "ListenerTest::* Test Body",

-    "1st.OnTestPartResult",

-    "2nd.OnTestPartResult",

-    "ListenerTest::TearDown",

-    "2nd.OnTestEnd",

-    "1st.OnTestEnd",

-    "ListenerTest::TearDownTestCase",

-    "2nd.OnTestCaseEnd",

-    "1st.OnTestCaseEnd",

-    "1st.OnEnvironmentsTearDownStart",

-    "2nd.OnEnvironmentsTearDownStart",

-    "Environment::TearDown",

-    "2nd.OnEnvironmentsTearDownEnd",

-    "1st.OnEnvironmentsTearDownEnd",

-    "2nd.OnTestIterationEnd(0)",

-    "1st.OnTestIterationEnd(0)",

-    "1st.OnTestIterationStart(1)",

-    "2nd.OnTestIterationStart(1)",

-    "1st.OnEnvironmentsSetUpStart",

-    "2nd.OnEnvironmentsSetUpStart",

-    "Environment::SetUp",

-    "2nd.OnEnvironmentsSetUpEnd",

-    "1st.OnEnvironmentsSetUpEnd",

-    "1st.OnTestCaseStart",

-    "2nd.OnTestCaseStart",

-    "ListenerTest::SetUpTestCase",

-    "1st.OnTestStart",

-    "2nd.OnTestStart",

-    "ListenerTest::SetUp",

-    "ListenerTest::* Test Body",

-    "1st.OnTestPartResult",

-    "2nd.OnTestPartResult",

-    "ListenerTest::TearDown",

-    "2nd.OnTestEnd",

-    "1st.OnTestEnd",

-    "1st.OnTestStart",

-    "2nd.OnTestStart",

-    "ListenerTest::SetUp",

-    "ListenerTest::* Test Body",

-    "1st.OnTestPartResult",

-    "2nd.OnTestPartResult",

-    "ListenerTest::TearDown",

-    "2nd.OnTestEnd",

-    "1st.OnTestEnd",

-    "ListenerTest::TearDownTestCase",

-    "2nd.OnTestCaseEnd",

-    "1st.OnTestCaseEnd",

-    "1st.OnEnvironmentsTearDownStart",

-    "2nd.OnEnvironmentsTearDownStart",

-    "Environment::TearDown",

-    "2nd.OnEnvironmentsTearDownEnd",

-    "1st.OnEnvironmentsTearDownEnd",

-    "2nd.OnTestIterationEnd(1)",

-    "1st.OnTestIterationEnd(1)",

-    "2nd.OnTestProgramEnd",

-    "1st.OnTestProgramEnd"

-  };

-  VerifyResults(events,

-                expected_events,

-                sizeof(expected_events)/sizeof(expected_events[0]));

-

-  // We need to check manually for ad hoc test failures that happen after

-  // RUN_ALL_TESTS finishes.

-  if (UnitTest::GetInstance()->Failed())

-    ret_val = 1;

-

-  return ret_val;

-}

+// 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: [email protected] (Vlad Losev)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This file verifies Google Test event listeners receive events at the
+// right times.
+
+#include <gtest/gtest.h>
+
+// 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"  // For Vector.
+#undef GTEST_IMPLEMENTATION_
+
+using ::testing::AddGlobalTestEnvironment;
+using ::testing::Environment;
+using ::testing::InitGoogleTest;
+using ::testing::Test;
+using ::testing::TestCase;
+using ::testing::TestEventListener;
+using ::testing::TestInfo;
+using ::testing::TestPartResult;
+using ::testing::UnitTest;
+using ::testing::internal::String;
+using ::testing::internal::Vector;
+
+// Used by tests to register their events.
+Vector<String>* g_events = NULL;
+
+namespace testing {
+namespace internal {
+
+class EventRecordingListener : public TestEventListener {
+ public:
+  EventRecordingListener(const char* name) : name_(name) {}
+
+ protected:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
+    g_events->PushBack(GetFullMethodName("OnTestProgramStart"));
+  }
+
+  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                                    int iteration) {
+    Message message;
+    message << GetFullMethodName("OnTestIterationStart")
+            << "(" << iteration << ")";
+    g_events->PushBack(message.GetString());
+  }
+
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {
+    g_events->PushBack(GetFullMethodName("OnEnvironmentsSetUpStart"));
+  }
+
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {
+    g_events->PushBack(GetFullMethodName("OnEnvironmentsSetUpEnd"));
+  }
+
+  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {
+    g_events->PushBack(GetFullMethodName("OnTestCaseStart"));
+  }
+
+  virtual void OnTestStart(const TestInfo& /*test_info*/) {
+    g_events->PushBack(GetFullMethodName("OnTestStart"));
+  }
+
+  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {
+    g_events->PushBack(GetFullMethodName("OnTestPartResult"));
+  }
+
+  virtual void OnTestEnd(const TestInfo& /*test_info*/) {
+    g_events->PushBack(GetFullMethodName("OnTestEnd"));
+  }
+
+  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {
+    g_events->PushBack(GetFullMethodName("OnTestCaseEnd"));
+  }
+
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {
+    g_events->PushBack(GetFullMethodName("OnEnvironmentsTearDownStart"));
+  }
+
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {
+    g_events->PushBack(GetFullMethodName("OnEnvironmentsTearDownEnd"));
+  }
+
+  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                                  int iteration) {
+    Message message;
+    message << GetFullMethodName("OnTestIterationEnd")
+            << "("  << iteration << ")";
+    g_events->PushBack(message.GetString());
+  }
+
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
+    g_events->PushBack(GetFullMethodName("OnTestProgramEnd"));
+  }
+
+ private:
+  String GetFullMethodName(const char* name) {
+    Message message;
+    message << name_ << "." << name;
+    return message.GetString();
+  }
+
+  String name_;
+};
+
+class EnvironmentInvocationCatcher : public Environment {
+ protected:
+  virtual void SetUp() {
+    g_events->PushBack(String("Environment::SetUp"));
+  }
+
+  virtual void TearDown() {
+    g_events->PushBack(String("Environment::TearDown"));
+  }
+};
+
+class ListenerTest : public Test {
+ protected:
+  static void SetUpTestCase() {
+    g_events->PushBack(String("ListenerTest::SetUpTestCase"));
+  }
+
+  static void TearDownTestCase() {
+    g_events->PushBack(String("ListenerTest::TearDownTestCase"));
+  }
+
+  virtual void SetUp() {
+    g_events->PushBack(String("ListenerTest::SetUp"));
+  }
+
+  virtual void TearDown() {
+    g_events->PushBack(String("ListenerTest::TearDown"));
+  }
+};
+
+TEST_F(ListenerTest, DoesFoo) {
+  // Test execution order within a test case is not guaranteed so we are not
+  // recording the test name.
+  g_events->PushBack(String("ListenerTest::* Test Body"));
+  SUCCEED();  // Triggers OnTestPartResult.
+}
+
+TEST_F(ListenerTest, DoesBar) {
+  g_events->PushBack(String("ListenerTest::* Test Body"));
+  SUCCEED();  // Triggers OnTestPartResult.
+}
+
+}  // namespace internal
+
+}  // namespace testing
+
+using ::testing::internal::EnvironmentInvocationCatcher;
+using ::testing::internal::EventRecordingListener;
+
+void VerifyResults(const Vector<String>& data,
+                   const char* const* expected_data,
+                   int expected_data_size) {
+  const int actual_size = data.size();
+  // If the following assertion fails, a new entry will be appended to
+  // data.  Hence we save data.size() first.
+  EXPECT_EQ(expected_data_size, actual_size);
+
+  // Compares the common prefix.
+  const int shorter_size = expected_data_size <= actual_size ?
+      expected_data_size : actual_size;
+  int i = 0;
+  for (; i < shorter_size; ++i) {
+    ASSERT_STREQ(expected_data[i], data.GetElement(i).c_str())
+        << "at position " << i;
+  }
+
+  // Prints extra elements in the actual data.
+  for (; i < actual_size; ++i) {
+    printf("  Actual event #%d: %s\n", i, data.GetElement(i).c_str());
+  }
+}
+
+int main(int argc, char **argv) {
+  Vector<String> events;
+  g_events = &events;
+  InitGoogleTest(&argc, argv);
+
+  UnitTest::GetInstance()->listeners().Append(
+      new EventRecordingListener("1st"));
+  UnitTest::GetInstance()->listeners().Append(
+      new EventRecordingListener("2nd"));
+
+  AddGlobalTestEnvironment(new EnvironmentInvocationCatcher);
+
+  GTEST_CHECK_(events.size() == 0)
+      << "AddGlobalTestEnvironment should not generate any events itself.";
+
+  ::testing::GTEST_FLAG(repeat) = 2;
+  int ret_val = RUN_ALL_TESTS();
+
+  const char* const expected_events[] = {
+    "1st.OnTestProgramStart",
+    "2nd.OnTestProgramStart",
+    "1st.OnTestIterationStart(0)",
+    "2nd.OnTestIterationStart(0)",
+    "1st.OnEnvironmentsSetUpStart",
+    "2nd.OnEnvironmentsSetUpStart",
+    "Environment::SetUp",
+    "2nd.OnEnvironmentsSetUpEnd",
+    "1st.OnEnvironmentsSetUpEnd",
+    "1st.OnTestCaseStart",
+    "2nd.OnTestCaseStart",
+    "ListenerTest::SetUpTestCase",
+    "1st.OnTestStart",
+    "2nd.OnTestStart",
+    "ListenerTest::SetUp",
+    "ListenerTest::* Test Body",
+    "1st.OnTestPartResult",
+    "2nd.OnTestPartResult",
+    "ListenerTest::TearDown",
+    "2nd.OnTestEnd",
+    "1st.OnTestEnd",
+    "1st.OnTestStart",
+    "2nd.OnTestStart",
+    "ListenerTest::SetUp",
+    "ListenerTest::* Test Body",
+    "1st.OnTestPartResult",
+    "2nd.OnTestPartResult",
+    "ListenerTest::TearDown",
+    "2nd.OnTestEnd",
+    "1st.OnTestEnd",
+    "ListenerTest::TearDownTestCase",
+    "2nd.OnTestCaseEnd",
+    "1st.OnTestCaseEnd",
+    "1st.OnEnvironmentsTearDownStart",
+    "2nd.OnEnvironmentsTearDownStart",
+    "Environment::TearDown",
+    "2nd.OnEnvironmentsTearDownEnd",
+    "1st.OnEnvironmentsTearDownEnd",
+    "2nd.OnTestIterationEnd(0)",
+    "1st.OnTestIterationEnd(0)",
+    "1st.OnTestIterationStart(1)",
+    "2nd.OnTestIterationStart(1)",
+    "1st.OnEnvironmentsSetUpStart",
+    "2nd.OnEnvironmentsSetUpStart",
+    "Environment::SetUp",
+    "2nd.OnEnvironmentsSetUpEnd",
+    "1st.OnEnvironmentsSetUpEnd",
+    "1st.OnTestCaseStart",
+    "2nd.OnTestCaseStart",
+    "ListenerTest::SetUpTestCase",
+    "1st.OnTestStart",
+    "2nd.OnTestStart",
+    "ListenerTest::SetUp",
+    "ListenerTest::* Test Body",
+    "1st.OnTestPartResult",
+    "2nd.OnTestPartResult",
+    "ListenerTest::TearDown",
+    "2nd.OnTestEnd",
+    "1st.OnTestEnd",
+    "1st.OnTestStart",
+    "2nd.OnTestStart",
+    "ListenerTest::SetUp",
+    "ListenerTest::* Test Body",
+    "1st.OnTestPartResult",
+    "2nd.OnTestPartResult",
+    "ListenerTest::TearDown",
+    "2nd.OnTestEnd",
+    "1st.OnTestEnd",
+    "ListenerTest::TearDownTestCase",
+    "2nd.OnTestCaseEnd",
+    "1st.OnTestCaseEnd",
+    "1st.OnEnvironmentsTearDownStart",
+    "2nd.OnEnvironmentsTearDownStart",
+    "Environment::TearDown",
+    "2nd.OnEnvironmentsTearDownEnd",
+    "1st.OnEnvironmentsTearDownEnd",
+    "2nd.OnTestIterationEnd(1)",
+    "1st.OnTestIterationEnd(1)",
+    "2nd.OnTestProgramEnd",
+    "1st.OnTestProgramEnd"
+  };
+  VerifyResults(events,
+                expected_events,
+                sizeof(expected_events)/sizeof(expected_events[0]));
+
+  // We need to check manually for ad hoc test failures that happen after
+  // RUN_ALL_TESTS finishes.
+  if (UnitTest::GetInstance()->Failed())
+    ret_val = 1;
+
+  return ret_val;
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-message_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-message_test.cc
index f0f1ddfe..6c43c33d 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-message_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-message_test.cc
@@ -1,157 +1,157 @@
-// Copyright 2005, 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: [email protected] (Zhanyong Wan)

-//

-// Tests for the Message class.

-

-#include <gtest/gtest-message.h>

-

-#include <gtest/gtest.h>

-

-namespace {

-

-using ::testing::Message;

-using ::testing::internal::StrStream;

-

-// A helper function that turns a Message into a C string.

-const char* ToCString(const Message& msg) {

-  static testing::internal::String result;

-  result = msg.GetString();

-  return result.c_str();

-}

-

-// Tests the testing::Message class

-

-// Tests the default constructor.

-TEST(MessageTest, DefaultConstructor) {

-  const Message msg;

-  EXPECT_STREQ("", ToCString(msg));

-}

-

-// Tests the copy constructor.

-TEST(MessageTest, CopyConstructor) {

-  const Message msg1("Hello");

-  const Message msg2(msg1);

-  EXPECT_STREQ("Hello", ToCString(msg2));

-}

-

-// Tests constructing a Message from a C-string.

-TEST(MessageTest, ConstructsFromCString) {

-  Message msg("Hello");

-  EXPECT_STREQ("Hello", ToCString(msg));

-}

-

-// Tests streaming a non-char pointer.

-TEST(MessageTest, StreamsPointer) {

-  int n = 0;

-  int* p = &n;

-  EXPECT_STRNE("(null)", ToCString(Message() << p));

-}

-

-// Tests streaming a NULL non-char pointer.

-TEST(MessageTest, StreamsNullPointer) {

-  int* p = NULL;

-  EXPECT_STREQ("(null)", ToCString(Message() << p));

-}

-

-// Tests streaming a C string.

-TEST(MessageTest, StreamsCString) {

-  EXPECT_STREQ("Foo", ToCString(Message() << "Foo"));

-}

-

-// Tests streaming a NULL C string.

-TEST(MessageTest, StreamsNullCString) {

-  char* p = NULL;

-  EXPECT_STREQ("(null)", ToCString(Message() << p));

-}

-

-#if GTEST_HAS_STD_STRING

-

-// Tests streaming std::string.

-//

-// As std::string has problem in MSVC when exception is disabled, we only

-// test this where std::string can be used.

-TEST(MessageTest, StreamsString) {

-  const ::std::string str("Hello");

-  EXPECT_STREQ("Hello", ToCString(Message() << str));

-}

-

-// Tests that we can output strings containing embedded NULs.

-TEST(MessageTest, StreamsStringWithEmbeddedNUL) {

-  const char char_array_with_nul[] =

-      "Here's a NUL\0 and some more string";

-  const ::std::string string_with_nul(char_array_with_nul,

-                                      sizeof(char_array_with_nul) - 1);

-  EXPECT_STREQ("Here's a NUL\\0 and some more string",

-               ToCString(Message() << string_with_nul));

-}

-

-#endif  // GTEST_HAS_STD_STRING

-

-// Tests streaming a NUL char.

-TEST(MessageTest, StreamsNULChar) {

-  EXPECT_STREQ("\\0", ToCString(Message() << '\0'));

-}

-

-// Tests streaming int.

-TEST(MessageTest, StreamsInt) {

-  EXPECT_STREQ("123", ToCString(Message() << 123));

-}

-

-// Tests that basic IO manipulators (endl, ends, and flush) can be

-// streamed to Message.

-TEST(MessageTest, StreamsBasicIoManip) {

-  EXPECT_STREQ("Line 1.\nA NUL char \\0 in line 2.",

-               ToCString(Message() << "Line 1." << std::endl

-                         << "A NUL char " << std::ends << std::flush

-                         << " in line 2."));

-}

-

-// Tests Message::GetString()

-TEST(MessageTest, GetString) {

-  Message msg;

-  msg << 1 << " lamb";

-  EXPECT_STREQ("1 lamb", msg.GetString().c_str());

-}

-

-// Tests streaming a Message object to an ostream.

-TEST(MessageTest, StreamsToOStream) {

-  Message msg("Hello");

-  StrStream ss;

-  ss << msg;

-  EXPECT_STREQ("Hello", testing::internal::StrStreamToString(&ss).c_str());

-}

-

-// Tests that a Message object doesn't take up too much stack space.

-TEST(MessageTest, DoesNotTakeUpMuchStackSpace) {

-  EXPECT_LE(sizeof(Message), 16U);

-}

-

-}  // namespace

+// Copyright 2005, 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: [email protected] (Zhanyong Wan)
+//
+// Tests for the Message class.
+
+#include <gtest/gtest-message.h>
+
+#include <gtest/gtest.h>
+
+namespace {
+
+using ::testing::Message;
+using ::testing::internal::StrStream;
+
+// A helper function that turns a Message into a C string.
+const char* ToCString(const Message& msg) {
+  static testing::internal::String result;
+  result = msg.GetString();
+  return result.c_str();
+}
+
+// Tests the testing::Message class
+
+// Tests the default constructor.
+TEST(MessageTest, DefaultConstructor) {
+  const Message msg;
+  EXPECT_STREQ("", ToCString(msg));
+}
+
+// Tests the copy constructor.
+TEST(MessageTest, CopyConstructor) {
+  const Message msg1("Hello");
+  const Message msg2(msg1);
+  EXPECT_STREQ("Hello", ToCString(msg2));
+}
+
+// Tests constructing a Message from a C-string.
+TEST(MessageTest, ConstructsFromCString) {
+  Message msg("Hello");
+  EXPECT_STREQ("Hello", ToCString(msg));
+}
+
+// Tests streaming a non-char pointer.
+TEST(MessageTest, StreamsPointer) {
+  int n = 0;
+  int* p = &n;
+  EXPECT_STRNE("(null)", ToCString(Message() << p));
+}
+
+// Tests streaming a NULL non-char pointer.
+TEST(MessageTest, StreamsNullPointer) {
+  int* p = NULL;
+  EXPECT_STREQ("(null)", ToCString(Message() << p));
+}
+
+// Tests streaming a C string.
+TEST(MessageTest, StreamsCString) {
+  EXPECT_STREQ("Foo", ToCString(Message() << "Foo"));
+}
+
+// Tests streaming a NULL C string.
+TEST(MessageTest, StreamsNullCString) {
+  char* p = NULL;
+  EXPECT_STREQ("(null)", ToCString(Message() << p));
+}
+
+#if GTEST_HAS_STD_STRING
+
+// Tests streaming std::string.
+//
+// As std::string has problem in MSVC when exception is disabled, we only
+// test this where std::string can be used.
+TEST(MessageTest, StreamsString) {
+  const ::std::string str("Hello");
+  EXPECT_STREQ("Hello", ToCString(Message() << str));
+}
+
+// Tests that we can output strings containing embedded NULs.
+TEST(MessageTest, StreamsStringWithEmbeddedNUL) {
+  const char char_array_with_nul[] =
+      "Here's a NUL\0 and some more string";
+  const ::std::string string_with_nul(char_array_with_nul,
+                                      sizeof(char_array_with_nul) - 1);
+  EXPECT_STREQ("Here's a NUL\\0 and some more string",
+               ToCString(Message() << string_with_nul));
+}
+
+#endif  // GTEST_HAS_STD_STRING
+
+// Tests streaming a NUL char.
+TEST(MessageTest, StreamsNULChar) {
+  EXPECT_STREQ("\\0", ToCString(Message() << '\0'));
+}
+
+// Tests streaming int.
+TEST(MessageTest, StreamsInt) {
+  EXPECT_STREQ("123", ToCString(Message() << 123));
+}
+
+// Tests that basic IO manipulators (endl, ends, and flush) can be
+// streamed to Message.
+TEST(MessageTest, StreamsBasicIoManip) {
+  EXPECT_STREQ("Line 1.\nA NUL char \\0 in line 2.",
+               ToCString(Message() << "Line 1." << std::endl
+                         << "A NUL char " << std::ends << std::flush
+                         << " in line 2."));
+}
+
+// Tests Message::GetString()
+TEST(MessageTest, GetString) {
+  Message msg;
+  msg << 1 << " lamb";
+  EXPECT_STREQ("1 lamb", msg.GetString().c_str());
+}
+
+// Tests streaming a Message object to an ostream.
+TEST(MessageTest, StreamsToOStream) {
+  Message msg("Hello");
+  StrStream ss;
+  ss << msg;
+  EXPECT_STREQ("Hello", testing::internal::StrStreamToString(&ss).c_str());
+}
+
+// Tests that a Message object doesn't take up too much stack space.
+TEST(MessageTest, DoesNotTakeUpMuchStackSpace) {
+  EXPECT_LE(sizeof(Message), 16U);
+}
+
+}  // namespace
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-options_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-options_test.cc
index 08c4df20..31ae3277 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-options_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-options_test.cc
@@ -1,267 +1,267 @@
-// Copyright 2008, 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.

-//

-// Authors: [email protected] (Keith Ray)

-//

-// Google Test UnitTestOptions tests

-//

-// This file tests classes and functions used internally by

-// Google Test.  They are subject to change without notice.

-//

-// This file is #included from gtest.cc, to avoid changing build or

-// make-files on Windows and other platforms. Do not #include this file

-// anywhere else!

-

-#include <gtest/gtest.h>

-

-#if GTEST_OS_WINDOWS_MOBILE

-#include <windows.h>

-#elif GTEST_OS_WINDOWS

-#include <direct.h>

-#endif  // GTEST_OS_WINDOWS_MOBILE

-

-// 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_

-

-namespace testing {

-namespace internal {

-namespace {

-

-// Turns the given relative path into an absolute path.

-FilePath GetAbsolutePathOf(const FilePath& relative_path) {

-  return FilePath::ConcatPaths(FilePath::GetCurrentDir(), relative_path);

-}

-

-// Testing UnitTestOptions::GetOutputFormat/GetOutputFile.

-

-TEST(XmlOutputTest, GetOutputFormatDefault) {

-  GTEST_FLAG(output) = "";

-  EXPECT_STREQ("", UnitTestOptions::GetOutputFormat().c_str());

-}

-

-TEST(XmlOutputTest, GetOutputFormat) {

-  GTEST_FLAG(output) = "xml:filename";

-  EXPECT_STREQ("xml", UnitTestOptions::GetOutputFormat().c_str());

-}

-

-TEST(XmlOutputTest, GetOutputFileDefault) {

-  GTEST_FLAG(output) = "";

-  EXPECT_STREQ(GetAbsolutePathOf(FilePath("test_detail.xml")).c_str(),

-               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());

-}

-

-TEST(XmlOutputTest, GetOutputFileSingleFile) {

-  GTEST_FLAG(output) = "xml:filename.abc";

-  EXPECT_STREQ(GetAbsolutePathOf(FilePath("filename.abc")).c_str(),

-               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());

-}

-

-TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {

-#if GTEST_OS_WINDOWS

-  GTEST_FLAG(output) = "xml:path\\";

-  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;

-#else

-  GTEST_FLAG(output) = "xml:path/";

-  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();

-  // TODO([email protected]): 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;

-#endif

-}

-

-TEST(OutputFileHelpersTest, GetCurrentExecutableName) {

-  const FilePath executable = GetCurrentExecutableName();

-  const char* const exe_str = executable.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;

-#else

-  // TODO([email protected]): 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;

-#endif  // GTEST_OS_WINDOWS

-}

-

-class XmlOutputChangeDirTest : public Test {

- protected:

-  virtual void SetUp() {

-    original_working_dir_ = FilePath::GetCurrentDir();

-    posix::ChDir("..");

-    // This will make the test fail if run from the root directory.

-    EXPECT_STRNE(original_working_dir_.c_str(),

-                 FilePath::GetCurrentDir().c_str());

-  }

-

-  virtual void TearDown() {

-    posix::ChDir(original_working_dir_.c_str());

-  }

-

-  FilePath original_working_dir_;

-};

-

-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefault) {

-  GTEST_FLAG(output) = "";

-  EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,

-                                     FilePath("test_detail.xml")).c_str(),

-               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());

-}

-

-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefaultXML) {

-  GTEST_FLAG(output) = "xml";

-  EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,

-                                     FilePath("test_detail.xml")).c_str(),

-               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());

-}

-

-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) {

-  GTEST_FLAG(output) = "xml:filename.abc";

-  EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,

-                                     FilePath("filename.abc")).c_str(),

-               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());

-}

-

-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {

-#if GTEST_OS_WINDOWS

-  GTEST_FLAG(output) = "xml:path\\";

-  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;

-#else

-  GTEST_FLAG(output) = "xml:path/";

-  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();

-  // TODO([email protected]): 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;

-#endif

-}

-

-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {

-#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());

-#else

-  GTEST_FLAG(output) ="xml:/tmp/filename.abc";

-  EXPECT_STREQ(FilePath("/tmp/filename.abc").c_str(),

-               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());

-#endif

-}

-

-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;

-#else

-  GTEST_FLAG(output) = "xml:/tmp/";

-  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();

-  // TODO([email protected]): 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;

-#endif

-}

-

-}  // namespace

-}  // namespace internal

-}  // namespace testing

+// Copyright 2008, 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.
+//
+// Authors: [email protected] (Keith Ray)
+//
+// Google Test UnitTestOptions tests
+//
+// This file tests classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included from gtest.cc, to avoid changing build or
+// make-files on Windows and other platforms. Do not #include this file
+// anywhere else!
+
+#include <gtest/gtest.h>
+
+#if GTEST_OS_WINDOWS_MOBILE
+#include <windows.h>
+#elif GTEST_OS_WINDOWS
+#include <direct.h>
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// 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_
+
+namespace testing {
+namespace internal {
+namespace {
+
+// Turns the given relative path into an absolute path.
+FilePath GetAbsolutePathOf(const FilePath& relative_path) {
+  return FilePath::ConcatPaths(FilePath::GetCurrentDir(), relative_path);
+}
+
+// Testing UnitTestOptions::GetOutputFormat/GetOutputFile.
+
+TEST(XmlOutputTest, GetOutputFormatDefault) {
+  GTEST_FLAG(output) = "";
+  EXPECT_STREQ("", UnitTestOptions::GetOutputFormat().c_str());
+}
+
+TEST(XmlOutputTest, GetOutputFormat) {
+  GTEST_FLAG(output) = "xml:filename";
+  EXPECT_STREQ("xml", UnitTestOptions::GetOutputFormat().c_str());
+}
+
+TEST(XmlOutputTest, GetOutputFileDefault) {
+  GTEST_FLAG(output) = "";
+  EXPECT_STREQ(GetAbsolutePathOf(FilePath("test_detail.xml")).c_str(),
+               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+}
+
+TEST(XmlOutputTest, GetOutputFileSingleFile) {
+  GTEST_FLAG(output) = "xml:filename.abc";
+  EXPECT_STREQ(GetAbsolutePathOf(FilePath("filename.abc")).c_str(),
+               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+}
+
+TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
+#if GTEST_OS_WINDOWS
+  GTEST_FLAG(output) = "xml:path\\";
+  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;
+#else
+  GTEST_FLAG(output) = "xml:path/";
+  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
+  // TODO([email protected]): 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;
+#endif
+}
+
+TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
+  const FilePath executable = GetCurrentExecutableName();
+  const char* const exe_str = executable.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;
+#else
+  // TODO([email protected]): 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;
+#endif  // GTEST_OS_WINDOWS
+}
+
+class XmlOutputChangeDirTest : public Test {
+ protected:
+  virtual void SetUp() {
+    original_working_dir_ = FilePath::GetCurrentDir();
+    posix::ChDir("..");
+    // This will make the test fail if run from the root directory.
+    EXPECT_STRNE(original_working_dir_.c_str(),
+                 FilePath::GetCurrentDir().c_str());
+  }
+
+  virtual void TearDown() {
+    posix::ChDir(original_working_dir_.c_str());
+  }
+
+  FilePath original_working_dir_;
+};
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefault) {
+  GTEST_FLAG(output) = "";
+  EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,
+                                     FilePath("test_detail.xml")).c_str(),
+               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefaultXML) {
+  GTEST_FLAG(output) = "xml";
+  EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,
+                                     FilePath("test_detail.xml")).c_str(),
+               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) {
+  GTEST_FLAG(output) = "xml:filename.abc";
+  EXPECT_STREQ(FilePath::ConcatPaths(original_working_dir_,
+                                     FilePath("filename.abc")).c_str(),
+               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
+#if GTEST_OS_WINDOWS
+  GTEST_FLAG(output) = "xml:path\\";
+  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;
+#else
+  GTEST_FLAG(output) = "xml:path/";
+  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
+  // TODO([email protected]): 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;
+#endif
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
+#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());
+#else
+  GTEST_FLAG(output) ="xml:/tmp/filename.abc";
+  EXPECT_STREQ(FilePath("/tmp/filename.abc").c_str(),
+               UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+#endif
+}
+
+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;
+#else
+  GTEST_FLAG(output) = "xml:/tmp/";
+  const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile();
+  // TODO([email protected]): 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;
+#endif
+}
+
+}  // namespace
+}  // namespace internal
+}  // namespace testing
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-param-test2_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-param-test2_test.cc
index 8dd0fe7b..ccb6cfac 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-param-test2_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-param-test2_test.cc
@@ -1,65 +1,65 @@
-// Copyright 2008, 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: [email protected] (Vlad Losev)

-//

-// Tests for Google Test itself.  This verifies that the basic constructs of

-// Google Test work.

-

-#include <gtest/gtest.h>

-

-#include "test/gtest-param-test_test.h"

-

-#if GTEST_HAS_PARAM_TEST

-

-using ::testing::Values;

-using ::testing::internal::ParamGenerator;

-

-// Tests that generators defined in a different translation unit

-// are functional. The test using extern_gen is defined

-// in gtest-param-test_test.cc.

-ParamGenerator<int> extern_gen = Values(33);

-

-// Tests that a parameterized test case can be defined in one translation unit

-// and instantiated in another. The test is defined in gtest-param-test_test.cc

-// and ExternalInstantiationTest fixture class is defined in

-// gtest-param-test_test.h.

-INSTANTIATE_TEST_CASE_P(MultiplesOf33,

-                        ExternalInstantiationTest,

-                        Values(33, 66));

-

-// Tests that a parameterized test case can be instantiated

-// in multiple translation units. Another instantiation is defined

-// in gtest-param-test_test.cc and InstantiationInMultipleTranslaionUnitsTest

-// fixture is defined in gtest-param-test_test.h

-INSTANTIATE_TEST_CASE_P(Sequence2,

-                        InstantiationInMultipleTranslaionUnitsTest,

-                        Values(42*3, 42*4, 42*5));

-

-#endif  // GTEST_HAS_PARAM_TEST

+// Copyright 2008, 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: [email protected] (Vlad Losev)
+//
+// Tests for Google Test itself.  This verifies that the basic constructs of
+// Google Test work.
+
+#include <gtest/gtest.h>
+
+#include "test/gtest-param-test_test.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+using ::testing::Values;
+using ::testing::internal::ParamGenerator;
+
+// Tests that generators defined in a different translation unit
+// are functional. The test using extern_gen is defined
+// in gtest-param-test_test.cc.
+ParamGenerator<int> extern_gen = Values(33);
+
+// Tests that a parameterized test case can be defined in one translation unit
+// and instantiated in another. The test is defined in gtest-param-test_test.cc
+// and ExternalInstantiationTest fixture class is defined in
+// gtest-param-test_test.h.
+INSTANTIATE_TEST_CASE_P(MultiplesOf33,
+                        ExternalInstantiationTest,
+                        Values(33, 66));
+
+// Tests that a parameterized test case can be instantiated
+// in multiple translation units. Another instantiation is defined
+// in gtest-param-test_test.cc and InstantiationInMultipleTranslaionUnitsTest
+// fixture is defined in gtest-param-test_test.h
+INSTANTIATE_TEST_CASE_P(Sequence2,
+                        InstantiationInMultipleTranslaionUnitsTest,
+                        Values(42*3, 42*4, 42*5));
+
+#endif  // GTEST_HAS_PARAM_TEST
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-param-test_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-param-test_test.cc
index 9e6460cf..ecb5fdbb 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-param-test_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-param-test_test.cc
@@ -1,792 +1,792 @@
-// Copyright 2008, 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: [email protected] (Vlad Losev)

-//

-// Tests for Google Test itself. This file verifies that the parameter

-// generators objects produce correct parameter sequences and that

-// Google Test runtime instantiates correct tests from those sequences.

-

-#include <gtest/gtest.h>

-

-#if GTEST_HAS_PARAM_TEST

-

-#include <algorithm>

-#include <iostream>

-#include <list>

-#include <vector>

-

-// To include gtest-internal-inl.h.

-#define GTEST_IMPLEMENTATION_ 1

-#include "src/gtest-internal-inl.h"  // for UnitTestOptions

-#undef GTEST_IMPLEMENTATION_

-

-#include "test/gtest-param-test_test.h"

-

-using ::std::vector;

-using ::std::sort;

-

-using ::testing::AddGlobalTestEnvironment;

-using ::testing::Bool;

-using ::testing::Message;

-using ::testing::Range;

-using ::testing::TestWithParam;

-using ::testing::Values;

-using ::testing::ValuesIn;

-

-#if GTEST_HAS_COMBINE

-using ::testing::Combine;

-using ::std::tr1::get;

-using ::std::tr1::make_tuple;

-using ::std::tr1::tuple;

-#endif  // GTEST_HAS_COMBINE

-

-using ::testing::internal::ParamGenerator;

-using ::testing::internal::UnitTestOptions;

-

-// Verifies that a sequence generated by the generator and accessed

-// via the iterator object matches the expected one using Google Test

-// assertions.

-template <typename T, size_t N>

-void VerifyGenerator(const ParamGenerator<T>& generator,

-                     const T (&expected_values)[N]) {

-  typename ParamGenerator<T>::iterator it = generator.begin();

-  for (size_t i = 0; i < N; ++i) {

-    ASSERT_FALSE(it == generator.end())

-        << "At element " << i << " when accessing via an iterator "

-        << "created with the copy constructor." << std::endl;

-    EXPECT_EQ(expected_values[i], *it)

-        << "At element " << i << " when accessing via an iterator "

-        << "created with the copy constructor." << std::endl;

-    it++;

-  }

-  EXPECT_TRUE(it == generator.end())

-        << "At the presumed end of sequence when accessing via an iterator "

-        << "created with the copy constructor." << std::endl;

-

-  // Test the iterator assignment. The following lines verify that

-  // the sequence accessed via an iterator initialized via the

-  // assignment operator (as opposed to a copy constructor) matches

-  // just the same.

-  it = generator.begin();

-  for (size_t i = 0; i < N; ++i) {

-    ASSERT_FALSE(it == generator.end())

-        << "At element " << i << " when accessing via an iterator "

-        << "created with the assignment operator." << std::endl;

-    EXPECT_EQ(expected_values[i], *it)

-        << "At element " << i << " when accessing via an iterator "

-        << "created with the assignment operator." << std::endl;

-    it++;

-  }

-  EXPECT_TRUE(it == generator.end())

-        << "At the presumed end of sequence when accessing via an iterator "

-        << "created with the assignment operator." << std::endl;

-}

-

-template <typename T>

-void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {

-  typename ParamGenerator<T>::iterator it = generator.begin();

-  EXPECT_TRUE(it == generator.end());

-

-  it = generator.begin();

-  EXPECT_TRUE(it == generator.end());

-}

-

-// Generator tests. They test that each of the provided generator functions

-// generates an expected sequence of values. The general test pattern

-// instantiates a generator using one of the generator functions,

-// checks the sequence produced by the generator using its iterator API,

-// and then resets the iterator back to the beginning of the sequence

-// and checks the sequence again.

-

-// Tests that iterators produced by generator functions conform to the

-// ForwardIterator concept.

-TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {

-  const ParamGenerator<int> gen = Range(0, 10);

-  ParamGenerator<int>::iterator it = gen.begin();

-

-  // Verifies that iterator initialization works as expected.

-  ParamGenerator<int>::iterator it2 = it;

-  EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the "

-                           << "element same as its source points to";

-

-  // Verifies that iterator assignment works as expected.

-  it++;

-  EXPECT_FALSE(*it == *it2);

-  it2 = it;

-  EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "

-                           << "element same as its source points to";

-

-  // Verifies that prefix operator++() returns *this.

-  EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be "

-                          << "refer to the original object";

-

-  // Verifies that the result of the postfix operator++ points to the value

-  // pointed to by the original iterator.

-  int original_value = *it;  // Have to compute it outside of macro call to be

-                             // unaffected by the parameter evaluation order.

-  EXPECT_EQ(original_value, *(it++));

-

-  // Verifies that prefix and postfix operator++() advance an iterator

-  // all the same.

-  it2 = it;

-  it++;

-  ++it2;

-  EXPECT_TRUE(*it == *it2);

-}

-

-// Tests that Range() generates the expected sequence.

-TEST(RangeTest, IntRangeWithDefaultStep) {

-  const ParamGenerator<int> gen = Range(0, 3);

-  const int expected_values[] = {0, 1, 2};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Edge case. Tests that Range() generates the single element sequence

-// as expected when provided with range limits that are equal.

-TEST(RangeTest, IntRangeSingleValue) {

-  const ParamGenerator<int> gen = Range(0, 1);

-  const int expected_values[] = {0};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Edge case. Tests that Range() with generates empty sequence when

-// supplied with an empty range.

-TEST(RangeTest, IntRangeEmpty) {

-  const ParamGenerator<int> gen = Range(0, 0);

-  VerifyGeneratorIsEmpty(gen);

-}

-

-// Tests that Range() with custom step (greater then one) generates

-// the expected sequence.

-TEST(RangeTest, IntRangeWithCustomStep) {

-  const ParamGenerator<int> gen = Range(0, 9, 3);

-  const int expected_values[] = {0, 3, 6};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Tests that Range() with custom step (greater then one) generates

-// the expected sequence when the last element does not fall on the

-// upper range limit. Sequences generated by Range() must not have

-// elements beyond the range limits.

-TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) {

-  const ParamGenerator<int> gen = Range(0, 4, 3);

-  const int expected_values[] = {0, 3};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Verifies that Range works with user-defined types that define

-// copy constructor, operator=(), operator+(), and operator<().

-class DogAdder {

- public:

-  explicit DogAdder(const char* value) : value_(value) {}

-  DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}

-

-  DogAdder operator=(const DogAdder& other) {

-    if (this != &other)

-      value_ = other.value_;

-    return *this;

-  }

-  DogAdder operator+(const DogAdder& other) const {

-    Message msg;

-    msg << value_.c_str() << other.value_.c_str();

-    return DogAdder(msg.GetString().c_str());

-  }

-  bool operator<(const DogAdder& other) const {

-    return value_ < other.value_;

-  }

-  const ::testing::internal::String& value() const { return value_; }

-

- private:

-  ::testing::internal::String value_;

-};

-

-TEST(RangeTest, WorksWithACustomType) {

-  const ParamGenerator<DogAdder> gen =

-      Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));

-  ParamGenerator<DogAdder>::iterator it = gen.begin();

-

-  ASSERT_FALSE(it == gen.end());

-  EXPECT_STREQ("cat", it->value().c_str());

-

-  ASSERT_FALSE(++it == gen.end());

-  EXPECT_STREQ("catdog", it->value().c_str());

-

-  EXPECT_TRUE(++it == gen.end());

-}

-

-class IntWrapper {

- public:

-  explicit IntWrapper(int value) : value_(value) {}

-  IntWrapper(const IntWrapper& other) : value_(other.value_) {}

-

-  IntWrapper operator=(const IntWrapper& other) {

-    value_ = other.value_;

-    return *this;

-  }

-  // operator+() adds a different type.

-  IntWrapper operator+(int other) const { return IntWrapper(value_ + other); }

-  bool operator<(const IntWrapper& other) const {

-    return value_ < other.value_;

-  }

-  int value() const { return value_; }

-

- private:

-  int value_;

-};

-

-TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) {

-  const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2));

-  ParamGenerator<IntWrapper>::iterator it = gen.begin();

-

-  ASSERT_FALSE(it == gen.end());

-  EXPECT_EQ(0, it->value());

-

-  ASSERT_FALSE(++it == gen.end());

-  EXPECT_EQ(1, it->value());

-

-  EXPECT_TRUE(++it == gen.end());

-}

-

-// Tests that ValuesIn() with an array parameter generates

-// the expected sequence.

-TEST(ValuesInTest, ValuesInArray) {

-  int array[] = {3, 5, 8};

-  const ParamGenerator<int> gen = ValuesIn(array);

-  VerifyGenerator(gen, array);

-}

-

-// Tests that ValuesIn() with a const array parameter generates

-// the expected sequence.

-TEST(ValuesInTest, ValuesInConstArray) {

-  const int array[] = {3, 5, 8};

-  const ParamGenerator<int> gen = ValuesIn(array);

-  VerifyGenerator(gen, array);

-}

-

-// Edge case. Tests that ValuesIn() with an array parameter containing a

-// single element generates the single element sequence.

-TEST(ValuesInTest, ValuesInSingleElementArray) {

-  int array[] = {42};

-  const ParamGenerator<int> gen = ValuesIn(array);

-  VerifyGenerator(gen, array);

-}

-

-// Tests that ValuesIn() generates the expected sequence for an STL

-// container (vector).

-TEST(ValuesInTest, ValuesInVector) {

-  typedef ::std::vector<int> ContainerType;

-  ContainerType values;

-  values.push_back(3);

-  values.push_back(5);

-  values.push_back(8);

-  const ParamGenerator<int> gen = ValuesIn(values);

-

-  const int expected_values[] = {3, 5, 8};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Tests that ValuesIn() generates the expected sequence.

-TEST(ValuesInTest, ValuesInIteratorRange) {

-  typedef ::std::vector<int> ContainerType;

-  ContainerType values;

-  values.push_back(3);

-  values.push_back(5);

-  values.push_back(8);

-  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());

-

-  const int expected_values[] = {3, 5, 8};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Edge case. Tests that ValuesIn() provided with an iterator range specifying a

-// single value generates a single-element sequence.

-TEST(ValuesInTest, ValuesInSingleElementIteratorRange) {

-  typedef ::std::vector<int> ContainerType;

-  ContainerType values;

-  values.push_back(42);

-  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());

-

-  const int expected_values[] = {42};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Edge case. Tests that ValuesIn() provided with an empty iterator range

-// generates an empty sequence.

-TEST(ValuesInTest, ValuesInEmptyIteratorRange) {

-  typedef ::std::vector<int> ContainerType;

-  ContainerType values;

-  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());

-

-  VerifyGeneratorIsEmpty(gen);

-}

-

-// Tests that the Values() generates the expected sequence.

-TEST(ValuesTest, ValuesWorks) {

-  const ParamGenerator<int> gen = Values(3, 5, 8);

-

-  const int expected_values[] = {3, 5, 8};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Tests that Values() generates the expected sequences from elements of

-// different types convertible to ParamGenerator's parameter type.

-TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {

-  const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);

-

-  const double expected_values[] = {3.0, 5.0, 8.0};

-  VerifyGenerator(gen, expected_values);

-}

-

-TEST(ValuesTest, ValuesWorksForMaxLengthList) {

-  const ParamGenerator<int> gen = Values(

-      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,

-      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,

-      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,

-      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,

-      410, 420, 430, 440, 450, 460, 470, 480, 490, 500);

-

-  const int expected_values[] = {

-      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,

-      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,

-      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,

-      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,

-      410, 420, 430, 440, 450, 460, 470, 480, 490, 500};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Edge case test. Tests that single-parameter Values() generates the sequence

-// with the single value.

-TEST(ValuesTest, ValuesWithSingleParameter) {

-  const ParamGenerator<int> gen = Values(42);

-

-  const int expected_values[] = {42};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Tests that Bool() generates sequence (false, true).

-TEST(BoolTest, BoolWorks) {

-  const ParamGenerator<bool> gen = Bool();

-

-  const bool expected_values[] = {false, true};

-  VerifyGenerator(gen, expected_values);

-}

-

-#if GTEST_HAS_COMBINE

-

-template <typename T1, typename T2>

-::std::ostream& operator<<(::std::ostream& stream, const tuple<T1, T2>& value) {

-  stream << "(" << get<0>(value) << ", " << get<1>(value) << ")";

-  return stream;

-}

-

-template <typename T1, typename T2, typename T3>

-::std::ostream& operator<<(::std::ostream& stream,

-                           const tuple<T1, T2, T3>& value) {

-  stream << "(" << get<0>(value) << ", " << get<1>(value)

-         << ", "<< get<2>(value) << ")";

-  return stream;

-}

-

-template <typename T1, typename T2, typename T3, typename T4, typename T5,

-          typename T6, typename T7, typename T8, typename T9, typename T10>

-::std::ostream& operator<<(

-    ::std::ostream& stream,

-    const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) {

-  stream << "(" << get<0>(value) << ", " << get<1>(value)

-         << ", "<< get<2>(value) << ", " << get<3>(value)

-         << ", "<< get<4>(value) << ", " << get<5>(value)

-         << ", "<< get<6>(value) << ", " << get<7>(value)

-         << ", "<< get<8>(value) << ", " << get<9>(value) << ")";

-  return stream;

-}

-

-// Tests that Combine() with two parameters generates the expected sequence.

-TEST(CombineTest, CombineWithTwoParameters) {

-  const char* foo = "foo";

-  const char* bar = "bar";

-  const ParamGenerator<tuple<const char*, int> > gen =

-      Combine(Values(foo, bar), Values(3, 4));

-

-  tuple<const char*, int> expected_values[] = {

-    make_tuple(foo, 3), make_tuple(foo, 4),

-    make_tuple(bar, 3), make_tuple(bar, 4)};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Tests that Combine() with three parameters generates the expected sequence.

-TEST(CombineTest, CombineWithThreeParameters) {

-  const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1),

-                                                            Values(3, 4),

-                                                            Values(5, 6));

-  tuple<int, int, int> expected_values[] = {

-    make_tuple(0, 3, 5), make_tuple(0, 3, 6),

-    make_tuple(0, 4, 5), make_tuple(0, 4, 6),

-    make_tuple(1, 3, 5), make_tuple(1, 3, 6),

-    make_tuple(1, 4, 5), make_tuple(1, 4, 6)};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Tests that the Combine() with the first parameter generating a single value

-// sequence generates a sequence with the number of elements equal to the

-// number of elements in the sequence generated by the second parameter.

-TEST(CombineTest, CombineWithFirstParameterSingleValue) {

-  const ParamGenerator<tuple<int, int> > gen = Combine(Values(42),

-                                                       Values(0, 1));

-

-  tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Tests that the Combine() with the second parameter generating a single value

-// sequence generates a sequence with the number of elements equal to the

-// number of elements in the sequence generated by the first parameter.

-TEST(CombineTest, CombineWithSecondParameterSingleValue) {

-  const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),

-                                                       Values(42));

-

-  tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)};

-  VerifyGenerator(gen, expected_values);

-}

-

-// Tests that when the first parameter produces an empty sequence,

-// Combine() produces an empty sequence, too.

-TEST(CombineTest, CombineWithFirstParameterEmptyRange) {

-  const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0),

-                                                       Values(0, 1));

-  VerifyGeneratorIsEmpty(gen);

-}

-

-// Tests that when the second parameter produces an empty sequence,

-// Combine() produces an empty sequence, too.

-TEST(CombineTest, CombineWithSecondParameterEmptyRange) {

-  const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),

-                                                       Range(1, 1));

-  VerifyGeneratorIsEmpty(gen);

-}

-

-// Edge case. Tests that combine works with the maximum number

-// of parameters supported by Google Test (currently 10).

-TEST(CombineTest, CombineWithMaxNumberOfParameters) {

-  const char* foo = "foo";

-  const char* bar = "bar";

-  const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int,

-                             int, int> > gen = Combine(Values(foo, bar),

-                                                       Values(1), Values(2),

-                                                       Values(3), Values(4),

-                                                       Values(5), Values(6),

-                                                       Values(7), Values(8),

-                                                       Values(9));

-

-  tuple<const char*, int, int, int, int, int, int, int, int, int>

-      expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9),

-                           make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)};

-  VerifyGenerator(gen, expected_values);

-}

-

-#endif  // GTEST_HAS_COMBINE

-

-// Tests that an generator produces correct sequence after being

-// assigned from another generator.

-TEST(ParamGeneratorTest, AssignmentWorks) {

-  ParamGenerator<int> gen = Values(1, 2);

-  const ParamGenerator<int> gen2 = Values(3, 4);

-  gen = gen2;

-

-  const int expected_values[] = {3, 4};

-  VerifyGenerator(gen, expected_values);

-}

-

-// This test verifies that the tests are expanded and run as specified:

-// one test per element from the sequence produced by the generator

-// specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's

-// fixture constructor, SetUp(), and TearDown() have run and have been

-// supplied with the correct parameters.

-

-// The use of environment object allows detection of the case where no test

-// case functionality is run at all. In this case TestCaseTearDown will not

-// be able to detect missing tests, naturally.

-template <int kExpectedCalls>

-class TestGenerationEnvironment : public ::testing::Environment {

- public:

-  static TestGenerationEnvironment* Instance() {

-    static TestGenerationEnvironment* instance = new TestGenerationEnvironment;

-    return instance;

-  }

-

-  void FixtureConstructorExecuted() { fixture_constructor_count_++; }

-  void SetUpExecuted() { set_up_count_++; }

-  void TearDownExecuted() { tear_down_count_++; }

-  void TestBodyExecuted() { test_body_count_++; }

-

-  virtual void TearDown() {

-    // If all MultipleTestGenerationTest tests have been de-selected

-    // by the filter flag, the following checks make no sense.

-    bool perform_check = false;

-

-    for (int i = 0; i < kExpectedCalls; ++i) {

-      Message msg;

-      msg << "TestsExpandedAndRun/" << i;

-      if (UnitTestOptions::FilterMatchesTest(

-             "TestExpansionModule/MultipleTestGenerationTest",

-              msg.GetString().c_str())) {

-        perform_check = true;

-      }

-    }

-    if (perform_check) {

-      EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)

-          << "Fixture constructor of ParamTestGenerationTest test case "

-          << "has not been run as expected.";

-      EXPECT_EQ(kExpectedCalls, set_up_count_)

-          << "Fixture SetUp method of ParamTestGenerationTest test case "

-          << "has not been run as expected.";

-      EXPECT_EQ(kExpectedCalls, tear_down_count_)

-          << "Fixture TearDown method of ParamTestGenerationTest test case "

-          << "has not been run as expected.";

-      EXPECT_EQ(kExpectedCalls, test_body_count_)

-          << "Test in ParamTestGenerationTest test case "

-          << "has not been run as expected.";

-    }

-  }

- private:

-  TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),

-                                tear_down_count_(0), test_body_count_(0) {}

-

-  int fixture_constructor_count_;

-  int set_up_count_;

-  int tear_down_count_;

-  int test_body_count_;

-

-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);

-};

-

-const int test_generation_params[] = {36, 42, 72};

-

-class TestGenerationTest : public TestWithParam<int> {

- public:

-  enum {

-    PARAMETER_COUNT =

-        sizeof(test_generation_params)/sizeof(test_generation_params[0])

-  };

-

-  typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;

-

-  TestGenerationTest() {

-    Environment::Instance()->FixtureConstructorExecuted();

-    current_parameter_ = GetParam();

-  }

-  virtual void SetUp() {

-    Environment::Instance()->SetUpExecuted();

-    EXPECT_EQ(current_parameter_, GetParam());

-  }

-  virtual void TearDown() {

-    Environment::Instance()->TearDownExecuted();

-    EXPECT_EQ(current_parameter_, GetParam());

-  }

-

-  static void SetUpTestCase() {

-    bool all_tests_in_test_case_selected = true;

-

-    for (int i = 0; i < PARAMETER_COUNT; ++i) {

-      Message test_name;

-      test_name << "TestsExpandedAndRun/" << i;

-      if ( !UnitTestOptions::FilterMatchesTest(

-                "TestExpansionModule/MultipleTestGenerationTest",

-                test_name.GetString())) {

-        all_tests_in_test_case_selected = false;

-      }

-    }

-    EXPECT_TRUE(all_tests_in_test_case_selected)

-        << "When running the TestGenerationTest test case all of its tests\n"

-        << "must be selected by the filter flag for the test case to pass.\n"

-        << "If not all of them are enabled, we can't reliably conclude\n"

-        << "that the correct number of tests have been generated.";

-

-    collected_parameters_.clear();

-  }

-

-  static void TearDownTestCase() {

-    vector<int> expected_values(test_generation_params,

-                                test_generation_params + PARAMETER_COUNT);

-    // Test execution order is not guaranteed by Google Test,

-    // so the order of values in collected_parameters_ can be

-    // different and we have to sort to compare.

-    sort(expected_values.begin(), expected_values.end());

-    sort(collected_parameters_.begin(), collected_parameters_.end());

-

-    EXPECT_TRUE(collected_parameters_ == expected_values);

-  }

- protected:

-  int current_parameter_;

-  static vector<int> collected_parameters_;

-

- private:

-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);

-};

-vector<int> TestGenerationTest::collected_parameters_;

-

-TEST_P(TestGenerationTest, TestsExpandedAndRun) {

-  Environment::Instance()->TestBodyExecuted();

-  EXPECT_EQ(current_parameter_, GetParam());

-  collected_parameters_.push_back(GetParam());

-}

-INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest,

-                        ValuesIn(test_generation_params));

-

-// This test verifies that the element sequence (third parameter of

-// INSTANTIATE_TEST_CASE_P) is evaluated in RUN_ALL_TESTS and not at the call

-// site of INSTANTIATE_TEST_CASE_P.

-// For that, we declare param_value_ to be a static member of

-// GeneratorEvaluationTest and initialize it to 0. We set it to 1 in main(),

-// just before invocation of RUN_ALL_TESTS. If the sequence is evaluated

-// before that moment, INSTANTIATE_TEST_CASE_P will create a test with

-// parameter 0, and the test body will fail the assertion.

-class GeneratorEvaluationTest : public TestWithParam<int> {

- public:

-  static int param_value() { return param_value_; }

-  static void set_param_value(int param_value) { param_value_ = param_value; }

-

- private:

-  static int param_value_;

-};

-int GeneratorEvaluationTest::param_value_ = 0;

-

-TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {

-  EXPECT_EQ(1, GetParam());

-}

-INSTANTIATE_TEST_CASE_P(GenEvalModule,

-                        GeneratorEvaluationTest,

-                        Values(GeneratorEvaluationTest::param_value()));

-

-// Tests that generators defined in a different translation unit are

-// functional. Generator extern_gen is defined in gtest-param-test_test2.cc.

-extern ParamGenerator<int> extern_gen;

-class ExternalGeneratorTest : public TestWithParam<int> {};

-TEST_P(ExternalGeneratorTest, ExternalGenerator) {

-  // Sequence produced by extern_gen contains only a single value

-  // which we verify here.

-  EXPECT_EQ(GetParam(), 33);

-}

-INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule,

-                        ExternalGeneratorTest,

-                        extern_gen);

-

-// Tests that a parameterized test case can be defined in one translation

-// unit and instantiated in another. This test will be instantiated in

-// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is

-// defined in gtest-param-test_test.h.

-TEST_P(ExternalInstantiationTest, IsMultipleOf33) {

-  EXPECT_EQ(0, GetParam() % 33);

-}

-

-// Tests that a parameterized test case can be instantiated with multiple

-// generators.

-class MultipleInstantiationTest : public TestWithParam<int> {};

-TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {

-}

-INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));

-INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));

-

-// Tests that a parameterized test case can be instantiated

-// in multiple translation units. This test will be instantiated

-// here and in gtest-param-test_test2.cc.

-// InstantiationInMultipleTranslationUnitsTest fixture class

-// is defined in gtest-param-test_test.h.

-TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) {

-  EXPECT_EQ(0, GetParam() % 42);

-}

-INSTANTIATE_TEST_CASE_P(Sequence1,

-                        InstantiationInMultipleTranslaionUnitsTest,

-                        Values(42, 42*2));

-

-// Tests that each iteration of parameterized test runs in a separate test

-// object.

-class SeparateInstanceTest : public TestWithParam<int> {

- public:

-  SeparateInstanceTest() : count_(0) {}

-

-  static void TearDownTestCase() {

-    EXPECT_GE(global_count_, 2)

-        << "If some (but not all) SeparateInstanceTest tests have been "

-        << "filtered out this test will fail. Make sure that all "

-        << "GeneratorEvaluationTest are selected or de-selected together "

-        << "by the test filter.";

-  }

-

- protected:

-  int count_;

-  static int global_count_;

-};

-int SeparateInstanceTest::global_count_ = 0;

-

-TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {

-  EXPECT_EQ(0, count_++);

-  global_count_++;

-}

-INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4));

-

-// Tests that all instantiations of a test have named appropriately. Test

-// defined with TEST_P(TestCaseName, TestName) and instantiated with

-// INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named

-// SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the

-// sequence element used to instantiate the test.

-class NamingTest : public TestWithParam<int> {};

-

-TEST_P(NamingTest, TestsAreNamedAppropriately) {

-  const ::testing::TestInfo* const test_info =

-     ::testing::UnitTest::GetInstance()->current_test_info();

-

-  EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name());

-

-  Message msg;

-  msg << "TestsAreNamedAppropriately/" << GetParam();

-  EXPECT_STREQ(msg.GetString().c_str(), test_info->name());

-}

-

-INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));

-

-#endif  // GTEST_HAS_PARAM_TEST

-

-TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {

-#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) {

-#if GTEST_HAS_PARAM_TEST

-  // Used in TestGenerationTest test case.

-  AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());

-  // Used in GeneratorEvaluationTest test case.

-  GeneratorEvaluationTest::set_param_value(1);

-#endif  // GTEST_HAS_PARAM_TEST

-

-  ::testing::InitGoogleTest(&argc, argv);

-  return RUN_ALL_TESTS();

-}

+// Copyright 2008, 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: [email protected] (Vlad Losev)
+//
+// Tests for Google Test itself. This file verifies that the parameter
+// generators objects produce correct parameter sequences and that
+// Google Test runtime instantiates correct tests from those sequences.
+
+#include <gtest/gtest.h>
+
+#if GTEST_HAS_PARAM_TEST
+
+#include <algorithm>
+#include <iostream>
+#include <list>
+#include <vector>
+
+// To include gtest-internal-inl.h.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"  // for UnitTestOptions
+#undef GTEST_IMPLEMENTATION_
+
+#include "test/gtest-param-test_test.h"
+
+using ::std::vector;
+using ::std::sort;
+
+using ::testing::AddGlobalTestEnvironment;
+using ::testing::Bool;
+using ::testing::Message;
+using ::testing::Range;
+using ::testing::TestWithParam;
+using ::testing::Values;
+using ::testing::ValuesIn;
+
+#if GTEST_HAS_COMBINE
+using ::testing::Combine;
+using ::std::tr1::get;
+using ::std::tr1::make_tuple;
+using ::std::tr1::tuple;
+#endif  // GTEST_HAS_COMBINE
+
+using ::testing::internal::ParamGenerator;
+using ::testing::internal::UnitTestOptions;
+
+// Verifies that a sequence generated by the generator and accessed
+// via the iterator object matches the expected one using Google Test
+// assertions.
+template <typename T, size_t N>
+void VerifyGenerator(const ParamGenerator<T>& generator,
+                     const T (&expected_values)[N]) {
+  typename ParamGenerator<T>::iterator it = generator.begin();
+  for (size_t i = 0; i < N; ++i) {
+    ASSERT_FALSE(it == generator.end())
+        << "At element " << i << " when accessing via an iterator "
+        << "created with the copy constructor." << std::endl;
+    EXPECT_EQ(expected_values[i], *it)
+        << "At element " << i << " when accessing via an iterator "
+        << "created with the copy constructor." << std::endl;
+    it++;
+  }
+  EXPECT_TRUE(it == generator.end())
+        << "At the presumed end of sequence when accessing via an iterator "
+        << "created with the copy constructor." << std::endl;
+
+  // Test the iterator assignment. The following lines verify that
+  // the sequence accessed via an iterator initialized via the
+  // assignment operator (as opposed to a copy constructor) matches
+  // just the same.
+  it = generator.begin();
+  for (size_t i = 0; i < N; ++i) {
+    ASSERT_FALSE(it == generator.end())
+        << "At element " << i << " when accessing via an iterator "
+        << "created with the assignment operator." << std::endl;
+    EXPECT_EQ(expected_values[i], *it)
+        << "At element " << i << " when accessing via an iterator "
+        << "created with the assignment operator." << std::endl;
+    it++;
+  }
+  EXPECT_TRUE(it == generator.end())
+        << "At the presumed end of sequence when accessing via an iterator "
+        << "created with the assignment operator." << std::endl;
+}
+
+template <typename T>
+void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {
+  typename ParamGenerator<T>::iterator it = generator.begin();
+  EXPECT_TRUE(it == generator.end());
+
+  it = generator.begin();
+  EXPECT_TRUE(it == generator.end());
+}
+
+// Generator tests. They test that each of the provided generator functions
+// generates an expected sequence of values. The general test pattern
+// instantiates a generator using one of the generator functions,
+// checks the sequence produced by the generator using its iterator API,
+// and then resets the iterator back to the beginning of the sequence
+// and checks the sequence again.
+
+// Tests that iterators produced by generator functions conform to the
+// ForwardIterator concept.
+TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
+  const ParamGenerator<int> gen = Range(0, 10);
+  ParamGenerator<int>::iterator it = gen.begin();
+
+  // Verifies that iterator initialization works as expected.
+  ParamGenerator<int>::iterator it2 = it;
+  EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the "
+                           << "element same as its source points to";
+
+  // Verifies that iterator assignment works as expected.
+  it++;
+  EXPECT_FALSE(*it == *it2);
+  it2 = it;
+  EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "
+                           << "element same as its source points to";
+
+  // Verifies that prefix operator++() returns *this.
+  EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be "
+                          << "refer to the original object";
+
+  // Verifies that the result of the postfix operator++ points to the value
+  // pointed to by the original iterator.
+  int original_value = *it;  // Have to compute it outside of macro call to be
+                             // unaffected by the parameter evaluation order.
+  EXPECT_EQ(original_value, *(it++));
+
+  // Verifies that prefix and postfix operator++() advance an iterator
+  // all the same.
+  it2 = it;
+  it++;
+  ++it2;
+  EXPECT_TRUE(*it == *it2);
+}
+
+// Tests that Range() generates the expected sequence.
+TEST(RangeTest, IntRangeWithDefaultStep) {
+  const ParamGenerator<int> gen = Range(0, 3);
+  const int expected_values[] = {0, 1, 2};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case. Tests that Range() generates the single element sequence
+// as expected when provided with range limits that are equal.
+TEST(RangeTest, IntRangeSingleValue) {
+  const ParamGenerator<int> gen = Range(0, 1);
+  const int expected_values[] = {0};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case. Tests that Range() with generates empty sequence when
+// supplied with an empty range.
+TEST(RangeTest, IntRangeEmpty) {
+  const ParamGenerator<int> gen = Range(0, 0);
+  VerifyGeneratorIsEmpty(gen);
+}
+
+// Tests that Range() with custom step (greater then one) generates
+// the expected sequence.
+TEST(RangeTest, IntRangeWithCustomStep) {
+  const ParamGenerator<int> gen = Range(0, 9, 3);
+  const int expected_values[] = {0, 3, 6};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that Range() with custom step (greater then one) generates
+// the expected sequence when the last element does not fall on the
+// upper range limit. Sequences generated by Range() must not have
+// elements beyond the range limits.
+TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) {
+  const ParamGenerator<int> gen = Range(0, 4, 3);
+  const int expected_values[] = {0, 3};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Verifies that Range works with user-defined types that define
+// copy constructor, operator=(), operator+(), and operator<().
+class DogAdder {
+ public:
+  explicit DogAdder(const char* value) : value_(value) {}
+  DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
+
+  DogAdder operator=(const DogAdder& other) {
+    if (this != &other)
+      value_ = other.value_;
+    return *this;
+  }
+  DogAdder operator+(const DogAdder& other) const {
+    Message msg;
+    msg << value_.c_str() << other.value_.c_str();
+    return DogAdder(msg.GetString().c_str());
+  }
+  bool operator<(const DogAdder& other) const {
+    return value_ < other.value_;
+  }
+  const ::testing::internal::String& value() const { return value_; }
+
+ private:
+  ::testing::internal::String value_;
+};
+
+TEST(RangeTest, WorksWithACustomType) {
+  const ParamGenerator<DogAdder> gen =
+      Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
+  ParamGenerator<DogAdder>::iterator it = gen.begin();
+
+  ASSERT_FALSE(it == gen.end());
+  EXPECT_STREQ("cat", it->value().c_str());
+
+  ASSERT_FALSE(++it == gen.end());
+  EXPECT_STREQ("catdog", it->value().c_str());
+
+  EXPECT_TRUE(++it == gen.end());
+}
+
+class IntWrapper {
+ public:
+  explicit IntWrapper(int value) : value_(value) {}
+  IntWrapper(const IntWrapper& other) : value_(other.value_) {}
+
+  IntWrapper operator=(const IntWrapper& other) {
+    value_ = other.value_;
+    return *this;
+  }
+  // operator+() adds a different type.
+  IntWrapper operator+(int other) const { return IntWrapper(value_ + other); }
+  bool operator<(const IntWrapper& other) const {
+    return value_ < other.value_;
+  }
+  int value() const { return value_; }
+
+ private:
+  int value_;
+};
+
+TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) {
+  const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2));
+  ParamGenerator<IntWrapper>::iterator it = gen.begin();
+
+  ASSERT_FALSE(it == gen.end());
+  EXPECT_EQ(0, it->value());
+
+  ASSERT_FALSE(++it == gen.end());
+  EXPECT_EQ(1, it->value());
+
+  EXPECT_TRUE(++it == gen.end());
+}
+
+// Tests that ValuesIn() with an array parameter generates
+// the expected sequence.
+TEST(ValuesInTest, ValuesInArray) {
+  int array[] = {3, 5, 8};
+  const ParamGenerator<int> gen = ValuesIn(array);
+  VerifyGenerator(gen, array);
+}
+
+// Tests that ValuesIn() with a const array parameter generates
+// the expected sequence.
+TEST(ValuesInTest, ValuesInConstArray) {
+  const int array[] = {3, 5, 8};
+  const ParamGenerator<int> gen = ValuesIn(array);
+  VerifyGenerator(gen, array);
+}
+
+// Edge case. Tests that ValuesIn() with an array parameter containing a
+// single element generates the single element sequence.
+TEST(ValuesInTest, ValuesInSingleElementArray) {
+  int array[] = {42};
+  const ParamGenerator<int> gen = ValuesIn(array);
+  VerifyGenerator(gen, array);
+}
+
+// Tests that ValuesIn() generates the expected sequence for an STL
+// container (vector).
+TEST(ValuesInTest, ValuesInVector) {
+  typedef ::std::vector<int> ContainerType;
+  ContainerType values;
+  values.push_back(3);
+  values.push_back(5);
+  values.push_back(8);
+  const ParamGenerator<int> gen = ValuesIn(values);
+
+  const int expected_values[] = {3, 5, 8};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that ValuesIn() generates the expected sequence.
+TEST(ValuesInTest, ValuesInIteratorRange) {
+  typedef ::std::vector<int> ContainerType;
+  ContainerType values;
+  values.push_back(3);
+  values.push_back(5);
+  values.push_back(8);
+  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
+
+  const int expected_values[] = {3, 5, 8};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case. Tests that ValuesIn() provided with an iterator range specifying a
+// single value generates a single-element sequence.
+TEST(ValuesInTest, ValuesInSingleElementIteratorRange) {
+  typedef ::std::vector<int> ContainerType;
+  ContainerType values;
+  values.push_back(42);
+  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
+
+  const int expected_values[] = {42};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case. Tests that ValuesIn() provided with an empty iterator range
+// generates an empty sequence.
+TEST(ValuesInTest, ValuesInEmptyIteratorRange) {
+  typedef ::std::vector<int> ContainerType;
+  ContainerType values;
+  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
+
+  VerifyGeneratorIsEmpty(gen);
+}
+
+// Tests that the Values() generates the expected sequence.
+TEST(ValuesTest, ValuesWorks) {
+  const ParamGenerator<int> gen = Values(3, 5, 8);
+
+  const int expected_values[] = {3, 5, 8};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that Values() generates the expected sequences from elements of
+// different types convertible to ParamGenerator's parameter type.
+TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
+  const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);
+
+  const double expected_values[] = {3.0, 5.0, 8.0};
+  VerifyGenerator(gen, expected_values);
+}
+
+TEST(ValuesTest, ValuesWorksForMaxLengthList) {
+  const ParamGenerator<int> gen = Values(
+      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
+      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
+      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
+      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
+      410, 420, 430, 440, 450, 460, 470, 480, 490, 500);
+
+  const int expected_values[] = {
+      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
+      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
+      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
+      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
+      410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case test. Tests that single-parameter Values() generates the sequence
+// with the single value.
+TEST(ValuesTest, ValuesWithSingleParameter) {
+  const ParamGenerator<int> gen = Values(42);
+
+  const int expected_values[] = {42};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that Bool() generates sequence (false, true).
+TEST(BoolTest, BoolWorks) {
+  const ParamGenerator<bool> gen = Bool();
+
+  const bool expected_values[] = {false, true};
+  VerifyGenerator(gen, expected_values);
+}
+
+#if GTEST_HAS_COMBINE
+
+template <typename T1, typename T2>
+::std::ostream& operator<<(::std::ostream& stream, const tuple<T1, T2>& value) {
+  stream << "(" << get<0>(value) << ", " << get<1>(value) << ")";
+  return stream;
+}
+
+template <typename T1, typename T2, typename T3>
+::std::ostream& operator<<(::std::ostream& stream,
+                           const tuple<T1, T2, T3>& value) {
+  stream << "(" << get<0>(value) << ", " << get<1>(value)
+         << ", "<< get<2>(value) << ")";
+  return stream;
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10>
+::std::ostream& operator<<(
+    ::std::ostream& stream,
+    const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) {
+  stream << "(" << get<0>(value) << ", " << get<1>(value)
+         << ", "<< get<2>(value) << ", " << get<3>(value)
+         << ", "<< get<4>(value) << ", " << get<5>(value)
+         << ", "<< get<6>(value) << ", " << get<7>(value)
+         << ", "<< get<8>(value) << ", " << get<9>(value) << ")";
+  return stream;
+}
+
+// Tests that Combine() with two parameters generates the expected sequence.
+TEST(CombineTest, CombineWithTwoParameters) {
+  const char* foo = "foo";
+  const char* bar = "bar";
+  const ParamGenerator<tuple<const char*, int> > gen =
+      Combine(Values(foo, bar), Values(3, 4));
+
+  tuple<const char*, int> expected_values[] = {
+    make_tuple(foo, 3), make_tuple(foo, 4),
+    make_tuple(bar, 3), make_tuple(bar, 4)};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that Combine() with three parameters generates the expected sequence.
+TEST(CombineTest, CombineWithThreeParameters) {
+  const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1),
+                                                            Values(3, 4),
+                                                            Values(5, 6));
+  tuple<int, int, int> expected_values[] = {
+    make_tuple(0, 3, 5), make_tuple(0, 3, 6),
+    make_tuple(0, 4, 5), make_tuple(0, 4, 6),
+    make_tuple(1, 3, 5), make_tuple(1, 3, 6),
+    make_tuple(1, 4, 5), make_tuple(1, 4, 6)};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that the Combine() with the first parameter generating a single value
+// sequence generates a sequence with the number of elements equal to the
+// number of elements in the sequence generated by the second parameter.
+TEST(CombineTest, CombineWithFirstParameterSingleValue) {
+  const ParamGenerator<tuple<int, int> > gen = Combine(Values(42),
+                                                       Values(0, 1));
+
+  tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that the Combine() with the second parameter generating a single value
+// sequence generates a sequence with the number of elements equal to the
+// number of elements in the sequence generated by the first parameter.
+TEST(CombineTest, CombineWithSecondParameterSingleValue) {
+  const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
+                                                       Values(42));
+
+  tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that when the first parameter produces an empty sequence,
+// Combine() produces an empty sequence, too.
+TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
+  const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0),
+                                                       Values(0, 1));
+  VerifyGeneratorIsEmpty(gen);
+}
+
+// Tests that when the second parameter produces an empty sequence,
+// Combine() produces an empty sequence, too.
+TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
+  const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
+                                                       Range(1, 1));
+  VerifyGeneratorIsEmpty(gen);
+}
+
+// Edge case. Tests that combine works with the maximum number
+// of parameters supported by Google Test (currently 10).
+TEST(CombineTest, CombineWithMaxNumberOfParameters) {
+  const char* foo = "foo";
+  const char* bar = "bar";
+  const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int,
+                             int, int> > gen = Combine(Values(foo, bar),
+                                                       Values(1), Values(2),
+                                                       Values(3), Values(4),
+                                                       Values(5), Values(6),
+                                                       Values(7), Values(8),
+                                                       Values(9));
+
+  tuple<const char*, int, int, int, int, int, int, int, int, int>
+      expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9),
+                           make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)};
+  VerifyGenerator(gen, expected_values);
+}
+
+#endif  // GTEST_HAS_COMBINE
+
+// Tests that an generator produces correct sequence after being
+// assigned from another generator.
+TEST(ParamGeneratorTest, AssignmentWorks) {
+  ParamGenerator<int> gen = Values(1, 2);
+  const ParamGenerator<int> gen2 = Values(3, 4);
+  gen = gen2;
+
+  const int expected_values[] = {3, 4};
+  VerifyGenerator(gen, expected_values);
+}
+
+// This test verifies that the tests are expanded and run as specified:
+// one test per element from the sequence produced by the generator
+// specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's
+// fixture constructor, SetUp(), and TearDown() have run and have been
+// supplied with the correct parameters.
+
+// The use of environment object allows detection of the case where no test
+// case functionality is run at all. In this case TestCaseTearDown will not
+// be able to detect missing tests, naturally.
+template <int kExpectedCalls>
+class TestGenerationEnvironment : public ::testing::Environment {
+ public:
+  static TestGenerationEnvironment* Instance() {
+    static TestGenerationEnvironment* instance = new TestGenerationEnvironment;
+    return instance;
+  }
+
+  void FixtureConstructorExecuted() { fixture_constructor_count_++; }
+  void SetUpExecuted() { set_up_count_++; }
+  void TearDownExecuted() { tear_down_count_++; }
+  void TestBodyExecuted() { test_body_count_++; }
+
+  virtual void TearDown() {
+    // If all MultipleTestGenerationTest tests have been de-selected
+    // by the filter flag, the following checks make no sense.
+    bool perform_check = false;
+
+    for (int i = 0; i < kExpectedCalls; ++i) {
+      Message msg;
+      msg << "TestsExpandedAndRun/" << i;
+      if (UnitTestOptions::FilterMatchesTest(
+             "TestExpansionModule/MultipleTestGenerationTest",
+              msg.GetString().c_str())) {
+        perform_check = true;
+      }
+    }
+    if (perform_check) {
+      EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)
+          << "Fixture constructor of ParamTestGenerationTest test case "
+          << "has not been run as expected.";
+      EXPECT_EQ(kExpectedCalls, set_up_count_)
+          << "Fixture SetUp method of ParamTestGenerationTest test case "
+          << "has not been run as expected.";
+      EXPECT_EQ(kExpectedCalls, tear_down_count_)
+          << "Fixture TearDown method of ParamTestGenerationTest test case "
+          << "has not been run as expected.";
+      EXPECT_EQ(kExpectedCalls, test_body_count_)
+          << "Test in ParamTestGenerationTest test case "
+          << "has not been run as expected.";
+    }
+  }
+ private:
+  TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),
+                                tear_down_count_(0), test_body_count_(0) {}
+
+  int fixture_constructor_count_;
+  int set_up_count_;
+  int tear_down_count_;
+  int test_body_count_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);
+};
+
+const int test_generation_params[] = {36, 42, 72};
+
+class TestGenerationTest : public TestWithParam<int> {
+ public:
+  enum {
+    PARAMETER_COUNT =
+        sizeof(test_generation_params)/sizeof(test_generation_params[0])
+  };
+
+  typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
+
+  TestGenerationTest() {
+    Environment::Instance()->FixtureConstructorExecuted();
+    current_parameter_ = GetParam();
+  }
+  virtual void SetUp() {
+    Environment::Instance()->SetUpExecuted();
+    EXPECT_EQ(current_parameter_, GetParam());
+  }
+  virtual void TearDown() {
+    Environment::Instance()->TearDownExecuted();
+    EXPECT_EQ(current_parameter_, GetParam());
+  }
+
+  static void SetUpTestCase() {
+    bool all_tests_in_test_case_selected = true;
+
+    for (int i = 0; i < PARAMETER_COUNT; ++i) {
+      Message test_name;
+      test_name << "TestsExpandedAndRun/" << i;
+      if ( !UnitTestOptions::FilterMatchesTest(
+                "TestExpansionModule/MultipleTestGenerationTest",
+                test_name.GetString())) {
+        all_tests_in_test_case_selected = false;
+      }
+    }
+    EXPECT_TRUE(all_tests_in_test_case_selected)
+        << "When running the TestGenerationTest test case all of its tests\n"
+        << "must be selected by the filter flag for the test case to pass.\n"
+        << "If not all of them are enabled, we can't reliably conclude\n"
+        << "that the correct number of tests have been generated.";
+
+    collected_parameters_.clear();
+  }
+
+  static void TearDownTestCase() {
+    vector<int> expected_values(test_generation_params,
+                                test_generation_params + PARAMETER_COUNT);
+    // Test execution order is not guaranteed by Google Test,
+    // so the order of values in collected_parameters_ can be
+    // different and we have to sort to compare.
+    sort(expected_values.begin(), expected_values.end());
+    sort(collected_parameters_.begin(), collected_parameters_.end());
+
+    EXPECT_TRUE(collected_parameters_ == expected_values);
+  }
+ protected:
+  int current_parameter_;
+  static vector<int> collected_parameters_;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);
+};
+vector<int> TestGenerationTest::collected_parameters_;
+
+TEST_P(TestGenerationTest, TestsExpandedAndRun) {
+  Environment::Instance()->TestBodyExecuted();
+  EXPECT_EQ(current_parameter_, GetParam());
+  collected_parameters_.push_back(GetParam());
+}
+INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest,
+                        ValuesIn(test_generation_params));
+
+// This test verifies that the element sequence (third parameter of
+// INSTANTIATE_TEST_CASE_P) is evaluated in RUN_ALL_TESTS and not at the call
+// site of INSTANTIATE_TEST_CASE_P.
+// For that, we declare param_value_ to be a static member of
+// GeneratorEvaluationTest and initialize it to 0. We set it to 1 in main(),
+// just before invocation of RUN_ALL_TESTS. If the sequence is evaluated
+// before that moment, INSTANTIATE_TEST_CASE_P will create a test with
+// parameter 0, and the test body will fail the assertion.
+class GeneratorEvaluationTest : public TestWithParam<int> {
+ public:
+  static int param_value() { return param_value_; }
+  static void set_param_value(int param_value) { param_value_ = param_value; }
+
+ private:
+  static int param_value_;
+};
+int GeneratorEvaluationTest::param_value_ = 0;
+
+TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {
+  EXPECT_EQ(1, GetParam());
+}
+INSTANTIATE_TEST_CASE_P(GenEvalModule,
+                        GeneratorEvaluationTest,
+                        Values(GeneratorEvaluationTest::param_value()));
+
+// Tests that generators defined in a different translation unit are
+// functional. Generator extern_gen is defined in gtest-param-test_test2.cc.
+extern ParamGenerator<int> extern_gen;
+class ExternalGeneratorTest : public TestWithParam<int> {};
+TEST_P(ExternalGeneratorTest, ExternalGenerator) {
+  // Sequence produced by extern_gen contains only a single value
+  // which we verify here.
+  EXPECT_EQ(GetParam(), 33);
+}
+INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule,
+                        ExternalGeneratorTest,
+                        extern_gen);
+
+// Tests that a parameterized test case can be defined in one translation
+// unit and instantiated in another. This test will be instantiated in
+// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is
+// defined in gtest-param-test_test.h.
+TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
+  EXPECT_EQ(0, GetParam() % 33);
+}
+
+// Tests that a parameterized test case can be instantiated with multiple
+// generators.
+class MultipleInstantiationTest : public TestWithParam<int> {};
+TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {
+}
+INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
+INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));
+
+// Tests that a parameterized test case can be instantiated
+// in multiple translation units. This test will be instantiated
+// here and in gtest-param-test_test2.cc.
+// InstantiationInMultipleTranslationUnitsTest fixture class
+// is defined in gtest-param-test_test.h.
+TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) {
+  EXPECT_EQ(0, GetParam() % 42);
+}
+INSTANTIATE_TEST_CASE_P(Sequence1,
+                        InstantiationInMultipleTranslaionUnitsTest,
+                        Values(42, 42*2));
+
+// Tests that each iteration of parameterized test runs in a separate test
+// object.
+class SeparateInstanceTest : public TestWithParam<int> {
+ public:
+  SeparateInstanceTest() : count_(0) {}
+
+  static void TearDownTestCase() {
+    EXPECT_GE(global_count_, 2)
+        << "If some (but not all) SeparateInstanceTest tests have been "
+        << "filtered out this test will fail. Make sure that all "
+        << "GeneratorEvaluationTest are selected or de-selected together "
+        << "by the test filter.";
+  }
+
+ protected:
+  int count_;
+  static int global_count_;
+};
+int SeparateInstanceTest::global_count_ = 0;
+
+TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {
+  EXPECT_EQ(0, count_++);
+  global_count_++;
+}
+INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4));
+
+// Tests that all instantiations of a test have named appropriately. Test
+// defined with TEST_P(TestCaseName, TestName) and instantiated with
+// INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named
+// SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the
+// sequence element used to instantiate the test.
+class NamingTest : public TestWithParam<int> {};
+
+TEST_P(NamingTest, TestsAreNamedAppropriately) {
+  const ::testing::TestInfo* const test_info =
+     ::testing::UnitTest::GetInstance()->current_test_info();
+
+  EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name());
+
+  Message msg;
+  msg << "TestsAreNamedAppropriately/" << GetParam();
+  EXPECT_STREQ(msg.GetString().c_str(), test_info->name());
+}
+
+INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
+#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) {
+#if GTEST_HAS_PARAM_TEST
+  // Used in TestGenerationTest test case.
+  AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
+  // Used in GeneratorEvaluationTest test case.
+  GeneratorEvaluationTest::set_param_value(1);
+#endif  // GTEST_HAS_PARAM_TEST
+
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-port_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-port_test.cc
index 07153138..df59f9e8 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-port_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-port_test.cc
@@ -1,699 +1,699 @@
-// Copyright 2008, 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.

-//

-// Authors: [email protected] (Vlad Losev), [email protected] (Zhanyong Wan)

-//

-// This file tests the internal cross-platform support utilities.

-

-#include <gtest/internal/gtest-port.h>

-

-#if GTEST_OS_MAC

-#include <pthread.h>

-#include <time.h>

-#endif  // GTEST_OS_MAC

-

-#include <gtest/gtest.h>

-#include <gtest/gtest-spi.h>

-

-// 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_

-

-namespace testing {

-namespace internal {

-

-TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {

-  if (AlwaysFalse())

-    GTEST_CHECK_(false) << "This should never be executed; "

-                           "It's a compilation test only.";

-

-  if (AlwaysTrue())

-    GTEST_CHECK_(true);

-  else

-    ;  // NOLINT

-

-  if (AlwaysFalse())

-    ;  // NOLINT

-  else

-    GTEST_CHECK_(true) << "";

-}

-

-TEST(GtestCheckSyntaxTest, WorksWithSwitch) {

-  switch (0) {

-    case 1:

-      break;

-    default:

-      GTEST_CHECK_(true);

-  }

-

-  switch(0)

-    case 0:

-      GTEST_CHECK_(true) << "Check failed in switch case";

-}

-

-#if GTEST_OS_MAC

-void* ThreadFunc(void* data) {

-  pthread_mutex_t* mutex = reinterpret_cast<pthread_mutex_t*>(data);

-  pthread_mutex_lock(mutex);

-  pthread_mutex_unlock(mutex);

-  return NULL;

-}

-

-TEST(GetThreadCountTest, ReturnsCorrectValue) {

-  EXPECT_EQ(1U, GetThreadCount());

-  pthread_mutex_t mutex;

-  pthread_attr_t  attr;

-  pthread_t       thread_id;

-

-  // TODO([email protected]): turn mutex into internal::Mutex for automatic

-  // destruction.

-  pthread_mutex_init(&mutex, NULL);

-  pthread_mutex_lock(&mutex);

-  ASSERT_EQ(0, pthread_attr_init(&attr));

-  ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));

-

-  const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);

-  ASSERT_EQ(0, pthread_attr_destroy(&attr));

-  ASSERT_EQ(0, status);

-  EXPECT_EQ(2U, GetThreadCount());

-  pthread_mutex_unlock(&mutex);

-

-  void* dummy;

-  ASSERT_EQ(0, pthread_join(thread_id, &dummy));

-

-  // MacOS X may not immediately report the updated thread count after

-  // joining a thread, causing flakiness in this test. To counter that, we

-  // wait for up to .5 seconds for the OS to report the correct value.

-  for (int i = 0; i < 5; ++i) {

-    if (GetThreadCount() == 1)

-      break;

-

-    timespec time;

-    time.tv_sec = 0;

-    time.tv_nsec = 100L * 1000 * 1000;  // .1 seconds.

-    nanosleep(&time, NULL);

-  }

-  EXPECT_EQ(1U, GetThreadCount());

-  pthread_mutex_destroy(&mutex);

-}

-#else

-TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {

-  EXPECT_EQ(0U, GetThreadCount());

-}

-#endif  // GTEST_OS_MAC

-

-TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {

-  const bool a_false_condition = false;

-  const char regex[] =

-#ifdef _MSC_VER

-     "gtest-port_test\\.cc\\(\\d+\\):"

-#else

-     "gtest-port_test\\.cc:[0-9]+"

-#endif  // _MSC_VER

-     ".*a_false_condition.*Extra info.*";

-

-  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",

-                            regex);

-}

-

-#if GTEST_HAS_DEATH_TEST

-

-TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {

-  EXPECT_EXIT({

-      GTEST_CHECK_(true) << "Extra info";

-      ::std::cerr << "Success\n";

-      exit(0); },

-      ::testing::ExitedWithCode(0), "Success");

-}

-

-#endif  // GTEST_HAS_DEATH_TEST

-

-#if GTEST_USES_POSIX_RE

-

-template <typename Str>

-class RETest : public ::testing::Test {};

-

-// Defines StringTypes as the list of all string types that class RE

-// supports.

-typedef testing::Types<

-#if GTEST_HAS_STD_STRING

-    ::std::string,

-#endif  // GTEST_HAS_STD_STRING

-#if GTEST_HAS_GLOBAL_STRING

-    ::string,

-#endif  // GTEST_HAS_GLOBAL_STRING

-    const char*> StringTypes;

-

-TYPED_TEST_CASE(RETest, StringTypes);

-

-// Tests RE's implicit constructors.

-TYPED_TEST(RETest, ImplicitConstructorWorks) {

-  const RE empty(TypeParam(""));

-  EXPECT_STREQ("", empty.pattern());

-

-  const RE simple(TypeParam("hello"));

-  EXPECT_STREQ("hello", simple.pattern());

-

-  const RE normal(TypeParam(".*(\\w+)"));

-  EXPECT_STREQ(".*(\\w+)", normal.pattern());

-}

-

-// Tests that RE's constructors reject invalid regular expressions.

-TYPED_TEST(RETest, RejectsInvalidRegex) {

-  EXPECT_NONFATAL_FAILURE({

-    const RE invalid(TypeParam("?"));

-  }, "\"?\" is not a valid POSIX Extended regular expression.");

-}

-

-// Tests RE::FullMatch().

-TYPED_TEST(RETest, FullMatchWorks) {

-  const RE empty(TypeParam(""));

-  EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty));

-  EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty));

-

-  const RE re(TypeParam("a.*z"));

-  EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re));

-  EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re));

-  EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re));

-  EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re));

-}

-

-// Tests RE::PartialMatch().

-TYPED_TEST(RETest, PartialMatchWorks) {

-  const RE empty(TypeParam(""));

-  EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty));

-  EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));

-

-  const RE re(TypeParam("a.*z"));

-  EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));

-  EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));

-  EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));

-  EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));

-  EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));

-}

-

-#elif GTEST_USES_SIMPLE_RE

-

-TEST(IsInSetTest, NulCharIsNotInAnySet) {

-  EXPECT_FALSE(IsInSet('\0', ""));

-  EXPECT_FALSE(IsInSet('\0', "\0"));

-  EXPECT_FALSE(IsInSet('\0', "a"));

-}

-

-TEST(IsInSetTest, WorksForNonNulChars) {

-  EXPECT_FALSE(IsInSet('a', "Ab"));

-  EXPECT_FALSE(IsInSet('c', ""));

-

-  EXPECT_TRUE(IsInSet('b', "bcd"));

-  EXPECT_TRUE(IsInSet('b', "ab"));

-}

-

-TEST(IsDigitTest, IsFalseForNonDigit) {

-  EXPECT_FALSE(IsDigit('\0'));

-  EXPECT_FALSE(IsDigit(' '));

-  EXPECT_FALSE(IsDigit('+'));

-  EXPECT_FALSE(IsDigit('-'));

-  EXPECT_FALSE(IsDigit('.'));

-  EXPECT_FALSE(IsDigit('a'));

-}

-

-TEST(IsDigitTest, IsTrueForDigit) {

-  EXPECT_TRUE(IsDigit('0'));

-  EXPECT_TRUE(IsDigit('1'));

-  EXPECT_TRUE(IsDigit('5'));

-  EXPECT_TRUE(IsDigit('9'));

-}

-

-TEST(IsPunctTest, IsFalseForNonPunct) {

-  EXPECT_FALSE(IsPunct('\0'));

-  EXPECT_FALSE(IsPunct(' '));

-  EXPECT_FALSE(IsPunct('\n'));

-  EXPECT_FALSE(IsPunct('a'));

-  EXPECT_FALSE(IsPunct('0'));

-}

-

-TEST(IsPunctTest, IsTrueForPunct) {

-  for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) {

-    EXPECT_PRED1(IsPunct, *p);

-  }

-}

-

-TEST(IsRepeatTest, IsFalseForNonRepeatChar) {

-  EXPECT_FALSE(IsRepeat('\0'));

-  EXPECT_FALSE(IsRepeat(' '));

-  EXPECT_FALSE(IsRepeat('a'));

-  EXPECT_FALSE(IsRepeat('1'));

-  EXPECT_FALSE(IsRepeat('-'));

-}

-

-TEST(IsRepeatTest, IsTrueForRepeatChar) {

-  EXPECT_TRUE(IsRepeat('?'));

-  EXPECT_TRUE(IsRepeat('*'));

-  EXPECT_TRUE(IsRepeat('+'));

-}

-

-TEST(IsWhiteSpaceTest, IsFalseForNonWhiteSpace) {

-  EXPECT_FALSE(IsWhiteSpace('\0'));

-  EXPECT_FALSE(IsWhiteSpace('a'));

-  EXPECT_FALSE(IsWhiteSpace('1'));

-  EXPECT_FALSE(IsWhiteSpace('+'));

-  EXPECT_FALSE(IsWhiteSpace('_'));

-}

-

-TEST(IsWhiteSpaceTest, IsTrueForWhiteSpace) {

-  EXPECT_TRUE(IsWhiteSpace(' '));

-  EXPECT_TRUE(IsWhiteSpace('\n'));

-  EXPECT_TRUE(IsWhiteSpace('\r'));

-  EXPECT_TRUE(IsWhiteSpace('\t'));

-  EXPECT_TRUE(IsWhiteSpace('\v'));

-  EXPECT_TRUE(IsWhiteSpace('\f'));

-}

-

-TEST(IsWordCharTest, IsFalseForNonWordChar) {

-  EXPECT_FALSE(IsWordChar('\0'));

-  EXPECT_FALSE(IsWordChar('+'));

-  EXPECT_FALSE(IsWordChar('.'));

-  EXPECT_FALSE(IsWordChar(' '));

-  EXPECT_FALSE(IsWordChar('\n'));

-}

-

-TEST(IsWordCharTest, IsTrueForLetter) {

-  EXPECT_TRUE(IsWordChar('a'));

-  EXPECT_TRUE(IsWordChar('b'));

-  EXPECT_TRUE(IsWordChar('A'));

-  EXPECT_TRUE(IsWordChar('Z'));

-}

-

-TEST(IsWordCharTest, IsTrueForDigit) {

-  EXPECT_TRUE(IsWordChar('0'));

-  EXPECT_TRUE(IsWordChar('1'));

-  EXPECT_TRUE(IsWordChar('7'));

-  EXPECT_TRUE(IsWordChar('9'));

-}

-

-TEST(IsWordCharTest, IsTrueForUnderscore) {

-  EXPECT_TRUE(IsWordChar('_'));

-}

-

-TEST(IsValidEscapeTest, IsFalseForNonPrintable) {

-  EXPECT_FALSE(IsValidEscape('\0'));

-  EXPECT_FALSE(IsValidEscape('\007'));

-}

-

-TEST(IsValidEscapeTest, IsFalseForDigit) {

-  EXPECT_FALSE(IsValidEscape('0'));

-  EXPECT_FALSE(IsValidEscape('9'));

-}

-

-TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {

-  EXPECT_FALSE(IsValidEscape(' '));

-  EXPECT_FALSE(IsValidEscape('\n'));

-}

-

-TEST(IsValidEscapeTest, IsFalseForSomeLetter) {

-  EXPECT_FALSE(IsValidEscape('a'));

-  EXPECT_FALSE(IsValidEscape('Z'));

-}

-

-TEST(IsValidEscapeTest, IsTrueForPunct) {

-  EXPECT_TRUE(IsValidEscape('.'));

-  EXPECT_TRUE(IsValidEscape('-'));

-  EXPECT_TRUE(IsValidEscape('^'));

-  EXPECT_TRUE(IsValidEscape('$'));

-  EXPECT_TRUE(IsValidEscape('('));

-  EXPECT_TRUE(IsValidEscape(']'));

-  EXPECT_TRUE(IsValidEscape('{'));

-  EXPECT_TRUE(IsValidEscape('|'));

-}

-

-TEST(IsValidEscapeTest, IsTrueForSomeLetter) {

-  EXPECT_TRUE(IsValidEscape('d'));

-  EXPECT_TRUE(IsValidEscape('D'));

-  EXPECT_TRUE(IsValidEscape('s'));

-  EXPECT_TRUE(IsValidEscape('S'));

-  EXPECT_TRUE(IsValidEscape('w'));

-  EXPECT_TRUE(IsValidEscape('W'));

-}

-

-TEST(AtomMatchesCharTest, EscapedPunct) {

-  EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, '\\', ' '));

-  EXPECT_FALSE(AtomMatchesChar(true, '_', '.'));

-  EXPECT_FALSE(AtomMatchesChar(true, '.', 'a'));

-

-  EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\'));

-  EXPECT_TRUE(AtomMatchesChar(true, '_', '_'));

-  EXPECT_TRUE(AtomMatchesChar(true, '+', '+'));

-  EXPECT_TRUE(AtomMatchesChar(true, '.', '.'));

-}

-

-TEST(AtomMatchesCharTest, Escaped_d) {

-  EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'd', '.'));

-

-  EXPECT_TRUE(AtomMatchesChar(true, 'd', '0'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'd', '9'));

-}

-

-TEST(AtomMatchesCharTest, Escaped_D) {

-  EXPECT_FALSE(AtomMatchesChar(true, 'D', '0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'D', '9'));

-

-  EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'D', '-'));

-}

-

-TEST(AtomMatchesCharTest, Escaped_s) {

-  EXPECT_FALSE(AtomMatchesChar(true, 's', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 's', 'a'));

-  EXPECT_FALSE(AtomMatchesChar(true, 's', '.'));

-  EXPECT_FALSE(AtomMatchesChar(true, 's', '9'));

-

-  EXPECT_TRUE(AtomMatchesChar(true, 's', ' '));

-  EXPECT_TRUE(AtomMatchesChar(true, 's', '\n'));

-  EXPECT_TRUE(AtomMatchesChar(true, 's', '\t'));

-}

-

-TEST(AtomMatchesCharTest, Escaped_S) {

-  EXPECT_FALSE(AtomMatchesChar(true, 'S', ' '));

-  EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r'));

-

-  EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'S', '9'));

-}

-

-TEST(AtomMatchesCharTest, Escaped_w) {

-  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'w', '+'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'w', ' '));

-  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n'));

-

-  EXPECT_TRUE(AtomMatchesChar(true, 'w', '0'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'w', '_'));

-}

-

-TEST(AtomMatchesCharTest, Escaped_W) {

-  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'W', '9'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'W', '_'));

-

-  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'W', '*'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n'));

-}

-

-TEST(AtomMatchesCharTest, EscapedWhiteSpace) {

-  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a'));

-  EXPECT_FALSE(AtomMatchesChar(true, 't', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 't', 't'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f'));

-

-  EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r'));

-  EXPECT_TRUE(AtomMatchesChar(true, 't', '\t'));

-  EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v'));

-}

-

-TEST(AtomMatchesCharTest, UnescapedDot) {

-  EXPECT_FALSE(AtomMatchesChar(false, '.', '\n'));

-

-  EXPECT_TRUE(AtomMatchesChar(false, '.', '\0'));

-  EXPECT_TRUE(AtomMatchesChar(false, '.', '.'));

-  EXPECT_TRUE(AtomMatchesChar(false, '.', 'a'));

-  EXPECT_TRUE(AtomMatchesChar(false, '.', ' '));

-}

-

-TEST(AtomMatchesCharTest, UnescapedChar) {

-  EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0'));

-  EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b'));

-  EXPECT_FALSE(AtomMatchesChar(false, '$', 'a'));

-

-  EXPECT_TRUE(AtomMatchesChar(false, '$', '$'));

-  EXPECT_TRUE(AtomMatchesChar(false, '5', '5'));

-  EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z'));

-}

-

-TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)),

-                          "NULL is not a valid simple regular expression");

-  EXPECT_NONFATAL_FAILURE(

-      ASSERT_FALSE(ValidateRegex("a\\")),

-      "Syntax error at index 1 in simple regular expression \"a\\\": ");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")),

-                          "'\\' cannot appear at the end");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")),

-                          "'\\' cannot appear at the end");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")),

-                          "invalid escape sequence \"\\h\"");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")),

-                          "'^' can only appear at the beginning");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")),

-                          "'^' can only appear at the beginning");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")),

-                          "'$' can only appear at the end");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")),

-                          "'$' can only appear at the end");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")),

-                          "'(' is unsupported");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")),

-                          "')' is unsupported");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")),

-                          "'[' is unsupported");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")),

-                          "'{' is unsupported");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")),

-                          "'?' can only follow a repeatable token");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")),

-                          "'*' can only follow a repeatable token");

-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")),

-                          "'+' can only follow a repeatable token");

-}

-

-TEST(ValidateRegexTest, ReturnsTrueForValid) {

-  EXPECT_TRUE(ValidateRegex(""));

-  EXPECT_TRUE(ValidateRegex("a"));

-  EXPECT_TRUE(ValidateRegex(".*"));

-  EXPECT_TRUE(ValidateRegex("^a_+"));

-  EXPECT_TRUE(ValidateRegex("^a\\t\\&?"));

-  EXPECT_TRUE(ValidateRegex("09*$"));

-  EXPECT_TRUE(ValidateRegex("^Z$"));

-  EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}"));

-}

-

-TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {

-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba"));

-  // Repeating more than once.

-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab"));

-

-  // Repeating zero times.

-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba"));

-  // Repeating once.

-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab"));

-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##"));

-}

-

-TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {

-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab"));

-

-  // Repeating zero times.

-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc"));

-  // Repeating once.

-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc"));

-  // Repeating more than once.

-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g"));

-}

-

-TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {

-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab"));

-  // Repeating zero times.

-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc"));

-

-  // Repeating once.

-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc"));

-  // Repeating more than once.

-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g"));

-}

-

-TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {

-  EXPECT_TRUE(MatchRegexAtHead("", ""));

-  EXPECT_TRUE(MatchRegexAtHead("", "ab"));

-}

-

-TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {

-  EXPECT_FALSE(MatchRegexAtHead("$", "a"));

-

-  EXPECT_TRUE(MatchRegexAtHead("$", ""));

-  EXPECT_TRUE(MatchRegexAtHead("a$", "a"));

-}

-

-TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {

-  EXPECT_FALSE(MatchRegexAtHead("\\w", "+"));

-  EXPECT_FALSE(MatchRegexAtHead("\\W", "ab"));

-

-  EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab"));

-  EXPECT_TRUE(MatchRegexAtHead("\\d", "1a"));

-}

-

-TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {

-  EXPECT_FALSE(MatchRegexAtHead(".+a", "abc"));

-  EXPECT_FALSE(MatchRegexAtHead("a?b", "aab"));

-

-  EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab"));

-  EXPECT_TRUE(MatchRegexAtHead("a?b", "b"));

-  EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));

-}

-

-TEST(MatchRegexAtHeadTest,

-     WorksWhenRegexStartsWithRepetionOfEscapeSequence) {

-  EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));

-  EXPECT_FALSE(MatchRegexAtHead("\\s?b", "  b"));

-

-  EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab"));

-  EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b"));

-  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b"));

-  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b"));

-}

-

-TEST(MatchRegexAtHeadTest, MatchesSequentially) {

-  EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc"));

-

-  EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc"));

-}

-

-TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {

-  EXPECT_FALSE(MatchRegexAnywhere("", NULL));

-}

-

-TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {

-  EXPECT_FALSE(MatchRegexAnywhere("^a", "ba"));

-  EXPECT_FALSE(MatchRegexAnywhere("^$", "a"));

-

-  EXPECT_TRUE(MatchRegexAnywhere("^a", "ab"));

-  EXPECT_TRUE(MatchRegexAnywhere("^", "ab"));

-  EXPECT_TRUE(MatchRegexAnywhere("^$", ""));

-}

-

-TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {

-  EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123"));

-  EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888"));

-}

-

-TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {

-  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5"));

-  EXPECT_TRUE(MatchRegexAnywhere(".*=", "="));

-  EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc"));

-}

-

-TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {

-  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5"));

-  EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "=  ...="));

-}

-

-// Tests RE's implicit constructors.

-TEST(RETest, ImplicitConstructorWorks) {

-  const RE empty("");

-  EXPECT_STREQ("", empty.pattern());

-

-  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);

-  }, "NULL is not a valid simple regular expression");

-

-  EXPECT_NONFATAL_FAILURE({

-    const RE normal(".*(\\w+");

-  }, "'(' is unsupported");

-

-  EXPECT_NONFATAL_FAILURE({

-    const RE invalid("^?");

-  }, "'?' can only follow a repeatable token");

-}

-

-// Tests RE::FullMatch().

-TEST(RETest, FullMatchWorks) {

-  const RE empty("");

-  EXPECT_TRUE(RE::FullMatch("", empty));

-  EXPECT_FALSE(RE::FullMatch("a", empty));

-

-  const RE re1("a");

-  EXPECT_TRUE(RE::FullMatch("a", re1));

-

-  const RE re("a.*z");

-  EXPECT_TRUE(RE::FullMatch("az", re));

-  EXPECT_TRUE(RE::FullMatch("axyz", re));

-  EXPECT_FALSE(RE::FullMatch("baz", re));

-  EXPECT_FALSE(RE::FullMatch("azy", re));

-}

-

-// Tests RE::PartialMatch().

-TEST(RETest, PartialMatchWorks) {

-  const RE empty("");

-  EXPECT_TRUE(RE::PartialMatch("", empty));

-  EXPECT_TRUE(RE::PartialMatch("a", empty));

-

-  const RE re("a.*z");

-  EXPECT_TRUE(RE::PartialMatch("az", re));

-  EXPECT_TRUE(RE::PartialMatch("axyz", re));

-  EXPECT_TRUE(RE::PartialMatch("baz", re));

-  EXPECT_TRUE(RE::PartialMatch("azy", re));

-  EXPECT_FALSE(RE::PartialMatch("zza", re));

-}

-

-#endif  // GTEST_USES_POSIX_RE

-

-TEST(CaptureStderrTest, CapturesStdErr) {

-  CaptureStderr();

-  fprintf(stderr, "abc");

-  ASSERT_STREQ("abc", GetCapturedStderr().c_str());

-}

-

-}  // namespace internal

-}  // namespace testing

+// Copyright 2008, 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.
+//
+// Authors: [email protected] (Vlad Losev), [email protected] (Zhanyong Wan)
+//
+// This file tests the internal cross-platform support utilities.
+
+#include <gtest/internal/gtest-port.h>
+
+#if GTEST_OS_MAC
+#include <pthread.h>
+#include <time.h>
+#endif  // GTEST_OS_MAC
+
+#include <gtest/gtest.h>
+#include <gtest/gtest-spi.h>
+
+// 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_
+
+namespace testing {
+namespace internal {
+
+TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {
+  if (AlwaysFalse())
+    GTEST_CHECK_(false) << "This should never be executed; "
+                           "It's a compilation test only.";
+
+  if (AlwaysTrue())
+    GTEST_CHECK_(true);
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ;  // NOLINT
+  else
+    GTEST_CHECK_(true) << "";
+}
+
+TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
+  switch (0) {
+    case 1:
+      break;
+    default:
+      GTEST_CHECK_(true);
+  }
+
+  switch(0)
+    case 0:
+      GTEST_CHECK_(true) << "Check failed in switch case";
+}
+
+#if GTEST_OS_MAC
+void* ThreadFunc(void* data) {
+  pthread_mutex_t* mutex = reinterpret_cast<pthread_mutex_t*>(data);
+  pthread_mutex_lock(mutex);
+  pthread_mutex_unlock(mutex);
+  return NULL;
+}
+
+TEST(GetThreadCountTest, ReturnsCorrectValue) {
+  EXPECT_EQ(1U, GetThreadCount());
+  pthread_mutex_t mutex;
+  pthread_attr_t  attr;
+  pthread_t       thread_id;
+
+  // TODO([email protected]): turn mutex into internal::Mutex for automatic
+  // destruction.
+  pthread_mutex_init(&mutex, NULL);
+  pthread_mutex_lock(&mutex);
+  ASSERT_EQ(0, pthread_attr_init(&attr));
+  ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
+
+  const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
+  ASSERT_EQ(0, pthread_attr_destroy(&attr));
+  ASSERT_EQ(0, status);
+  EXPECT_EQ(2U, GetThreadCount());
+  pthread_mutex_unlock(&mutex);
+
+  void* dummy;
+  ASSERT_EQ(0, pthread_join(thread_id, &dummy));
+
+  // MacOS X may not immediately report the updated thread count after
+  // joining a thread, causing flakiness in this test. To counter that, we
+  // wait for up to .5 seconds for the OS to report the correct value.
+  for (int i = 0; i < 5; ++i) {
+    if (GetThreadCount() == 1)
+      break;
+
+    timespec time;
+    time.tv_sec = 0;
+    time.tv_nsec = 100L * 1000 * 1000;  // .1 seconds.
+    nanosleep(&time, NULL);
+  }
+  EXPECT_EQ(1U, GetThreadCount());
+  pthread_mutex_destroy(&mutex);
+}
+#else
+TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {
+  EXPECT_EQ(0U, GetThreadCount());
+}
+#endif  // GTEST_OS_MAC
+
+TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
+  const bool a_false_condition = false;
+  const char regex[] =
+#ifdef _MSC_VER
+     "gtest-port_test\\.cc\\(\\d+\\):"
+#else
+     "gtest-port_test\\.cc:[0-9]+"
+#endif  // _MSC_VER
+     ".*a_false_condition.*Extra info.*";
+
+  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
+                            regex);
+}
+
+#if GTEST_HAS_DEATH_TEST
+
+TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
+  EXPECT_EXIT({
+      GTEST_CHECK_(true) << "Extra info";
+      ::std::cerr << "Success\n";
+      exit(0); },
+      ::testing::ExitedWithCode(0), "Success");
+}
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+#if GTEST_USES_POSIX_RE
+
+template <typename Str>
+class RETest : public ::testing::Test {};
+
+// Defines StringTypes as the list of all string types that class RE
+// supports.
+typedef testing::Types<
+#if GTEST_HAS_STD_STRING
+    ::std::string,
+#endif  // GTEST_HAS_STD_STRING
+#if GTEST_HAS_GLOBAL_STRING
+    ::string,
+#endif  // GTEST_HAS_GLOBAL_STRING
+    const char*> StringTypes;
+
+TYPED_TEST_CASE(RETest, StringTypes);
+
+// Tests RE's implicit constructors.
+TYPED_TEST(RETest, ImplicitConstructorWorks) {
+  const RE empty(TypeParam(""));
+  EXPECT_STREQ("", empty.pattern());
+
+  const RE simple(TypeParam("hello"));
+  EXPECT_STREQ("hello", simple.pattern());
+
+  const RE normal(TypeParam(".*(\\w+)"));
+  EXPECT_STREQ(".*(\\w+)", normal.pattern());
+}
+
+// Tests that RE's constructors reject invalid regular expressions.
+TYPED_TEST(RETest, RejectsInvalidRegex) {
+  EXPECT_NONFATAL_FAILURE({
+    const RE invalid(TypeParam("?"));
+  }, "\"?\" is not a valid POSIX Extended regular expression.");
+}
+
+// Tests RE::FullMatch().
+TYPED_TEST(RETest, FullMatchWorks) {
+  const RE empty(TypeParam(""));
+  EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty));
+  EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty));
+
+  const RE re(TypeParam("a.*z"));
+  EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re));
+  EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re));
+  EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re));
+  EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re));
+}
+
+// Tests RE::PartialMatch().
+TYPED_TEST(RETest, PartialMatchWorks) {
+  const RE empty(TypeParam(""));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));
+
+  const RE re(TypeParam("a.*z"));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));
+  EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));
+}
+
+#elif GTEST_USES_SIMPLE_RE
+
+TEST(IsInSetTest, NulCharIsNotInAnySet) {
+  EXPECT_FALSE(IsInSet('\0', ""));
+  EXPECT_FALSE(IsInSet('\0', "\0"));
+  EXPECT_FALSE(IsInSet('\0', "a"));
+}
+
+TEST(IsInSetTest, WorksForNonNulChars) {
+  EXPECT_FALSE(IsInSet('a', "Ab"));
+  EXPECT_FALSE(IsInSet('c', ""));
+
+  EXPECT_TRUE(IsInSet('b', "bcd"));
+  EXPECT_TRUE(IsInSet('b', "ab"));
+}
+
+TEST(IsDigitTest, IsFalseForNonDigit) {
+  EXPECT_FALSE(IsDigit('\0'));
+  EXPECT_FALSE(IsDigit(' '));
+  EXPECT_FALSE(IsDigit('+'));
+  EXPECT_FALSE(IsDigit('-'));
+  EXPECT_FALSE(IsDigit('.'));
+  EXPECT_FALSE(IsDigit('a'));
+}
+
+TEST(IsDigitTest, IsTrueForDigit) {
+  EXPECT_TRUE(IsDigit('0'));
+  EXPECT_TRUE(IsDigit('1'));
+  EXPECT_TRUE(IsDigit('5'));
+  EXPECT_TRUE(IsDigit('9'));
+}
+
+TEST(IsPunctTest, IsFalseForNonPunct) {
+  EXPECT_FALSE(IsPunct('\0'));
+  EXPECT_FALSE(IsPunct(' '));
+  EXPECT_FALSE(IsPunct('\n'));
+  EXPECT_FALSE(IsPunct('a'));
+  EXPECT_FALSE(IsPunct('0'));
+}
+
+TEST(IsPunctTest, IsTrueForPunct) {
+  for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) {
+    EXPECT_PRED1(IsPunct, *p);
+  }
+}
+
+TEST(IsRepeatTest, IsFalseForNonRepeatChar) {
+  EXPECT_FALSE(IsRepeat('\0'));
+  EXPECT_FALSE(IsRepeat(' '));
+  EXPECT_FALSE(IsRepeat('a'));
+  EXPECT_FALSE(IsRepeat('1'));
+  EXPECT_FALSE(IsRepeat('-'));
+}
+
+TEST(IsRepeatTest, IsTrueForRepeatChar) {
+  EXPECT_TRUE(IsRepeat('?'));
+  EXPECT_TRUE(IsRepeat('*'));
+  EXPECT_TRUE(IsRepeat('+'));
+}
+
+TEST(IsWhiteSpaceTest, IsFalseForNonWhiteSpace) {
+  EXPECT_FALSE(IsWhiteSpace('\0'));
+  EXPECT_FALSE(IsWhiteSpace('a'));
+  EXPECT_FALSE(IsWhiteSpace('1'));
+  EXPECT_FALSE(IsWhiteSpace('+'));
+  EXPECT_FALSE(IsWhiteSpace('_'));
+}
+
+TEST(IsWhiteSpaceTest, IsTrueForWhiteSpace) {
+  EXPECT_TRUE(IsWhiteSpace(' '));
+  EXPECT_TRUE(IsWhiteSpace('\n'));
+  EXPECT_TRUE(IsWhiteSpace('\r'));
+  EXPECT_TRUE(IsWhiteSpace('\t'));
+  EXPECT_TRUE(IsWhiteSpace('\v'));
+  EXPECT_TRUE(IsWhiteSpace('\f'));
+}
+
+TEST(IsWordCharTest, IsFalseForNonWordChar) {
+  EXPECT_FALSE(IsWordChar('\0'));
+  EXPECT_FALSE(IsWordChar('+'));
+  EXPECT_FALSE(IsWordChar('.'));
+  EXPECT_FALSE(IsWordChar(' '));
+  EXPECT_FALSE(IsWordChar('\n'));
+}
+
+TEST(IsWordCharTest, IsTrueForLetter) {
+  EXPECT_TRUE(IsWordChar('a'));
+  EXPECT_TRUE(IsWordChar('b'));
+  EXPECT_TRUE(IsWordChar('A'));
+  EXPECT_TRUE(IsWordChar('Z'));
+}
+
+TEST(IsWordCharTest, IsTrueForDigit) {
+  EXPECT_TRUE(IsWordChar('0'));
+  EXPECT_TRUE(IsWordChar('1'));
+  EXPECT_TRUE(IsWordChar('7'));
+  EXPECT_TRUE(IsWordChar('9'));
+}
+
+TEST(IsWordCharTest, IsTrueForUnderscore) {
+  EXPECT_TRUE(IsWordChar('_'));
+}
+
+TEST(IsValidEscapeTest, IsFalseForNonPrintable) {
+  EXPECT_FALSE(IsValidEscape('\0'));
+  EXPECT_FALSE(IsValidEscape('\007'));
+}
+
+TEST(IsValidEscapeTest, IsFalseForDigit) {
+  EXPECT_FALSE(IsValidEscape('0'));
+  EXPECT_FALSE(IsValidEscape('9'));
+}
+
+TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {
+  EXPECT_FALSE(IsValidEscape(' '));
+  EXPECT_FALSE(IsValidEscape('\n'));
+}
+
+TEST(IsValidEscapeTest, IsFalseForSomeLetter) {
+  EXPECT_FALSE(IsValidEscape('a'));
+  EXPECT_FALSE(IsValidEscape('Z'));
+}
+
+TEST(IsValidEscapeTest, IsTrueForPunct) {
+  EXPECT_TRUE(IsValidEscape('.'));
+  EXPECT_TRUE(IsValidEscape('-'));
+  EXPECT_TRUE(IsValidEscape('^'));
+  EXPECT_TRUE(IsValidEscape('$'));
+  EXPECT_TRUE(IsValidEscape('('));
+  EXPECT_TRUE(IsValidEscape(']'));
+  EXPECT_TRUE(IsValidEscape('{'));
+  EXPECT_TRUE(IsValidEscape('|'));
+}
+
+TEST(IsValidEscapeTest, IsTrueForSomeLetter) {
+  EXPECT_TRUE(IsValidEscape('d'));
+  EXPECT_TRUE(IsValidEscape('D'));
+  EXPECT_TRUE(IsValidEscape('s'));
+  EXPECT_TRUE(IsValidEscape('S'));
+  EXPECT_TRUE(IsValidEscape('w'));
+  EXPECT_TRUE(IsValidEscape('W'));
+}
+
+TEST(AtomMatchesCharTest, EscapedPunct) {
+  EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, '\\', ' '));
+  EXPECT_FALSE(AtomMatchesChar(true, '_', '.'));
+  EXPECT_FALSE(AtomMatchesChar(true, '.', 'a'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\'));
+  EXPECT_TRUE(AtomMatchesChar(true, '_', '_'));
+  EXPECT_TRUE(AtomMatchesChar(true, '+', '+'));
+  EXPECT_TRUE(AtomMatchesChar(true, '.', '.'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_d) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'd', '.'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'd', '0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'd', '9'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_D) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'D', '0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'D', '9'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'D', '-'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_s) {
+  EXPECT_FALSE(AtomMatchesChar(true, 's', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 's', 'a'));
+  EXPECT_FALSE(AtomMatchesChar(true, 's', '.'));
+  EXPECT_FALSE(AtomMatchesChar(true, 's', '9'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 's', ' '));
+  EXPECT_TRUE(AtomMatchesChar(true, 's', '\n'));
+  EXPECT_TRUE(AtomMatchesChar(true, 's', '\t'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_S) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'S', ' '));
+  EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'S', '9'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_w) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'w', '+'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'w', ' '));
+  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'w', '0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'w', '_'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_W) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'W', '9'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'W', '_'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'W', '*'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n'));
+}
+
+TEST(AtomMatchesCharTest, EscapedWhiteSpace) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a'));
+  EXPECT_FALSE(AtomMatchesChar(true, 't', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 't', 't'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r'));
+  EXPECT_TRUE(AtomMatchesChar(true, 't', '\t'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v'));
+}
+
+TEST(AtomMatchesCharTest, UnescapedDot) {
+  EXPECT_FALSE(AtomMatchesChar(false, '.', '\n'));
+
+  EXPECT_TRUE(AtomMatchesChar(false, '.', '\0'));
+  EXPECT_TRUE(AtomMatchesChar(false, '.', '.'));
+  EXPECT_TRUE(AtomMatchesChar(false, '.', 'a'));
+  EXPECT_TRUE(AtomMatchesChar(false, '.', ' '));
+}
+
+TEST(AtomMatchesCharTest, UnescapedChar) {
+  EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b'));
+  EXPECT_FALSE(AtomMatchesChar(false, '$', 'a'));
+
+  EXPECT_TRUE(AtomMatchesChar(false, '$', '$'));
+  EXPECT_TRUE(AtomMatchesChar(false, '5', '5'));
+  EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z'));
+}
+
+TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)),
+                          "NULL is not a valid simple regular expression");
+  EXPECT_NONFATAL_FAILURE(
+      ASSERT_FALSE(ValidateRegex("a\\")),
+      "Syntax error at index 1 in simple regular expression \"a\\\": ");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")),
+                          "'\\' cannot appear at the end");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")),
+                          "'\\' cannot appear at the end");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")),
+                          "invalid escape sequence \"\\h\"");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")),
+                          "'^' can only appear at the beginning");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")),
+                          "'^' can only appear at the beginning");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")),
+                          "'$' can only appear at the end");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")),
+                          "'$' can only appear at the end");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")),
+                          "'(' is unsupported");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")),
+                          "')' is unsupported");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")),
+                          "'[' is unsupported");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")),
+                          "'{' is unsupported");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")),
+                          "'?' can only follow a repeatable token");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")),
+                          "'*' can only follow a repeatable token");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")),
+                          "'+' can only follow a repeatable token");
+}
+
+TEST(ValidateRegexTest, ReturnsTrueForValid) {
+  EXPECT_TRUE(ValidateRegex(""));
+  EXPECT_TRUE(ValidateRegex("a"));
+  EXPECT_TRUE(ValidateRegex(".*"));
+  EXPECT_TRUE(ValidateRegex("^a_+"));
+  EXPECT_TRUE(ValidateRegex("^a\\t\\&?"));
+  EXPECT_TRUE(ValidateRegex("09*$"));
+  EXPECT_TRUE(ValidateRegex("^Z$"));
+  EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}"));
+}
+
+TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba"));
+  // Repeating more than once.
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab"));
+
+  // Repeating zero times.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba"));
+  // Repeating once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab"));
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##"));
+}
+
+TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab"));
+
+  // Repeating zero times.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc"));
+  // Repeating once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc"));
+  // Repeating more than once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g"));
+}
+
+TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab"));
+  // Repeating zero times.
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc"));
+
+  // Repeating once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc"));
+  // Repeating more than once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g"));
+}
+
+TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {
+  EXPECT_TRUE(MatchRegexAtHead("", ""));
+  EXPECT_TRUE(MatchRegexAtHead("", "ab"));
+}
+
+TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {
+  EXPECT_FALSE(MatchRegexAtHead("$", "a"));
+
+  EXPECT_TRUE(MatchRegexAtHead("$", ""));
+  EXPECT_TRUE(MatchRegexAtHead("a$", "a"));
+}
+
+TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {
+  EXPECT_FALSE(MatchRegexAtHead("\\w", "+"));
+  EXPECT_FALSE(MatchRegexAtHead("\\W", "ab"));
+
+  EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab"));
+  EXPECT_TRUE(MatchRegexAtHead("\\d", "1a"));
+}
+
+TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {
+  EXPECT_FALSE(MatchRegexAtHead(".+a", "abc"));
+  EXPECT_FALSE(MatchRegexAtHead("a?b", "aab"));
+
+  EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab"));
+  EXPECT_TRUE(MatchRegexAtHead("a?b", "b"));
+  EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));
+}
+
+TEST(MatchRegexAtHeadTest,
+     WorksWhenRegexStartsWithRepetionOfEscapeSequence) {
+  EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));
+  EXPECT_FALSE(MatchRegexAtHead("\\s?b", "  b"));
+
+  EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab"));
+  EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b"));
+  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b"));
+  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b"));
+}
+
+TEST(MatchRegexAtHeadTest, MatchesSequentially) {
+  EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc"));
+
+  EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc"));
+}
+
+TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {
+  EXPECT_FALSE(MatchRegexAnywhere("", NULL));
+}
+
+TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {
+  EXPECT_FALSE(MatchRegexAnywhere("^a", "ba"));
+  EXPECT_FALSE(MatchRegexAnywhere("^$", "a"));
+
+  EXPECT_TRUE(MatchRegexAnywhere("^a", "ab"));
+  EXPECT_TRUE(MatchRegexAnywhere("^", "ab"));
+  EXPECT_TRUE(MatchRegexAnywhere("^$", ""));
+}
+
+TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {
+  EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123"));
+  EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888"));
+}
+
+TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {
+  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5"));
+  EXPECT_TRUE(MatchRegexAnywhere(".*=", "="));
+  EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc"));
+}
+
+TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {
+  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5"));
+  EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "=  ...="));
+}
+
+// Tests RE's implicit constructors.
+TEST(RETest, ImplicitConstructorWorks) {
+  const RE empty("");
+  EXPECT_STREQ("", empty.pattern());
+
+  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);
+  }, "NULL is not a valid simple regular expression");
+
+  EXPECT_NONFATAL_FAILURE({
+    const RE normal(".*(\\w+");
+  }, "'(' is unsupported");
+
+  EXPECT_NONFATAL_FAILURE({
+    const RE invalid("^?");
+  }, "'?' can only follow a repeatable token");
+}
+
+// Tests RE::FullMatch().
+TEST(RETest, FullMatchWorks) {
+  const RE empty("");
+  EXPECT_TRUE(RE::FullMatch("", empty));
+  EXPECT_FALSE(RE::FullMatch("a", empty));
+
+  const RE re1("a");
+  EXPECT_TRUE(RE::FullMatch("a", re1));
+
+  const RE re("a.*z");
+  EXPECT_TRUE(RE::FullMatch("az", re));
+  EXPECT_TRUE(RE::FullMatch("axyz", re));
+  EXPECT_FALSE(RE::FullMatch("baz", re));
+  EXPECT_FALSE(RE::FullMatch("azy", re));
+}
+
+// Tests RE::PartialMatch().
+TEST(RETest, PartialMatchWorks) {
+  const RE empty("");
+  EXPECT_TRUE(RE::PartialMatch("", empty));
+  EXPECT_TRUE(RE::PartialMatch("a", empty));
+
+  const RE re("a.*z");
+  EXPECT_TRUE(RE::PartialMatch("az", re));
+  EXPECT_TRUE(RE::PartialMatch("axyz", re));
+  EXPECT_TRUE(RE::PartialMatch("baz", re));
+  EXPECT_TRUE(RE::PartialMatch("azy", re));
+  EXPECT_FALSE(RE::PartialMatch("zza", re));
+}
+
+#endif  // GTEST_USES_POSIX_RE
+
+TEST(CaptureStderrTest, CapturesStdErr) {
+  CaptureStderr();
+  fprintf(stderr, "abc");
+  ASSERT_STREQ("abc", GetCapturedStderr().c_str());
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-test-part_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-test-part_test.cc
index 5d87f237..403c1845 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-test-part_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-test-part_test.cc
@@ -1,159 +1,159 @@
-// Copyright 2008 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: [email protected] (Markus Heule)

-//

-

-#include <gtest/gtest-test-part.h>

-

-#include <gtest/gtest.h>

-

-using testing::Test;

-using testing::TestPartResult;

-using testing::TestPartResultArray;

-

-namespace {

-

-// Tests the TestPartResult class.

-

-// The test fixture for testing TestPartResult.

-class TestPartResultTest : public Test {

- protected:

-  TestPartResultTest()

-      : r1_(TestPartResult::kSuccess, "foo/bar.cc", 10, "Success!"),

-        r2_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure!"),

-        r3_(TestPartResult::kFatalFailure, NULL, -1, "Failure!") {}

-

-  TestPartResult r1_, r2_, r3_;

-};

-

-// Tests TestPartResult::type().

-TEST_F(TestPartResultTest, type) {

-  EXPECT_EQ(TestPartResult::kSuccess, r1_.type());

-  EXPECT_EQ(TestPartResult::kNonFatalFailure, r2_.type());

-  EXPECT_EQ(TestPartResult::kFatalFailure, r3_.type());

-}

-

-// Tests TestPartResult::file_name().

-TEST_F(TestPartResultTest, file_name) {

-  EXPECT_STREQ("foo/bar.cc", r1_.file_name());

-  EXPECT_STREQ(NULL, r3_.file_name());

-}

-

-// Tests TestPartResult::line_number().

-TEST_F(TestPartResultTest, line_number) {

-  EXPECT_EQ(10, r1_.line_number());

-  EXPECT_EQ(-1, r2_.line_number());

-}

-

-// Tests TestPartResult::message().

-TEST_F(TestPartResultTest, message) {

-  EXPECT_STREQ("Success!", r1_.message());

-}

-

-// Tests TestPartResult::passed().

-TEST_F(TestPartResultTest, Passed) {

-  EXPECT_TRUE(r1_.passed());

-  EXPECT_FALSE(r2_.passed());

-  EXPECT_FALSE(r3_.passed());

-}

-

-// Tests TestPartResult::failed().

-TEST_F(TestPartResultTest, Failed) {

-  EXPECT_FALSE(r1_.failed());

-  EXPECT_TRUE(r2_.failed());

-  EXPECT_TRUE(r3_.failed());

-}

-

-// Tests TestPartResult::fatally_failed().

-TEST_F(TestPartResultTest, FatallyFailed) {

-  EXPECT_FALSE(r1_.fatally_failed());

-  EXPECT_FALSE(r2_.fatally_failed());

-  EXPECT_TRUE(r3_.fatally_failed());

-}

-

-// Tests TestPartResult::nonfatally_failed().

-TEST_F(TestPartResultTest, NonfatallyFailed) {

-  EXPECT_FALSE(r1_.nonfatally_failed());

-  EXPECT_TRUE(r2_.nonfatally_failed());

-  EXPECT_FALSE(r3_.nonfatally_failed());

-}

-

-// Tests the TestPartResultArray class.

-

-class TestPartResultArrayTest : public Test {

- protected:

-  TestPartResultArrayTest()

-      : r1_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure 1"),

-        r2_(TestPartResult::kFatalFailure, "foo/bar.cc", -1, "Failure 2") {}

-

-  const TestPartResult r1_, r2_;

-};

-

-// Tests that TestPartResultArray initially has size 0.

-TEST_F(TestPartResultArrayTest, InitialSizeIsZero) {

-  TestPartResultArray results;

-  EXPECT_EQ(0, results.size());

-}

-

-// Tests that TestPartResultArray contains the given TestPartResult

-// after one Append() operation.

-TEST_F(TestPartResultArrayTest, ContainsGivenResultAfterAppend) {

-  TestPartResultArray results;

-  results.Append(r1_);

-  EXPECT_EQ(1, results.size());

-  EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());

-}

-

-// Tests that TestPartResultArray contains the given TestPartResults

-// after two Append() operations.

-TEST_F(TestPartResultArrayTest, ContainsGivenResultsAfterTwoAppends) {

-  TestPartResultArray results;

-  results.Append(r1_);

-  results.Append(r2_);

-  EXPECT_EQ(2, results.size());

-  EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());

-  EXPECT_STREQ("Failure 2", results.GetTestPartResult(1).message());

-}

-

-typedef TestPartResultArrayTest TestPartResultArrayDeathTest;

-

-// Tests that the program dies when GetTestPartResult() is called with

-// an invalid index.

-TEST_F(TestPartResultArrayDeathTest, DiesWhenIndexIsOutOfBound) {

-  TestPartResultArray results;

-  results.Append(r1_);

-

-  EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(-1), "");

-  EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(1), "");

-}

-

-// TODO([email protected]): Add a test for the class HasNewFatalFailureHelper.

-

-}  // namespace

+// Copyright 2008 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: [email protected] (Markus Heule)
+//
+
+#include <gtest/gtest-test-part.h>
+
+#include <gtest/gtest.h>
+
+using testing::Test;
+using testing::TestPartResult;
+using testing::TestPartResultArray;
+
+namespace {
+
+// Tests the TestPartResult class.
+
+// The test fixture for testing TestPartResult.
+class TestPartResultTest : public Test {
+ protected:
+  TestPartResultTest()
+      : r1_(TestPartResult::kSuccess, "foo/bar.cc", 10, "Success!"),
+        r2_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure!"),
+        r3_(TestPartResult::kFatalFailure, NULL, -1, "Failure!") {}
+
+  TestPartResult r1_, r2_, r3_;
+};
+
+// Tests TestPartResult::type().
+TEST_F(TestPartResultTest, type) {
+  EXPECT_EQ(TestPartResult::kSuccess, r1_.type());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure, r2_.type());
+  EXPECT_EQ(TestPartResult::kFatalFailure, r3_.type());
+}
+
+// Tests TestPartResult::file_name().
+TEST_F(TestPartResultTest, file_name) {
+  EXPECT_STREQ("foo/bar.cc", r1_.file_name());
+  EXPECT_STREQ(NULL, r3_.file_name());
+}
+
+// Tests TestPartResult::line_number().
+TEST_F(TestPartResultTest, line_number) {
+  EXPECT_EQ(10, r1_.line_number());
+  EXPECT_EQ(-1, r2_.line_number());
+}
+
+// Tests TestPartResult::message().
+TEST_F(TestPartResultTest, message) {
+  EXPECT_STREQ("Success!", r1_.message());
+}
+
+// Tests TestPartResult::passed().
+TEST_F(TestPartResultTest, Passed) {
+  EXPECT_TRUE(r1_.passed());
+  EXPECT_FALSE(r2_.passed());
+  EXPECT_FALSE(r3_.passed());
+}
+
+// Tests TestPartResult::failed().
+TEST_F(TestPartResultTest, Failed) {
+  EXPECT_FALSE(r1_.failed());
+  EXPECT_TRUE(r2_.failed());
+  EXPECT_TRUE(r3_.failed());
+}
+
+// Tests TestPartResult::fatally_failed().
+TEST_F(TestPartResultTest, FatallyFailed) {
+  EXPECT_FALSE(r1_.fatally_failed());
+  EXPECT_FALSE(r2_.fatally_failed());
+  EXPECT_TRUE(r3_.fatally_failed());
+}
+
+// Tests TestPartResult::nonfatally_failed().
+TEST_F(TestPartResultTest, NonfatallyFailed) {
+  EXPECT_FALSE(r1_.nonfatally_failed());
+  EXPECT_TRUE(r2_.nonfatally_failed());
+  EXPECT_FALSE(r3_.nonfatally_failed());
+}
+
+// Tests the TestPartResultArray class.
+
+class TestPartResultArrayTest : public Test {
+ protected:
+  TestPartResultArrayTest()
+      : r1_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure 1"),
+        r2_(TestPartResult::kFatalFailure, "foo/bar.cc", -1, "Failure 2") {}
+
+  const TestPartResult r1_, r2_;
+};
+
+// Tests that TestPartResultArray initially has size 0.
+TEST_F(TestPartResultArrayTest, InitialSizeIsZero) {
+  TestPartResultArray results;
+  EXPECT_EQ(0, results.size());
+}
+
+// Tests that TestPartResultArray contains the given TestPartResult
+// after one Append() operation.
+TEST_F(TestPartResultArrayTest, ContainsGivenResultAfterAppend) {
+  TestPartResultArray results;
+  results.Append(r1_);
+  EXPECT_EQ(1, results.size());
+  EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());
+}
+
+// Tests that TestPartResultArray contains the given TestPartResults
+// after two Append() operations.
+TEST_F(TestPartResultArrayTest, ContainsGivenResultsAfterTwoAppends) {
+  TestPartResultArray results;
+  results.Append(r1_);
+  results.Append(r2_);
+  EXPECT_EQ(2, results.size());
+  EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());
+  EXPECT_STREQ("Failure 2", results.GetTestPartResult(1).message());
+}
+
+typedef TestPartResultArrayTest TestPartResultArrayDeathTest;
+
+// Tests that the program dies when GetTestPartResult() is called with
+// an invalid index.
+TEST_F(TestPartResultArrayDeathTest, DiesWhenIndexIsOutOfBound) {
+  TestPartResultArray results;
+  results.Append(r1_);
+
+  EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(-1), "");
+  EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(1), "");
+}
+
+// TODO([email protected]): Add a test for the class HasNewFatalFailureHelper.
+
+}  // namespace
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-tuple_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-tuple_test.cc
index ce5ba4e4..3829118e 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-tuple_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-tuple_test.cc
@@ -1,288 +1,288 @@
-// Copyright 2007, 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: [email protected] (Zhanyong Wan)

-

-#include <gtest/internal/gtest-tuple.h>

-#include <utility>

-#include <gtest/gtest.h>

-

-namespace {

-

-using ::std::tr1::get;

-using ::std::tr1::make_tuple;

-using ::std::tr1::tuple;

-using ::std::tr1::tuple_element;

-using ::std::tr1::tuple_size;

-using ::testing::StaticAssertTypeEq;

-

-// Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK.

-TEST(tuple_element_Test, ReturnsElementType) {

-  StaticAssertTypeEq<int, tuple_element<0, tuple<int, char> >::type>();

-  StaticAssertTypeEq<int&, tuple_element<1, tuple<double, int&> >::type>();

-  StaticAssertTypeEq<bool, tuple_element<2, tuple<double, int, bool> >::type>();

-}

-

-// Tests that tuple_size<T>::value gives the number of fields in tuple

-// type T.

-TEST(tuple_size_Test, ReturnsNumberOfFields) {

-  EXPECT_EQ(0, +tuple_size<tuple<> >::value);

-  EXPECT_EQ(1, +tuple_size<tuple<void*> >::value);

-  EXPECT_EQ(1, +tuple_size<tuple<char> >::value);

-  EXPECT_EQ(1, +(tuple_size<tuple<tuple<int, double> > >::value));

-  EXPECT_EQ(2, +(tuple_size<tuple<int&, const char> >::value));

-  EXPECT_EQ(3, +(tuple_size<tuple<char*, void, const bool&> >::value));

-}

-

-// Tests comparing a tuple with itself.

-TEST(ComparisonTest, ComparesWithSelf) {

-  const tuple<int, char, bool> a(5, 'a', false);

-

-  EXPECT_TRUE(a == a);

-  EXPECT_FALSE(a != a);

-}

-

-// Tests comparing two tuples with the same value.

-TEST(ComparisonTest, ComparesEqualTuples) {

-  const tuple<int, bool> a(5, true), b(5, true);

-

-  EXPECT_TRUE(a == b);

-  EXPECT_FALSE(a != b);

-}

-

-// Tests comparing two different tuples that have no reference fields.

-TEST(ComparisonTest, ComparesUnequalTuplesWithoutReferenceFields) {

-  typedef tuple<const int, char> FooTuple;

-

-  const FooTuple a(0, 'x');

-  const FooTuple b(1, 'a');

-

-  EXPECT_TRUE(a != b);

-  EXPECT_FALSE(a == b);

-

-  const FooTuple c(1, 'b');

-

-  EXPECT_TRUE(b != c);

-  EXPECT_FALSE(b == c);

-}

-

-// Tests comparing two different tuples that have reference fields.

-TEST(ComparisonTest, ComparesUnequalTuplesWithReferenceFields) {

-  typedef tuple<int&, const char&> FooTuple;

-

-  int i = 5;

-  const char ch = 'a';

-  const FooTuple a(i, ch);

-

-  int j = 6;

-  const FooTuple b(j, ch);

-

-  EXPECT_TRUE(a != b);

-  EXPECT_FALSE(a == b);

-

-  j = 5;

-  const char ch2 = 'b';

-  const FooTuple c(j, ch2);

-

-  EXPECT_TRUE(b != c);

-  EXPECT_FALSE(b == c);

-}

-

-// Tests that a tuple field with a reference type is an alias of the

-// variable it's supposed to reference.

-TEST(ReferenceFieldTest, IsAliasOfReferencedVariable) {

-  int n = 0;

-  tuple<bool, int&> t(true, n);

-

-  n = 1;

-  EXPECT_EQ(n, get<1>(t))

-      << "Changing a underlying variable should update the reference field.";

-

-  // Makes sure that the implementation doesn't do anything funny with

-  // the & operator for the return type of get<>().

-  EXPECT_EQ(&n, &(get<1>(t)))

-      << "The address of a reference field should equal the address of "

-      << "the underlying variable.";

-

-  get<1>(t) = 2;

-  EXPECT_EQ(2, n)

-      << "Changing a reference field should update the underlying variable.";

-}

-

-// Tests tuple's default constructor.

-TEST(TupleConstructorTest, DefaultConstructor) {

-  // We are just testing that the following compiles.

-  tuple<> empty;

-  tuple<int> one_field;

-  tuple<double, char, bool*> three_fields;

-}

-

-// Tests constructing a tuple from its fields.

-TEST(TupleConstructorTest, ConstructsFromFields) {

-  int n = 1;

-  // Reference field.

-  tuple<int&> a(n);

-  EXPECT_EQ(&n, &(get<0>(a)));

-

-  // Non-reference fields.

-  tuple<int, char> b(5, 'a');

-  EXPECT_EQ(5, get<0>(b));

-  EXPECT_EQ('a', get<1>(b));

-

-  // Const reference field.

-  const int m = 2;

-  tuple<bool, const int&> c(true, m);

-  EXPECT_TRUE(get<0>(c));

-  EXPECT_EQ(&m, &(get<1>(c)));

-}

-

-// Tests tuple's copy constructor.

-TEST(TupleConstructorTest, CopyConstructor) {

-  tuple<double, bool> a(0.0, true);

-  tuple<double, bool> b(a);

-

-  EXPECT_DOUBLE_EQ(0.0, get<0>(b));

-  EXPECT_TRUE(get<1>(b));

-}

-

-// Tests constructing a tuple from another tuple that has a compatible

-// but different type.

-TEST(TupleConstructorTest, ConstructsFromDifferentTupleType) {

-  tuple<int, int, char> a(0, 1, 'a');

-  tuple<double, long, int> b(a);

-

-  EXPECT_DOUBLE_EQ(0.0, get<0>(b));

-  EXPECT_EQ(1, get<1>(b));

-  EXPECT_EQ('a', get<2>(b));

-}

-

-// Tests constructing a 2-tuple from an std::pair.

-TEST(TupleConstructorTest, ConstructsFromPair) {

-  ::std::pair<int, char> a(1, 'a');

-  tuple<int, char> b(a);

-  tuple<int, const char&> c(a);

-}

-

-// Tests assigning a tuple to another tuple with the same type.

-TEST(TupleAssignmentTest, AssignsToSameTupleType) {

-  const tuple<int, long> a(5, 7L);

-  tuple<int, long> b;

-  b = a;

-  EXPECT_EQ(5, get<0>(b));

-  EXPECT_EQ(7L, get<1>(b));

-}

-

-// Tests assigning a tuple to another tuple with a different but

-// compatible type.

-TEST(TupleAssignmentTest, AssignsToDifferentTupleType) {

-  const tuple<int, long, bool> a(1, 7L, true);

-  tuple<long, int, bool> b;

-  b = a;

-  EXPECT_EQ(1L, get<0>(b));

-  EXPECT_EQ(7, get<1>(b));

-  EXPECT_TRUE(get<2>(b));

-}

-

-// Tests assigning an std::pair to a 2-tuple.

-TEST(TupleAssignmentTest, AssignsFromPair) {

-  const ::std::pair<int, bool> a(5, true);

-  tuple<int, bool> b;

-  b = a;

-  EXPECT_EQ(5, get<0>(b));

-  EXPECT_TRUE(get<1>(b));

-

-  tuple<long, bool> c;

-  c = a;

-  EXPECT_EQ(5L, get<0>(c));

-  EXPECT_TRUE(get<1>(c));

-}

-

-// A fixture for testing big tuples.

-class BigTupleTest : public testing::Test {

- protected:

-  typedef tuple<int, int, int, int, int, int, int, int, int, int> BigTuple;

-

-  BigTupleTest() :

-      a_(1, 0, 0, 0, 0, 0, 0, 0, 0, 2),

-      b_(1, 0, 0, 0, 0, 0, 0, 0, 0, 3) {}

-

-  BigTuple a_, b_;

-};

-

-// Tests constructing big tuples.

-TEST_F(BigTupleTest, Construction) {

-  BigTuple a;

-  BigTuple b(b_);

-}

-

-// Tests that get<N>(t) returns the N-th (0-based) field of tuple t.

-TEST_F(BigTupleTest, get) {

-  EXPECT_EQ(1, get<0>(a_));

-  EXPECT_EQ(2, get<9>(a_));

-

-  // Tests that get() works on a const tuple too.

-  const BigTuple a(a_);

-  EXPECT_EQ(1, get<0>(a));

-  EXPECT_EQ(2, get<9>(a));

-}

-

-// Tests comparing big tuples.

-TEST_F(BigTupleTest, Comparisons) {

-  EXPECT_TRUE(a_ == a_);

-  EXPECT_FALSE(a_ != a_);

-

-  EXPECT_TRUE(a_ != b_);

-  EXPECT_FALSE(a_ == b_);

-}

-

-TEST(MakeTupleTest, WorksForScalarTypes) {

-  tuple<bool, int> a;

-  a = make_tuple(true, 5);

-  EXPECT_TRUE(get<0>(a));

-  EXPECT_EQ(5, get<1>(a));

-

-  tuple<char, int, long> b;

-  b = make_tuple('a', 'b', 5);

-  EXPECT_EQ('a', get<0>(b));

-  EXPECT_EQ('b', get<1>(b));

-  EXPECT_EQ(5, get<2>(b));

-}

-

-TEST(MakeTupleTest, WorksForPointers) {

-  int a[] = { 1, 2, 3, 4 };

-  const char* const str = "hi";

-  int* const p = a;

-

-  tuple<const char*, int*> t;

-  t = make_tuple(str, p);

-  EXPECT_EQ(str, get<0>(t));

-  EXPECT_EQ(p, get<1>(t));

-}

-

-}  // namespace

+// Copyright 2007, 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: [email protected] (Zhanyong Wan)
+
+#include <gtest/internal/gtest-tuple.h>
+#include <utility>
+#include <gtest/gtest.h>
+
+namespace {
+
+using ::std::tr1::get;
+using ::std::tr1::make_tuple;
+using ::std::tr1::tuple;
+using ::std::tr1::tuple_element;
+using ::std::tr1::tuple_size;
+using ::testing::StaticAssertTypeEq;
+
+// Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK.
+TEST(tuple_element_Test, ReturnsElementType) {
+  StaticAssertTypeEq<int, tuple_element<0, tuple<int, char> >::type>();
+  StaticAssertTypeEq<int&, tuple_element<1, tuple<double, int&> >::type>();
+  StaticAssertTypeEq<bool, tuple_element<2, tuple<double, int, bool> >::type>();
+}
+
+// Tests that tuple_size<T>::value gives the number of fields in tuple
+// type T.
+TEST(tuple_size_Test, ReturnsNumberOfFields) {
+  EXPECT_EQ(0, +tuple_size<tuple<> >::value);
+  EXPECT_EQ(1, +tuple_size<tuple<void*> >::value);
+  EXPECT_EQ(1, +tuple_size<tuple<char> >::value);
+  EXPECT_EQ(1, +(tuple_size<tuple<tuple<int, double> > >::value));
+  EXPECT_EQ(2, +(tuple_size<tuple<int&, const char> >::value));
+  EXPECT_EQ(3, +(tuple_size<tuple<char*, void, const bool&> >::value));
+}
+
+// Tests comparing a tuple with itself.
+TEST(ComparisonTest, ComparesWithSelf) {
+  const tuple<int, char, bool> a(5, 'a', false);
+
+  EXPECT_TRUE(a == a);
+  EXPECT_FALSE(a != a);
+}
+
+// Tests comparing two tuples with the same value.
+TEST(ComparisonTest, ComparesEqualTuples) {
+  const tuple<int, bool> a(5, true), b(5, true);
+
+  EXPECT_TRUE(a == b);
+  EXPECT_FALSE(a != b);
+}
+
+// Tests comparing two different tuples that have no reference fields.
+TEST(ComparisonTest, ComparesUnequalTuplesWithoutReferenceFields) {
+  typedef tuple<const int, char> FooTuple;
+
+  const FooTuple a(0, 'x');
+  const FooTuple b(1, 'a');
+
+  EXPECT_TRUE(a != b);
+  EXPECT_FALSE(a == b);
+
+  const FooTuple c(1, 'b');
+
+  EXPECT_TRUE(b != c);
+  EXPECT_FALSE(b == c);
+}
+
+// Tests comparing two different tuples that have reference fields.
+TEST(ComparisonTest, ComparesUnequalTuplesWithReferenceFields) {
+  typedef tuple<int&, const char&> FooTuple;
+
+  int i = 5;
+  const char ch = 'a';
+  const FooTuple a(i, ch);
+
+  int j = 6;
+  const FooTuple b(j, ch);
+
+  EXPECT_TRUE(a != b);
+  EXPECT_FALSE(a == b);
+
+  j = 5;
+  const char ch2 = 'b';
+  const FooTuple c(j, ch2);
+
+  EXPECT_TRUE(b != c);
+  EXPECT_FALSE(b == c);
+}
+
+// Tests that a tuple field with a reference type is an alias of the
+// variable it's supposed to reference.
+TEST(ReferenceFieldTest, IsAliasOfReferencedVariable) {
+  int n = 0;
+  tuple<bool, int&> t(true, n);
+
+  n = 1;
+  EXPECT_EQ(n, get<1>(t))
+      << "Changing a underlying variable should update the reference field.";
+
+  // Makes sure that the implementation doesn't do anything funny with
+  // the & operator for the return type of get<>().
+  EXPECT_EQ(&n, &(get<1>(t)))
+      << "The address of a reference field should equal the address of "
+      << "the underlying variable.";
+
+  get<1>(t) = 2;
+  EXPECT_EQ(2, n)
+      << "Changing a reference field should update the underlying variable.";
+}
+
+// Tests tuple's default constructor.
+TEST(TupleConstructorTest, DefaultConstructor) {
+  // We are just testing that the following compiles.
+  tuple<> empty;
+  tuple<int> one_field;
+  tuple<double, char, bool*> three_fields;
+}
+
+// Tests constructing a tuple from its fields.
+TEST(TupleConstructorTest, ConstructsFromFields) {
+  int n = 1;
+  // Reference field.
+  tuple<int&> a(n);
+  EXPECT_EQ(&n, &(get<0>(a)));
+
+  // Non-reference fields.
+  tuple<int, char> b(5, 'a');
+  EXPECT_EQ(5, get<0>(b));
+  EXPECT_EQ('a', get<1>(b));
+
+  // Const reference field.
+  const int m = 2;
+  tuple<bool, const int&> c(true, m);
+  EXPECT_TRUE(get<0>(c));
+  EXPECT_EQ(&m, &(get<1>(c)));
+}
+
+// Tests tuple's copy constructor.
+TEST(TupleConstructorTest, CopyConstructor) {
+  tuple<double, bool> a(0.0, true);
+  tuple<double, bool> b(a);
+
+  EXPECT_DOUBLE_EQ(0.0, get<0>(b));
+  EXPECT_TRUE(get<1>(b));
+}
+
+// Tests constructing a tuple from another tuple that has a compatible
+// but different type.
+TEST(TupleConstructorTest, ConstructsFromDifferentTupleType) {
+  tuple<int, int, char> a(0, 1, 'a');
+  tuple<double, long, int> b(a);
+
+  EXPECT_DOUBLE_EQ(0.0, get<0>(b));
+  EXPECT_EQ(1, get<1>(b));
+  EXPECT_EQ('a', get<2>(b));
+}
+
+// Tests constructing a 2-tuple from an std::pair.
+TEST(TupleConstructorTest, ConstructsFromPair) {
+  ::std::pair<int, char> a(1, 'a');
+  tuple<int, char> b(a);
+  tuple<int, const char&> c(a);
+}
+
+// Tests assigning a tuple to another tuple with the same type.
+TEST(TupleAssignmentTest, AssignsToSameTupleType) {
+  const tuple<int, long> a(5, 7L);
+  tuple<int, long> b;
+  b = a;
+  EXPECT_EQ(5, get<0>(b));
+  EXPECT_EQ(7L, get<1>(b));
+}
+
+// Tests assigning a tuple to another tuple with a different but
+// compatible type.
+TEST(TupleAssignmentTest, AssignsToDifferentTupleType) {
+  const tuple<int, long, bool> a(1, 7L, true);
+  tuple<long, int, bool> b;
+  b = a;
+  EXPECT_EQ(1L, get<0>(b));
+  EXPECT_EQ(7, get<1>(b));
+  EXPECT_TRUE(get<2>(b));
+}
+
+// Tests assigning an std::pair to a 2-tuple.
+TEST(TupleAssignmentTest, AssignsFromPair) {
+  const ::std::pair<int, bool> a(5, true);
+  tuple<int, bool> b;
+  b = a;
+  EXPECT_EQ(5, get<0>(b));
+  EXPECT_TRUE(get<1>(b));
+
+  tuple<long, bool> c;
+  c = a;
+  EXPECT_EQ(5L, get<0>(c));
+  EXPECT_TRUE(get<1>(c));
+}
+
+// A fixture for testing big tuples.
+class BigTupleTest : public testing::Test {
+ protected:
+  typedef tuple<int, int, int, int, int, int, int, int, int, int> BigTuple;
+
+  BigTupleTest() :
+      a_(1, 0, 0, 0, 0, 0, 0, 0, 0, 2),
+      b_(1, 0, 0, 0, 0, 0, 0, 0, 0, 3) {}
+
+  BigTuple a_, b_;
+};
+
+// Tests constructing big tuples.
+TEST_F(BigTupleTest, Construction) {
+  BigTuple a;
+  BigTuple b(b_);
+}
+
+// Tests that get<N>(t) returns the N-th (0-based) field of tuple t.
+TEST_F(BigTupleTest, get) {
+  EXPECT_EQ(1, get<0>(a_));
+  EXPECT_EQ(2, get<9>(a_));
+
+  // Tests that get() works on a const tuple too.
+  const BigTuple a(a_);
+  EXPECT_EQ(1, get<0>(a));
+  EXPECT_EQ(2, get<9>(a));
+}
+
+// Tests comparing big tuples.
+TEST_F(BigTupleTest, Comparisons) {
+  EXPECT_TRUE(a_ == a_);
+  EXPECT_FALSE(a_ != a_);
+
+  EXPECT_TRUE(a_ != b_);
+  EXPECT_FALSE(a_ == b_);
+}
+
+TEST(MakeTupleTest, WorksForScalarTypes) {
+  tuple<bool, int> a;
+  a = make_tuple(true, 5);
+  EXPECT_TRUE(get<0>(a));
+  EXPECT_EQ(5, get<1>(a));
+
+  tuple<char, int, long> b;
+  b = make_tuple('a', 'b', 5);
+  EXPECT_EQ('a', get<0>(b));
+  EXPECT_EQ('b', get<1>(b));
+  EXPECT_EQ(5, get<2>(b));
+}
+
+TEST(MakeTupleTest, WorksForPointers) {
+  int a[] = { 1, 2, 3, 4 };
+  const char* const str = "hi";
+  int* const p = a;
+
+  tuple<const char*, int*> t;
+  t = make_tuple(str, p);
+  EXPECT_EQ(str, get<0>(t));
+  EXPECT_EQ(p, get<1>(t));
+}
+
+}  // namespace
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-typed-test2_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-typed-test2_test.cc
index 39d8df8a..79a8a87d 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-typed-test2_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-typed-test2_test.cc
@@ -1,45 +1,45 @@
-// Copyright 2008 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: [email protected] (Zhanyong Wan)

-

-#include <vector>

-

-#include "test/gtest-typed-test_test.h"

-#include <gtest/gtest.h>

-

-#if GTEST_HAS_TYPED_TEST_P

-

-// Tests that the same type-parameterized test case can be

-// instantiated in different translation units linked together.

-// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)

-INSTANTIATE_TYPED_TEST_CASE_P(Vector, ContainerTest,

-                              testing::Types<std::vector<int> >);

-

-#endif  // GTEST_HAS_TYPED_TEST_P

+// Copyright 2008 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: [email protected] (Zhanyong Wan)
+
+#include <vector>
+
+#include "test/gtest-typed-test_test.h"
+#include <gtest/gtest.h>
+
+#if GTEST_HAS_TYPED_TEST_P
+
+// Tests that the same type-parameterized test case can be
+// instantiated in different translation units linked together.
+// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
+INSTANTIATE_TYPED_TEST_CASE_P(Vector, ContainerTest,
+                              testing::Types<std::vector<int> >);
+
+#endif  // GTEST_HAS_TYPED_TEST_P
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-typed-test_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-typed-test_test.cc
index be8c044c..4b6e971c 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-typed-test_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-typed-test_test.cc
@@ -1,360 +1,360 @@
-// Copyright 2008 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: [email protected] (Zhanyong Wan)

-

-#include <set>

-#include <vector>

-

-#include "test/gtest-typed-test_test.h"

-#include <gtest/gtest.h>

-

-using testing::Test;

-

-// Used for testing that SetUpTestCase()/TearDownTestCase(), fixture

-// ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and

-// type-parameterized test.

-template <typename T>

-class CommonTest : public Test {

-  // For some technical reason, SetUpTestCase() and TearDownTestCase()

-  // must be public.

- public:

-  static void SetUpTestCase() {

-    shared_ = new T(5);

-  }

-

-  static void TearDownTestCase() {

-    delete shared_;

-    shared_ = NULL;

-  }

-

-  // This 'protected:' is optional.  There's no harm in making all

-  // members of this fixture class template public.

- protected:

-  // We used to use std::list here, but switched to std::vector since

-  // MSVC's <list> doesn't compile cleanly with /W4.

-  typedef std::vector<T> Vector;

-  typedef std::set<int> IntSet;

-

-  CommonTest() : value_(1) {}

-

-  virtual ~CommonTest() { EXPECT_EQ(3, value_); }

-

-  virtual void SetUp() {

-    EXPECT_EQ(1, value_);

-    value_++;

-  }

-

-  virtual void TearDown() {

-    EXPECT_EQ(2, value_);

-    value_++;

-  }

-

-  T value_;

-  static T* shared_;

-};

-

-template <typename T>

-T* CommonTest<T>::shared_ = NULL;

-

-// This #ifdef block tests typed tests.

-#if GTEST_HAS_TYPED_TEST

-

-using testing::Types;

-

-// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,

-// and SetUp()/TearDown() work correctly in typed tests

-

-typedef Types<char, int> TwoTypes;

-TYPED_TEST_CASE(CommonTest, TwoTypes);

-

-TYPED_TEST(CommonTest, ValuesAreCorrect) {

-  // Static members of the fixture class template can be visited via

-  // the TestFixture:: prefix.

-  EXPECT_EQ(5, *TestFixture::shared_);

-

-  // Typedefs in the fixture class template can be visited via the

-  // "typename TestFixture::" prefix.

-  typename TestFixture::Vector empty;

-  EXPECT_EQ(0U, empty.size());

-

-  typename TestFixture::IntSet empty2;

-  EXPECT_EQ(0U, empty2.size());

-

-  // Non-static members of the fixture class must be visited via

-  // 'this', as required by C++ for class templates.

-  EXPECT_EQ(2, this->value_);

-}

-

-// The second test makes sure shared_ is not deleted after the first

-// test.

-TYPED_TEST(CommonTest, ValuesAreStillCorrect) {

-  // Static members of the fixture class template can also be visited

-  // via 'this'.

-  ASSERT_TRUE(this->shared_ != NULL);

-  EXPECT_EQ(5, *this->shared_);

-

-  // TypeParam can be used to refer to the type parameter.

-  EXPECT_EQ(static_cast<TypeParam>(2), this->value_);

-}

-

-// Tests that multiple TYPED_TEST_CASE's can be defined in the same

-// translation unit.

-

-template <typename T>

-class TypedTest1 : public Test {

-};

-

-// Verifies that the second argument of TYPED_TEST_CASE can be a

-// single type.

-TYPED_TEST_CASE(TypedTest1, int);

-TYPED_TEST(TypedTest1, A) {}

-

-template <typename T>

-class TypedTest2 : public Test {

-};

-

-// Verifies that the second argument of TYPED_TEST_CASE can be a

-// Types<...> type list.

-TYPED_TEST_CASE(TypedTest2, Types<int>);

-

-// This also verifies that tests from different typed test cases can

-// share the same name.

-TYPED_TEST(TypedTest2, A) {}

-

-// Tests that a typed test case can be defined in a namespace.

-

-namespace library1 {

-

-template <typename T>

-class NumericTest : public Test {

-};

-

-typedef Types<int, long> NumericTypes;

-TYPED_TEST_CASE(NumericTest, NumericTypes);

-

-TYPED_TEST(NumericTest, DefaultIsZero) {

-  EXPECT_EQ(0, TypeParam());

-}

-

-}  // namespace library1

-

-#endif  // GTEST_HAS_TYPED_TEST

-

-// This #ifdef block tests type-parameterized tests.

-#if GTEST_HAS_TYPED_TEST_P

-

-using testing::Types;

-using testing::internal::TypedTestCasePState;

-

-// Tests TypedTestCasePState.

-

-class TypedTestCasePStateTest : public Test {

- protected:

-  virtual void SetUp() {

-    state_.AddTestName("foo.cc", 0, "FooTest", "A");

-    state_.AddTestName("foo.cc", 0, "FooTest", "B");

-    state_.AddTestName("foo.cc", 0, "FooTest", "C");

-  }

-

-  TypedTestCasePState state_;

-};

-

-TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) {

-  const char* tests = "A, B, C";

-  EXPECT_EQ(tests,

-            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));

-}

-

-// Makes sure that the order of the tests and spaces around the names

-// don't matter.

-TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) {

-  const char* tests = "A,C,   B";

-  EXPECT_EQ(tests,

-            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));

-}

-

-typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest;

-

-TEST_F(TypedTestCasePStateDeathTest, DetectsDuplicates) {

-  EXPECT_DEATH_IF_SUPPORTED(

-      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, A, C"),

-      "foo\\.cc.1.?: Test A is listed more than once\\.");

-}

-

-TEST_F(TypedTestCasePStateDeathTest, DetectsExtraTest) {

-  EXPECT_DEATH_IF_SUPPORTED(

-      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C, D"),

-      "foo\\.cc.1.?: No test named D can be found in this test case\\.");

-}

-

-TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) {

-  EXPECT_DEATH_IF_SUPPORTED(

-      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, C"),

-      "foo\\.cc.1.?: You forgot to list test B\\.");

-}

-

-// Tests that defining a test for a parameterized test case generates

-// a run-time error if the test case has been registered.

-TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) {

-  state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C");

-  EXPECT_DEATH_IF_SUPPORTED(

-      state_.AddTestName("foo.cc", 2, "FooTest", "D"),

-      "foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_CASE_P"

-      "\\(FooTest, \\.\\.\\.\\)\\.");

-}

-

-// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,

-// and SetUp()/TearDown() work correctly in type-parameterized tests.

-

-template <typename T>

-class DerivedTest : public CommonTest<T> {

-};

-

-TYPED_TEST_CASE_P(DerivedTest);

-

-TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {

-  // Static members of the fixture class template can be visited via

-  // the TestFixture:: prefix.

-  EXPECT_EQ(5, *TestFixture::shared_);

-

-  // Non-static members of the fixture class must be visited via

-  // 'this', as required by C++ for class templates.

-  EXPECT_EQ(2, this->value_);

-}

-

-// The second test makes sure shared_ is not deleted after the first

-// test.

-TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {

-  // Static members of the fixture class template can also be visited

-  // via 'this'.

-  ASSERT_TRUE(this->shared_ != NULL);

-  EXPECT_EQ(5, *this->shared_);

-  EXPECT_EQ(2, this->value_);

-}

-

-REGISTER_TYPED_TEST_CASE_P(DerivedTest,

-                           ValuesAreCorrect, ValuesAreStillCorrect);

-

-typedef Types<short, long> MyTwoTypes;

-INSTANTIATE_TYPED_TEST_CASE_P(My, DerivedTest, MyTwoTypes);

-

-// Tests that multiple TYPED_TEST_CASE_P's can be defined in the same

-// translation unit.

-

-template <typename T>

-class TypedTestP1 : public Test {

-};

-

-TYPED_TEST_CASE_P(TypedTestP1);

-

-// For testing that the code between TYPED_TEST_CASE_P() and

-// TYPED_TEST_P() is not enclosed in a namespace.

-typedef int IntAfterTypedTestCaseP;

-

-TYPED_TEST_P(TypedTestP1, A) {}

-TYPED_TEST_P(TypedTestP1, B) {}

-

-// For testing that the code between TYPED_TEST_P() and

-// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.

-typedef int IntBeforeRegisterTypedTestCaseP;

-

-REGISTER_TYPED_TEST_CASE_P(TypedTestP1, A, B);

-

-template <typename T>

-class TypedTestP2 : public Test {

-};

-

-TYPED_TEST_CASE_P(TypedTestP2);

-

-// This also verifies that tests from different type-parameterized

-// test cases can share the same name.

-TYPED_TEST_P(TypedTestP2, A) {}

-

-REGISTER_TYPED_TEST_CASE_P(TypedTestP2, A);

-

-// Verifies that the code between TYPED_TEST_CASE_P() and

-// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.

-IntAfterTypedTestCaseP after = 0;

-IntBeforeRegisterTypedTestCaseP before = 0;

-

-// Verifies that the last argument of INSTANTIATE_TYPED_TEST_CASE_P()

-// can be either a single type or a Types<...> type list.

-INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP1, int);

-INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP2, Types<int>);

-

-// Tests that the same type-parameterized test case can be

-// instantiated more than once in the same translation unit.

-INSTANTIATE_TYPED_TEST_CASE_P(Double, TypedTestP2, Types<double>);

-

-// Tests that the same type-parameterized test case can be

-// instantiated in different translation units linked together.

-// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)

-typedef Types<std::vector<double>, std::set<char> > MyContainers;

-INSTANTIATE_TYPED_TEST_CASE_P(My, ContainerTest, MyContainers);

-

-// Tests that a type-parameterized test case can be defined and

-// instantiated in a namespace.

-

-namespace library2 {

-

-template <typename T>

-class NumericTest : public Test {

-};

-

-TYPED_TEST_CASE_P(NumericTest);

-

-TYPED_TEST_P(NumericTest, DefaultIsZero) {

-  EXPECT_EQ(0, TypeParam());

-}

-

-TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {

-  EXPECT_LT(TypeParam(0), TypeParam(1));

-}

-

-REGISTER_TYPED_TEST_CASE_P(NumericTest,

-                           DefaultIsZero, ZeroIsLessThanOne);

-typedef Types<int, double> NumericTypes;

-INSTANTIATE_TYPED_TEST_CASE_P(My, NumericTest, NumericTypes);

-

-}  // namespace library2

-

-#endif  // GTEST_HAS_TYPED_TEST_P

-

-#if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)

-

-// Google Test doesn't support type-parameterized tests on some platforms

-// and compilers, such as MSVC 7.1. If we use conditional compilation to

-// compile out all code referring to the gtest_main library, MSVC linker

-// will not link that library at all and consequently complain about

-// missing entry point defined in that library (fatal error LNK1561:

-// entry point must be defined). This dummy test keeps gtest_main linked in.

-TEST(DummyTest, TypedTestsAreNotSupportedOnThisPlatform) {}

-

-#endif  // #if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)

+// Copyright 2008 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: [email protected] (Zhanyong Wan)
+
+#include <set>
+#include <vector>
+
+#include "test/gtest-typed-test_test.h"
+#include <gtest/gtest.h>
+
+using testing::Test;
+
+// Used for testing that SetUpTestCase()/TearDownTestCase(), fixture
+// ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and
+// type-parameterized test.
+template <typename T>
+class CommonTest : public Test {
+  // For some technical reason, SetUpTestCase() and TearDownTestCase()
+  // must be public.
+ public:
+  static void SetUpTestCase() {
+    shared_ = new T(5);
+  }
+
+  static void TearDownTestCase() {
+    delete shared_;
+    shared_ = NULL;
+  }
+
+  // This 'protected:' is optional.  There's no harm in making all
+  // members of this fixture class template public.
+ protected:
+  // We used to use std::list here, but switched to std::vector since
+  // MSVC's <list> doesn't compile cleanly with /W4.
+  typedef std::vector<T> Vector;
+  typedef std::set<int> IntSet;
+
+  CommonTest() : value_(1) {}
+
+  virtual ~CommonTest() { EXPECT_EQ(3, value_); }
+
+  virtual void SetUp() {
+    EXPECT_EQ(1, value_);
+    value_++;
+  }
+
+  virtual void TearDown() {
+    EXPECT_EQ(2, value_);
+    value_++;
+  }
+
+  T value_;
+  static T* shared_;
+};
+
+template <typename T>
+T* CommonTest<T>::shared_ = NULL;
+
+// This #ifdef block tests typed tests.
+#if GTEST_HAS_TYPED_TEST
+
+using testing::Types;
+
+// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
+// and SetUp()/TearDown() work correctly in typed tests
+
+typedef Types<char, int> TwoTypes;
+TYPED_TEST_CASE(CommonTest, TwoTypes);
+
+TYPED_TEST(CommonTest, ValuesAreCorrect) {
+  // Static members of the fixture class template can be visited via
+  // the TestFixture:: prefix.
+  EXPECT_EQ(5, *TestFixture::shared_);
+
+  // Typedefs in the fixture class template can be visited via the
+  // "typename TestFixture::" prefix.
+  typename TestFixture::Vector empty;
+  EXPECT_EQ(0U, empty.size());
+
+  typename TestFixture::IntSet empty2;
+  EXPECT_EQ(0U, empty2.size());
+
+  // Non-static members of the fixture class must be visited via
+  // 'this', as required by C++ for class templates.
+  EXPECT_EQ(2, this->value_);
+}
+
+// The second test makes sure shared_ is not deleted after the first
+// test.
+TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
+  // Static members of the fixture class template can also be visited
+  // via 'this'.
+  ASSERT_TRUE(this->shared_ != NULL);
+  EXPECT_EQ(5, *this->shared_);
+
+  // TypeParam can be used to refer to the type parameter.
+  EXPECT_EQ(static_cast<TypeParam>(2), this->value_);
+}
+
+// Tests that multiple TYPED_TEST_CASE's can be defined in the same
+// translation unit.
+
+template <typename T>
+class TypedTest1 : public Test {
+};
+
+// Verifies that the second argument of TYPED_TEST_CASE can be a
+// single type.
+TYPED_TEST_CASE(TypedTest1, int);
+TYPED_TEST(TypedTest1, A) {}
+
+template <typename T>
+class TypedTest2 : public Test {
+};
+
+// Verifies that the second argument of TYPED_TEST_CASE can be a
+// Types<...> type list.
+TYPED_TEST_CASE(TypedTest2, Types<int>);
+
+// This also verifies that tests from different typed test cases can
+// share the same name.
+TYPED_TEST(TypedTest2, A) {}
+
+// Tests that a typed test case can be defined in a namespace.
+
+namespace library1 {
+
+template <typename T>
+class NumericTest : public Test {
+};
+
+typedef Types<int, long> NumericTypes;
+TYPED_TEST_CASE(NumericTest, NumericTypes);
+
+TYPED_TEST(NumericTest, DefaultIsZero) {
+  EXPECT_EQ(0, TypeParam());
+}
+
+}  // namespace library1
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+// This #ifdef block tests type-parameterized tests.
+#if GTEST_HAS_TYPED_TEST_P
+
+using testing::Types;
+using testing::internal::TypedTestCasePState;
+
+// Tests TypedTestCasePState.
+
+class TypedTestCasePStateTest : public Test {
+ protected:
+  virtual void SetUp() {
+    state_.AddTestName("foo.cc", 0, "FooTest", "A");
+    state_.AddTestName("foo.cc", 0, "FooTest", "B");
+    state_.AddTestName("foo.cc", 0, "FooTest", "C");
+  }
+
+  TypedTestCasePState state_;
+};
+
+TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) {
+  const char* tests = "A, B, C";
+  EXPECT_EQ(tests,
+            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
+}
+
+// Makes sure that the order of the tests and spaces around the names
+// don't matter.
+TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) {
+  const char* tests = "A,C,   B";
+  EXPECT_EQ(tests,
+            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
+}
+
+typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest;
+
+TEST_F(TypedTestCasePStateDeathTest, DetectsDuplicates) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, A, C"),
+      "foo\\.cc.1.?: Test A is listed more than once\\.");
+}
+
+TEST_F(TypedTestCasePStateDeathTest, DetectsExtraTest) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C, D"),
+      "foo\\.cc.1.?: No test named D can be found in this test case\\.");
+}
+
+TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, C"),
+      "foo\\.cc.1.?: You forgot to list test B\\.");
+}
+
+// Tests that defining a test for a parameterized test case generates
+// a run-time error if the test case has been registered.
+TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) {
+  state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C");
+  EXPECT_DEATH_IF_SUPPORTED(
+      state_.AddTestName("foo.cc", 2, "FooTest", "D"),
+      "foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_CASE_P"
+      "\\(FooTest, \\.\\.\\.\\)\\.");
+}
+
+// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
+// and SetUp()/TearDown() work correctly in type-parameterized tests.
+
+template <typename T>
+class DerivedTest : public CommonTest<T> {
+};
+
+TYPED_TEST_CASE_P(DerivedTest);
+
+TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
+  // Static members of the fixture class template can be visited via
+  // the TestFixture:: prefix.
+  EXPECT_EQ(5, *TestFixture::shared_);
+
+  // Non-static members of the fixture class must be visited via
+  // 'this', as required by C++ for class templates.
+  EXPECT_EQ(2, this->value_);
+}
+
+// The second test makes sure shared_ is not deleted after the first
+// test.
+TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
+  // Static members of the fixture class template can also be visited
+  // via 'this'.
+  ASSERT_TRUE(this->shared_ != NULL);
+  EXPECT_EQ(5, *this->shared_);
+  EXPECT_EQ(2, this->value_);
+}
+
+REGISTER_TYPED_TEST_CASE_P(DerivedTest,
+                           ValuesAreCorrect, ValuesAreStillCorrect);
+
+typedef Types<short, long> MyTwoTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, DerivedTest, MyTwoTypes);
+
+// Tests that multiple TYPED_TEST_CASE_P's can be defined in the same
+// translation unit.
+
+template <typename T>
+class TypedTestP1 : public Test {
+};
+
+TYPED_TEST_CASE_P(TypedTestP1);
+
+// For testing that the code between TYPED_TEST_CASE_P() and
+// TYPED_TEST_P() is not enclosed in a namespace.
+typedef int IntAfterTypedTestCaseP;
+
+TYPED_TEST_P(TypedTestP1, A) {}
+TYPED_TEST_P(TypedTestP1, B) {}
+
+// For testing that the code between TYPED_TEST_P() and
+// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
+typedef int IntBeforeRegisterTypedTestCaseP;
+
+REGISTER_TYPED_TEST_CASE_P(TypedTestP1, A, B);
+
+template <typename T>
+class TypedTestP2 : public Test {
+};
+
+TYPED_TEST_CASE_P(TypedTestP2);
+
+// This also verifies that tests from different type-parameterized
+// test cases can share the same name.
+TYPED_TEST_P(TypedTestP2, A) {}
+
+REGISTER_TYPED_TEST_CASE_P(TypedTestP2, A);
+
+// Verifies that the code between TYPED_TEST_CASE_P() and
+// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
+IntAfterTypedTestCaseP after = 0;
+IntBeforeRegisterTypedTestCaseP before = 0;
+
+// Verifies that the last argument of INSTANTIATE_TYPED_TEST_CASE_P()
+// can be either a single type or a Types<...> type list.
+INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP1, int);
+INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP2, Types<int>);
+
+// Tests that the same type-parameterized test case can be
+// instantiated more than once in the same translation unit.
+INSTANTIATE_TYPED_TEST_CASE_P(Double, TypedTestP2, Types<double>);
+
+// Tests that the same type-parameterized test case can be
+// instantiated in different translation units linked together.
+// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
+typedef Types<std::vector<double>, std::set<char> > MyContainers;
+INSTANTIATE_TYPED_TEST_CASE_P(My, ContainerTest, MyContainers);
+
+// Tests that a type-parameterized test case can be defined and
+// instantiated in a namespace.
+
+namespace library2 {
+
+template <typename T>
+class NumericTest : public Test {
+};
+
+TYPED_TEST_CASE_P(NumericTest);
+
+TYPED_TEST_P(NumericTest, DefaultIsZero) {
+  EXPECT_EQ(0, TypeParam());
+}
+
+TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
+  EXPECT_LT(TypeParam(0), TypeParam(1));
+}
+
+REGISTER_TYPED_TEST_CASE_P(NumericTest,
+                           DefaultIsZero, ZeroIsLessThanOne);
+typedef Types<int, double> NumericTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, NumericTest, NumericTypes);
+
+}  // namespace library2
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+#if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
+
+// Google Test doesn't support type-parameterized tests on some platforms
+// and compilers, such as MSVC 7.1. If we use conditional compilation to
+// compile out all code referring to the gtest_main library, MSVC linker
+// will not link that library at all and consequently complain about
+// missing entry point defined in that library (fatal error LNK1561:
+// entry point must be defined). This dummy test keeps gtest_main linked in.
+TEST(DummyTest, TypedTestsAreNotSupportedOnThisPlatform) {}
+
+#endif  // #if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-unittest-api_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-unittest-api_test.cc
index 30ec0046..7e0f8f80 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-unittest-api_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest-unittest-api_test.cc
@@ -1,343 +1,343 @@
-// 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: [email protected] (Vlad Losev)

-//

-// The Google C++ Testing Framework (Google Test)

-//

-// This file contains tests verifying correctness of data provided via

-// UnitTest's public methods.

-

-#include <gtest/gtest.h>

-

-#include <string.h>  // For strcmp.

-#include <algorithm>

-

-using ::testing::InitGoogleTest;

-

-namespace testing {

-namespace internal {

-

-template <typename T>

-struct LessByName {

-  bool operator()(const T* a, const T* b) {

-    return strcmp(a->name(), b->name()) < 0;

-  }

-};

-

-class UnitTestHelper {

- public:

-  // Returns the array of pointers to all test cases sorted by the test case

-  // name.  The caller is responsible for deleting the array.

-  static TestCase const** const GetSortedTestCases() {

-    UnitTest& unit_test = *UnitTest::GetInstance();

-    TestCase const** const test_cases =

-        new const TestCase*[unit_test.total_test_case_count()];

-

-    for (int i = 0; i < unit_test.total_test_case_count(); ++i)

-      test_cases[i] = unit_test.GetTestCase(i);

-

-    std::sort(test_cases,

-              test_cases + unit_test.total_test_case_count(),

-              LessByName<TestCase>());

-    return test_cases;

-  }

-

-  // Returns the test case by its name.  The caller doesn't own the returned

-  // pointer.

-  static const TestCase* FindTestCase(const char* name) {

-    UnitTest& unit_test = *UnitTest::GetInstance();

-    for (int i = 0; i < unit_test.total_test_case_count(); ++i) {

-      const TestCase* test_case = unit_test.GetTestCase(i);

-      if (0 == strcmp(test_case->name(), name))

-        return test_case;

-    }

-    return NULL;

-  }

-

-  // Returns the array of pointers to all tests in a particular test case

-  // sorted by the test name.  The caller is responsible for deleting the

-  // array.

-  static TestInfo const** const GetSortedTests(const TestCase* test_case) {

-    TestInfo const** const tests =

-        new const TestInfo*[test_case->total_test_count()];

-

-    for (int i = 0; i < test_case->total_test_count(); ++i)

-      tests[i] = test_case->GetTestInfo(i);

-

-    std::sort(tests, tests + test_case->total_test_count(),

-              LessByName<TestInfo>());

-    return tests;

-  }

-};

-

-#if GTEST_HAS_TYPED_TEST

-template <typename T> class TestCaseWithCommentTest : public Test {};

-TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);

-TYPED_TEST(TestCaseWithCommentTest, Dummy) {}

-

-const int kTypedTestCases = 1;

-const int kTypedTests = 1;

-

-String GetExpectedTestCaseComment() {

-  Message comment;

-  comment << "TypeParam = " << GetTypeName<int>().c_str();

-  return comment.GetString();

-}

-#else

-const int kTypedTestCases = 0;

-const int kTypedTests = 0;

-#endif  // GTEST_HAS_TYPED_TEST

-

-// We can only test the accessors that do not change value while tests run.

-// Since tests can be run in any order, the values the accessors that track

-// test execution (such as failed_test_count) can not be predicted.

-TEST(ApiTest, UnitTestImmutableAccessorsWork) {

-  UnitTest* unit_test = UnitTest::GetInstance();

-

-  ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());

-  EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());

-  EXPECT_EQ(2, unit_test->disabled_test_count());

-  EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());

-  EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());

-

-  const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();

-

-  EXPECT_STREQ("ApiTest", test_cases[0]->name());

-  EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());

-#if GTEST_HAS_TYPED_TEST

-  EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());

-#endif  // GTEST_HAS_TYPED_TEST

-

-  delete[] test_cases;

-

-  // The following lines initiate actions to verify certain methods in

-  // FinalSuccessChecker::TearDown.

-

-  // Records a test property to verify TestResult::GetTestProperty().

-  RecordProperty("key", "value");

-}

-

-TEST(ApiTest, TestCaseImmutableAccessorsWork) {

-  const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");

-  ASSERT_TRUE(test_case != NULL);

-

-  EXPECT_STREQ("ApiTest", test_case->name());

-  EXPECT_STREQ("", test_case->comment());

-  EXPECT_TRUE(test_case->should_run());

-  EXPECT_EQ(1, test_case->disabled_test_count());

-  EXPECT_EQ(3, test_case->test_to_run_count());

-  ASSERT_EQ(4, test_case->total_test_count());

-

-  const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);

-

-  EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());

-  EXPECT_STREQ("ApiTest", tests[0]->test_case_name());

-  EXPECT_STREQ("", tests[0]->comment());

-  EXPECT_STREQ("", tests[0]->test_case_comment());

-  EXPECT_FALSE(tests[0]->should_run());

-

-  EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());

-  EXPECT_STREQ("ApiTest", tests[1]->test_case_name());

-  EXPECT_STREQ("", tests[1]->comment());

-  EXPECT_STREQ("", tests[1]->test_case_comment());

-  EXPECT_TRUE(tests[1]->should_run());

-

-  EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());

-  EXPECT_STREQ("ApiTest", tests[2]->test_case_name());

-  EXPECT_STREQ("", tests[2]->comment());

-  EXPECT_STREQ("", tests[2]->test_case_comment());

-  EXPECT_TRUE(tests[2]->should_run());

-

-  EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());

-  EXPECT_STREQ("ApiTest", tests[3]->test_case_name());

-  EXPECT_STREQ("", tests[3]->comment());

-  EXPECT_STREQ("", tests[3]->test_case_comment());

-  EXPECT_TRUE(tests[3]->should_run());

-

-  delete[] tests;

-  tests = NULL;

-

-#if GTEST_HAS_TYPED_TEST

-  test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");

-  ASSERT_TRUE(test_case != NULL);

-

-  EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());

-  EXPECT_STREQ(GetExpectedTestCaseComment().c_str(), test_case->comment());

-  EXPECT_TRUE(test_case->should_run());

-  EXPECT_EQ(0, test_case->disabled_test_count());

-  EXPECT_EQ(1, test_case->test_to_run_count());

-  ASSERT_EQ(1, test_case->total_test_count());

-

-  tests = UnitTestHelper::GetSortedTests(test_case);

-

-  EXPECT_STREQ("Dummy", tests[0]->name());

-  EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());

-  EXPECT_STREQ("", tests[0]->comment());

-  EXPECT_STREQ(GetExpectedTestCaseComment().c_str(),

-               tests[0]->test_case_comment());

-  EXPECT_TRUE(tests[0]->should_run());

-

-  delete[] tests;

-#endif  // GTEST_HAS_TYPED_TEST

-}

-

-TEST(ApiTest, TestCaseDisabledAccessorsWork) {

-  const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");

-  ASSERT_TRUE(test_case != NULL);

-

-  EXPECT_STREQ("DISABLED_Test", test_case->name());

-  EXPECT_STREQ("", test_case->comment());

-  EXPECT_FALSE(test_case->should_run());

-  EXPECT_EQ(1, test_case->disabled_test_count());

-  EXPECT_EQ(0, test_case->test_to_run_count());

-  ASSERT_EQ(1, test_case->total_test_count());

-

-  const TestInfo* const test_info = test_case->GetTestInfo(0);

-  EXPECT_STREQ("Dummy2", test_info->name());

-  EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());

-  EXPECT_STREQ("", test_info->comment());

-  EXPECT_STREQ("", test_info->test_case_comment());

-  EXPECT_FALSE(test_info->should_run());

-}

-

-// These two tests are here to provide support for testing

-// test_case_to_run_count, disabled_test_count, and test_to_run_count.

-TEST(ApiTest, DISABLED_Dummy1) {}

-TEST(DISABLED_Test, Dummy2) {}

-

-class FinalSuccessChecker : public Environment {

- protected:

-  virtual void TearDown() {

-    UnitTest* unit_test = UnitTest::GetInstance();

-

-    EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());

-    EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());

-    EXPECT_EQ(0, unit_test->failed_test_case_count());

-    EXPECT_EQ(0, unit_test->failed_test_count());

-    EXPECT_TRUE(unit_test->Passed());

-    EXPECT_FALSE(unit_test->Failed());

-    ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());

-

-    const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();

-

-    EXPECT_STREQ("ApiTest", test_cases[0]->name());

-    EXPECT_STREQ("", test_cases[0]->comment());

-    EXPECT_TRUE(test_cases[0]->should_run());

-    EXPECT_EQ(1, test_cases[0]->disabled_test_count());

-    ASSERT_EQ(4, test_cases[0]->total_test_count());

-    EXPECT_EQ(3, test_cases[0]->successful_test_count());

-    EXPECT_EQ(0, test_cases[0]->failed_test_count());

-    EXPECT_TRUE(test_cases[0]->Passed());

-    EXPECT_FALSE(test_cases[0]->Failed());

-

-    EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());

-    EXPECT_STREQ("", test_cases[1]->comment());

-    EXPECT_FALSE(test_cases[1]->should_run());

-    EXPECT_EQ(1, test_cases[1]->disabled_test_count());

-    ASSERT_EQ(1, test_cases[1]->total_test_count());

-    EXPECT_EQ(0, test_cases[1]->successful_test_count());

-    EXPECT_EQ(0, test_cases[1]->failed_test_count());

-

-#if GTEST_HAS_TYPED_TEST

-    EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());

-    EXPECT_STREQ(GetExpectedTestCaseComment().c_str(),

-                 test_cases[2]->comment());

-    EXPECT_TRUE(test_cases[2]->should_run());

-    EXPECT_EQ(0, test_cases[2]->disabled_test_count());

-    ASSERT_EQ(1, test_cases[2]->total_test_count());

-    EXPECT_EQ(1, test_cases[2]->successful_test_count());

-    EXPECT_EQ(0, test_cases[2]->failed_test_count());

-    EXPECT_TRUE(test_cases[2]->Passed());

-    EXPECT_FALSE(test_cases[2]->Failed());

-#endif  // GTEST_HAS_TYPED_TEST

-

-    const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");

-    const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);

-    EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());

-    EXPECT_STREQ("ApiTest", tests[0]->test_case_name());

-    EXPECT_FALSE(tests[0]->should_run());

-

-    EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());

-    EXPECT_STREQ("ApiTest", tests[1]->test_case_name());

-    EXPECT_STREQ("", tests[1]->comment());

-    EXPECT_STREQ("", tests[1]->test_case_comment());

-    EXPECT_TRUE(tests[1]->should_run());

-    EXPECT_TRUE(tests[1]->result()->Passed());

-    EXPECT_EQ(0, tests[1]->result()->test_property_count());

-

-    EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());

-    EXPECT_STREQ("ApiTest", tests[2]->test_case_name());

-    EXPECT_STREQ("", tests[2]->comment());

-    EXPECT_STREQ("", tests[2]->test_case_comment());

-    EXPECT_TRUE(tests[2]->should_run());

-    EXPECT_TRUE(tests[2]->result()->Passed());

-    EXPECT_EQ(0, tests[2]->result()->test_property_count());

-

-    EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());

-    EXPECT_STREQ("ApiTest", tests[3]->test_case_name());

-    EXPECT_STREQ("", tests[3]->comment());

-    EXPECT_STREQ("", tests[3]->test_case_comment());

-    EXPECT_TRUE(tests[3]->should_run());

-    EXPECT_TRUE(tests[3]->result()->Passed());

-    EXPECT_EQ(1, tests[3]->result()->test_property_count());

-    const TestProperty& property = tests[3]->result()->GetTestProperty(0);

-    EXPECT_STREQ("key", property.key());

-    EXPECT_STREQ("value", property.value());

-

-    delete[] tests;

-

-#if GTEST_HAS_TYPED_TEST

-    test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");

-    tests = UnitTestHelper::GetSortedTests(test_case);

-

-    EXPECT_STREQ("Dummy", tests[0]->name());

-    EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());

-    EXPECT_STREQ("", tests[0]->comment());

-    EXPECT_STREQ(GetExpectedTestCaseComment().c_str(),

-                 tests[0]->test_case_comment());

-    EXPECT_TRUE(tests[0]->should_run());

-    EXPECT_TRUE(tests[0]->result()->Passed());

-    EXPECT_EQ(0, tests[0]->result()->test_property_count());

-

-    delete[] tests;

-#endif  // GTEST_HAS_TYPED_TEST

-    delete[] test_cases;

-  }

-};

-

-}  // namespace internal

-}  // namespace testing

-

-int main(int argc, char **argv) {

-  InitGoogleTest(&argc, argv);

-

-  AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());

-

-  return RUN_ALL_TESTS();

-}

+// 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: [email protected] (Vlad Losev)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This file contains tests verifying correctness of data provided via
+// UnitTest's public methods.
+
+#include <gtest/gtest.h>
+
+#include <string.h>  // For strcmp.
+#include <algorithm>
+
+using ::testing::InitGoogleTest;
+
+namespace testing {
+namespace internal {
+
+template <typename T>
+struct LessByName {
+  bool operator()(const T* a, const T* b) {
+    return strcmp(a->name(), b->name()) < 0;
+  }
+};
+
+class UnitTestHelper {
+ public:
+  // Returns the array of pointers to all test cases sorted by the test case
+  // name.  The caller is responsible for deleting the array.
+  static TestCase const** const GetSortedTestCases() {
+    UnitTest& unit_test = *UnitTest::GetInstance();
+    TestCase const** const test_cases =
+        new const TestCase*[unit_test.total_test_case_count()];
+
+    for (int i = 0; i < unit_test.total_test_case_count(); ++i)
+      test_cases[i] = unit_test.GetTestCase(i);
+
+    std::sort(test_cases,
+              test_cases + unit_test.total_test_case_count(),
+              LessByName<TestCase>());
+    return test_cases;
+  }
+
+  // Returns the test case by its name.  The caller doesn't own the returned
+  // pointer.
+  static const TestCase* FindTestCase(const char* name) {
+    UnitTest& unit_test = *UnitTest::GetInstance();
+    for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
+      const TestCase* test_case = unit_test.GetTestCase(i);
+      if (0 == strcmp(test_case->name(), name))
+        return test_case;
+    }
+    return NULL;
+  }
+
+  // Returns the array of pointers to all tests in a particular test case
+  // sorted by the test name.  The caller is responsible for deleting the
+  // array.
+  static TestInfo const** const GetSortedTests(const TestCase* test_case) {
+    TestInfo const** const tests =
+        new const TestInfo*[test_case->total_test_count()];
+
+    for (int i = 0; i < test_case->total_test_count(); ++i)
+      tests[i] = test_case->GetTestInfo(i);
+
+    std::sort(tests, tests + test_case->total_test_count(),
+              LessByName<TestInfo>());
+    return tests;
+  }
+};
+
+#if GTEST_HAS_TYPED_TEST
+template <typename T> class TestCaseWithCommentTest : public Test {};
+TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);
+TYPED_TEST(TestCaseWithCommentTest, Dummy) {}
+
+const int kTypedTestCases = 1;
+const int kTypedTests = 1;
+
+String GetExpectedTestCaseComment() {
+  Message comment;
+  comment << "TypeParam = " << GetTypeName<int>().c_str();
+  return comment.GetString();
+}
+#else
+const int kTypedTestCases = 0;
+const int kTypedTests = 0;
+#endif  // GTEST_HAS_TYPED_TEST
+
+// We can only test the accessors that do not change value while tests run.
+// Since tests can be run in any order, the values the accessors that track
+// test execution (such as failed_test_count) can not be predicted.
+TEST(ApiTest, UnitTestImmutableAccessorsWork) {
+  UnitTest* unit_test = UnitTest::GetInstance();
+
+  ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
+  EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
+  EXPECT_EQ(2, unit_test->disabled_test_count());
+  EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
+  EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());
+
+  const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
+
+  EXPECT_STREQ("ApiTest", test_cases[0]->name());
+  EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
+#if GTEST_HAS_TYPED_TEST
+  EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
+#endif  // GTEST_HAS_TYPED_TEST
+
+  delete[] test_cases;
+
+  // The following lines initiate actions to verify certain methods in
+  // FinalSuccessChecker::TearDown.
+
+  // Records a test property to verify TestResult::GetTestProperty().
+  RecordProperty("key", "value");
+}
+
+TEST(ApiTest, TestCaseImmutableAccessorsWork) {
+  const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
+  ASSERT_TRUE(test_case != NULL);
+
+  EXPECT_STREQ("ApiTest", test_case->name());
+  EXPECT_STREQ("", test_case->comment());
+  EXPECT_TRUE(test_case->should_run());
+  EXPECT_EQ(1, test_case->disabled_test_count());
+  EXPECT_EQ(3, test_case->test_to_run_count());
+  ASSERT_EQ(4, test_case->total_test_count());
+
+  const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
+
+  EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
+  EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
+  EXPECT_STREQ("", tests[0]->comment());
+  EXPECT_STREQ("", tests[0]->test_case_comment());
+  EXPECT_FALSE(tests[0]->should_run());
+
+  EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
+  EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
+  EXPECT_STREQ("", tests[1]->comment());
+  EXPECT_STREQ("", tests[1]->test_case_comment());
+  EXPECT_TRUE(tests[1]->should_run());
+
+  EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
+  EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
+  EXPECT_STREQ("", tests[2]->comment());
+  EXPECT_STREQ("", tests[2]->test_case_comment());
+  EXPECT_TRUE(tests[2]->should_run());
+
+  EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
+  EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
+  EXPECT_STREQ("", tests[3]->comment());
+  EXPECT_STREQ("", tests[3]->test_case_comment());
+  EXPECT_TRUE(tests[3]->should_run());
+
+  delete[] tests;
+  tests = NULL;
+
+#if GTEST_HAS_TYPED_TEST
+  test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
+  ASSERT_TRUE(test_case != NULL);
+
+  EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
+  EXPECT_STREQ(GetExpectedTestCaseComment().c_str(), test_case->comment());
+  EXPECT_TRUE(test_case->should_run());
+  EXPECT_EQ(0, test_case->disabled_test_count());
+  EXPECT_EQ(1, test_case->test_to_run_count());
+  ASSERT_EQ(1, test_case->total_test_count());
+
+  tests = UnitTestHelper::GetSortedTests(test_case);
+
+  EXPECT_STREQ("Dummy", tests[0]->name());
+  EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
+  EXPECT_STREQ("", tests[0]->comment());
+  EXPECT_STREQ(GetExpectedTestCaseComment().c_str(),
+               tests[0]->test_case_comment());
+  EXPECT_TRUE(tests[0]->should_run());
+
+  delete[] tests;
+#endif  // GTEST_HAS_TYPED_TEST
+}
+
+TEST(ApiTest, TestCaseDisabledAccessorsWork) {
+  const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
+  ASSERT_TRUE(test_case != NULL);
+
+  EXPECT_STREQ("DISABLED_Test", test_case->name());
+  EXPECT_STREQ("", test_case->comment());
+  EXPECT_FALSE(test_case->should_run());
+  EXPECT_EQ(1, test_case->disabled_test_count());
+  EXPECT_EQ(0, test_case->test_to_run_count());
+  ASSERT_EQ(1, test_case->total_test_count());
+
+  const TestInfo* const test_info = test_case->GetTestInfo(0);
+  EXPECT_STREQ("Dummy2", test_info->name());
+  EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
+  EXPECT_STREQ("", test_info->comment());
+  EXPECT_STREQ("", test_info->test_case_comment());
+  EXPECT_FALSE(test_info->should_run());
+}
+
+// These two tests are here to provide support for testing
+// test_case_to_run_count, disabled_test_count, and test_to_run_count.
+TEST(ApiTest, DISABLED_Dummy1) {}
+TEST(DISABLED_Test, Dummy2) {}
+
+class FinalSuccessChecker : public Environment {
+ protected:
+  virtual void TearDown() {
+    UnitTest* unit_test = UnitTest::GetInstance();
+
+    EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());
+    EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
+    EXPECT_EQ(0, unit_test->failed_test_case_count());
+    EXPECT_EQ(0, unit_test->failed_test_count());
+    EXPECT_TRUE(unit_test->Passed());
+    EXPECT_FALSE(unit_test->Failed());
+    ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
+
+    const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
+
+    EXPECT_STREQ("ApiTest", test_cases[0]->name());
+    EXPECT_STREQ("", test_cases[0]->comment());
+    EXPECT_TRUE(test_cases[0]->should_run());
+    EXPECT_EQ(1, test_cases[0]->disabled_test_count());
+    ASSERT_EQ(4, test_cases[0]->total_test_count());
+    EXPECT_EQ(3, test_cases[0]->successful_test_count());
+    EXPECT_EQ(0, test_cases[0]->failed_test_count());
+    EXPECT_TRUE(test_cases[0]->Passed());
+    EXPECT_FALSE(test_cases[0]->Failed());
+
+    EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
+    EXPECT_STREQ("", test_cases[1]->comment());
+    EXPECT_FALSE(test_cases[1]->should_run());
+    EXPECT_EQ(1, test_cases[1]->disabled_test_count());
+    ASSERT_EQ(1, test_cases[1]->total_test_count());
+    EXPECT_EQ(0, test_cases[1]->successful_test_count());
+    EXPECT_EQ(0, test_cases[1]->failed_test_count());
+
+#if GTEST_HAS_TYPED_TEST
+    EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
+    EXPECT_STREQ(GetExpectedTestCaseComment().c_str(),
+                 test_cases[2]->comment());
+    EXPECT_TRUE(test_cases[2]->should_run());
+    EXPECT_EQ(0, test_cases[2]->disabled_test_count());
+    ASSERT_EQ(1, test_cases[2]->total_test_count());
+    EXPECT_EQ(1, test_cases[2]->successful_test_count());
+    EXPECT_EQ(0, test_cases[2]->failed_test_count());
+    EXPECT_TRUE(test_cases[2]->Passed());
+    EXPECT_FALSE(test_cases[2]->Failed());
+#endif  // GTEST_HAS_TYPED_TEST
+
+    const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
+    const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
+    EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
+    EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
+    EXPECT_FALSE(tests[0]->should_run());
+
+    EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
+    EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
+    EXPECT_STREQ("", tests[1]->comment());
+    EXPECT_STREQ("", tests[1]->test_case_comment());
+    EXPECT_TRUE(tests[1]->should_run());
+    EXPECT_TRUE(tests[1]->result()->Passed());
+    EXPECT_EQ(0, tests[1]->result()->test_property_count());
+
+    EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
+    EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
+    EXPECT_STREQ("", tests[2]->comment());
+    EXPECT_STREQ("", tests[2]->test_case_comment());
+    EXPECT_TRUE(tests[2]->should_run());
+    EXPECT_TRUE(tests[2]->result()->Passed());
+    EXPECT_EQ(0, tests[2]->result()->test_property_count());
+
+    EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
+    EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
+    EXPECT_STREQ("", tests[3]->comment());
+    EXPECT_STREQ("", tests[3]->test_case_comment());
+    EXPECT_TRUE(tests[3]->should_run());
+    EXPECT_TRUE(tests[3]->result()->Passed());
+    EXPECT_EQ(1, tests[3]->result()->test_property_count());
+    const TestProperty& property = tests[3]->result()->GetTestProperty(0);
+    EXPECT_STREQ("key", property.key());
+    EXPECT_STREQ("value", property.value());
+
+    delete[] tests;
+
+#if GTEST_HAS_TYPED_TEST
+    test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
+    tests = UnitTestHelper::GetSortedTests(test_case);
+
+    EXPECT_STREQ("Dummy", tests[0]->name());
+    EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
+    EXPECT_STREQ("", tests[0]->comment());
+    EXPECT_STREQ(GetExpectedTestCaseComment().c_str(),
+                 tests[0]->test_case_comment());
+    EXPECT_TRUE(tests[0]->should_run());
+    EXPECT_TRUE(tests[0]->result()->Passed());
+    EXPECT_EQ(0, tests[0]->result()->test_property_count());
+
+    delete[] tests;
+#endif  // GTEST_HAS_TYPED_TEST
+    delete[] test_cases;
+  }
+};
+
+}  // namespace internal
+}  // namespace testing
+
+int main(int argc, char **argv) {
+  InitGoogleTest(&argc, argv);
+
+  AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
+
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_all_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_all_test.cc
index e53b5b97..955aa628 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_all_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_all_test.cc
@@ -1,47 +1,47 @@
-// 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: [email protected] (Zhanyong Wan)

-//

-// Tests for Google C++ Testing Framework (Google Test)

-//

-// Sometimes it's desirable to build most of Google Test's own tests

-// by compiling a single file.  This file serves this purpose.

-#include "test/gtest-filepath_test.cc"

-#include "test/gtest-linked_ptr_test.cc"

-#include "test/gtest-message_test.cc"

-#include "test/gtest-options_test.cc"

-#include "test/gtest-port_test.cc"

-#include "test/gtest_pred_impl_unittest.cc"

-#include "test/gtest_prod_test.cc"

-#include "test/gtest-test-part_test.cc"

-#include "test/gtest-typed-test_test.cc"

-#include "test/gtest-typed-test2_test.cc"

-#include "test/gtest_unittest.cc"

-#include "test/production.cc"

+// 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: [email protected] (Zhanyong Wan)
+//
+// Tests for Google C++ Testing Framework (Google Test)
+//
+// Sometimes it's desirable to build most of Google Test's own tests
+// by compiling a single file.  This file serves this purpose.
+#include "test/gtest-filepath_test.cc"
+#include "test/gtest-linked_ptr_test.cc"
+#include "test/gtest-message_test.cc"
+#include "test/gtest-options_test.cc"
+#include "test/gtest-port_test.cc"
+#include "test/gtest_pred_impl_unittest.cc"
+#include "test/gtest_prod_test.cc"
+#include "test/gtest-test-part_test.cc"
+#include "test/gtest-typed-test_test.cc"
+#include "test/gtest-typed-test2_test.cc"
+#include "test/gtest_unittest.cc"
+#include "test/production.cc"
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_break_on_failure_unittest_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_break_on_failure_unittest_.cc
index 4a3445f4..10a1203b 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_break_on_failure_unittest_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_break_on_failure_unittest_.cc
@@ -1,66 +1,66 @@
-// Copyright 2006, 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: [email protected] (Zhanyong Wan)

-

-// Unit test for Google Test's break-on-failure mode.

-//

-// A user can ask Google Test to seg-fault when an assertion fails, using

-// either the GTEST_BREAK_ON_FAILURE environment variable or the

-// --gtest_break_on_failure flag.  This file is used for testing such

-// functionality.

-//

-// This program will be invoked from a Python unit test.  It is

-// expected to fail.  Don't run it directly.

-

-#include <gtest/gtest.h>

-

-#if GTEST_OS_WINDOWS

-#include <windows.h>

-#endif

-

-namespace {

-

-// A test that's expected to fail.

-TEST(Foo, Bar) {

-  EXPECT_EQ(2, 3);

-}

-

-}  // namespace

-

-int main(int argc, char **argv) {

-#if GTEST_OS_WINDOWS

-  // Suppresses display of the Windows error dialog upon encountering

-  // a general protection fault (segment violation).

-  SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);

-#endif

-  testing::InitGoogleTest(&argc, argv);

-

-  return RUN_ALL_TESTS();

-}

+// Copyright 2006, 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: [email protected] (Zhanyong Wan)
+
+// Unit test for Google Test's break-on-failure mode.
+//
+// A user can ask Google Test to seg-fault when an assertion fails, using
+// either the GTEST_BREAK_ON_FAILURE environment variable or the
+// --gtest_break_on_failure flag.  This file is used for testing such
+// functionality.
+//
+// This program will be invoked from a Python unit test.  It is
+// expected to fail.  Don't run it directly.
+
+#include <gtest/gtest.h>
+
+#if GTEST_OS_WINDOWS
+#include <windows.h>
+#endif
+
+namespace {
+
+// A test that's expected to fail.
+TEST(Foo, Bar) {
+  EXPECT_EQ(2, 3);
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+#if GTEST_OS_WINDOWS
+  // Suppresses display of the Windows error dialog upon encountering
+  // a general protection fault (segment violation).
+  SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
+#endif
+  testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_color_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_color_test_.cc
index 06f5d1ae..305aeb96 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_color_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_color_test_.cc
@@ -1,68 +1,68 @@
-// Copyright 2008, 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: [email protected] (Zhanyong Wan)

-

-// A helper program for testing how Google Test determines whether to use

-// colors in the output.  It prints "YES" and returns 1 if Google Test

-// decides to use colors, and prints "NO" and returns 0 otherwise.

-

-#include <stdio.h>

-

-#include <gtest/gtest.h>

-

-namespace testing {

-namespace internal {

-bool ShouldUseColor(bool stdout_is_tty);

-}  // namespace internal

-}  // namespace testing

-

-using testing::internal::ShouldUseColor;

-

-// The purpose of this is to ensure that the UnitTest singleton is

-// created before main() is entered, and thus that ShouldUseColor()

-// works the same way as in a real Google-Test-based test.  We don't actual

-// run the TEST itself.

-TEST(GTestColorTest, Dummy) {

-}

-

-int main(int argc, char** argv) {

-  testing::InitGoogleTest(&argc, argv);

-

-  if (ShouldUseColor(true)) {

-    // Google Test decides to use colors in the output (assuming it

-    // goes to a TTY).

-    printf("YES\n");

-    return 1;

-  } else {

-    // Google Test decides not to use colors in the output.

-    printf("NO\n");

-    return 0;

-  }

-}

+// Copyright 2008, 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: [email protected] (Zhanyong Wan)
+
+// A helper program for testing how Google Test determines whether to use
+// colors in the output.  It prints "YES" and returns 1 if Google Test
+// decides to use colors, and prints "NO" and returns 0 otherwise.
+
+#include <stdio.h>
+
+#include <gtest/gtest.h>
+
+namespace testing {
+namespace internal {
+bool ShouldUseColor(bool stdout_is_tty);
+}  // namespace internal
+}  // namespace testing
+
+using testing::internal::ShouldUseColor;
+
+// The purpose of this is to ensure that the UnitTest singleton is
+// created before main() is entered, and thus that ShouldUseColor()
+// works the same way as in a real Google-Test-based test.  We don't actual
+// run the TEST itself.
+TEST(GTestColorTest, Dummy) {
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  if (ShouldUseColor(true)) {
+    // Google Test decides to use colors in the output (assuming it
+    // goes to a TTY).
+    printf("YES\n");
+    return 1;
+  } else {
+    // Google Test decides not to use colors in the output.
+    printf("NO\n");
+    return 0;
+  }
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_env_var_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_env_var_test_.cc
index 132969cd..f7c78fcf 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_env_var_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_env_var_test_.cc
@@ -1,126 +1,126 @@
-// Copyright 2008, 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: [email protected] (Zhanyong Wan)

-

-// A helper program for testing that Google Test parses the environment

-// variables correctly.

-

-#include <gtest/gtest.h>

-

-#include <iostream>

-

-#define GTEST_IMPLEMENTATION_ 1

-#include "src/gtest-internal-inl.h"

-#undef GTEST_IMPLEMENTATION_

-

-using ::std::cout;

-

-namespace testing {

-

-// The purpose of this is to make the test more realistic by ensuring

-// that the UnitTest singleton is created before main() is entered.

-// We don't actual run the TEST itself.

-TEST(GTestEnvVarTest, Dummy) {

-}

-

-void PrintFlag(const char* flag) {

-  if (strcmp(flag, "break_on_failure") == 0) {

-    cout << GTEST_FLAG(break_on_failure);

-    return;

-  }

-

-  if (strcmp(flag, "catch_exceptions") == 0) {

-    cout << GTEST_FLAG(catch_exceptions);

-    return;

-  }

-

-  if (strcmp(flag, "color") == 0) {

-    cout << GTEST_FLAG(color);

-    return;

-  }

-

-  if (strcmp(flag, "death_test_style") == 0) {

-    cout << GTEST_FLAG(death_test_style);

-    return;

-  }

-

-  if (strcmp(flag, "death_test_use_fork") == 0) {

-    cout << GTEST_FLAG(death_test_use_fork);

-    return;

-  }

-

-  if (strcmp(flag, "filter") == 0) {

-    cout << GTEST_FLAG(filter);

-    return;

-  }

-

-  if (strcmp(flag, "output") == 0) {

-    cout << GTEST_FLAG(output);

-    return;

-  }

-

-  if (strcmp(flag, "print_time") == 0) {

-    cout << GTEST_FLAG(print_time);

-    return;

-  }

-

-  if (strcmp(flag, "repeat") == 0) {

-    cout << GTEST_FLAG(repeat);

-    return;

-  }

-

-  if (strcmp(flag, "stack_trace_depth") == 0) {

-    cout << GTEST_FLAG(stack_trace_depth);

-    return;

-  }

-

-  if (strcmp(flag, "throw_on_failure") == 0) {

-    cout << GTEST_FLAG(throw_on_failure);

-    return;

-  }

-

-  cout << "Invalid flag name " << flag

-       << ".  Valid names are break_on_failure, color, filter, etc.\n";

-  exit(1);

-}

-

-}  // namespace testing

-

-int main(int argc, char** argv) {

-  testing::InitGoogleTest(&argc, argv);

-

-  if (argc != 2) {

-    cout << "Usage: gtest_env_var_test_ NAME_OF_FLAG\n";

-    return 1;

-  }

-

-  testing::PrintFlag(argv[1]);

-  return 0;

-}

+// Copyright 2008, 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: [email protected] (Zhanyong Wan)
+
+// A helper program for testing that Google Test parses the environment
+// variables correctly.
+
+#include <gtest/gtest.h>
+
+#include <iostream>
+
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+using ::std::cout;
+
+namespace testing {
+
+// The purpose of this is to make the test more realistic by ensuring
+// that the UnitTest singleton is created before main() is entered.
+// We don't actual run the TEST itself.
+TEST(GTestEnvVarTest, Dummy) {
+}
+
+void PrintFlag(const char* flag) {
+  if (strcmp(flag, "break_on_failure") == 0) {
+    cout << GTEST_FLAG(break_on_failure);
+    return;
+  }
+
+  if (strcmp(flag, "catch_exceptions") == 0) {
+    cout << GTEST_FLAG(catch_exceptions);
+    return;
+  }
+
+  if (strcmp(flag, "color") == 0) {
+    cout << GTEST_FLAG(color);
+    return;
+  }
+
+  if (strcmp(flag, "death_test_style") == 0) {
+    cout << GTEST_FLAG(death_test_style);
+    return;
+  }
+
+  if (strcmp(flag, "death_test_use_fork") == 0) {
+    cout << GTEST_FLAG(death_test_use_fork);
+    return;
+  }
+
+  if (strcmp(flag, "filter") == 0) {
+    cout << GTEST_FLAG(filter);
+    return;
+  }
+
+  if (strcmp(flag, "output") == 0) {
+    cout << GTEST_FLAG(output);
+    return;
+  }
+
+  if (strcmp(flag, "print_time") == 0) {
+    cout << GTEST_FLAG(print_time);
+    return;
+  }
+
+  if (strcmp(flag, "repeat") == 0) {
+    cout << GTEST_FLAG(repeat);
+    return;
+  }
+
+  if (strcmp(flag, "stack_trace_depth") == 0) {
+    cout << GTEST_FLAG(stack_trace_depth);
+    return;
+  }
+
+  if (strcmp(flag, "throw_on_failure") == 0) {
+    cout << GTEST_FLAG(throw_on_failure);
+    return;
+  }
+
+  cout << "Invalid flag name " << flag
+       << ".  Valid names are break_on_failure, color, filter, etc.\n";
+  exit(1);
+}
+
+}  // namespace testing
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  if (argc != 2) {
+    cout << "Usage: gtest_env_var_test_ NAME_OF_FLAG\n";
+    return 1;
+  }
+
+  testing::PrintFlag(argv[1]);
+  return 0;
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_environment_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_environment_test.cc
index 98cb75de..c9392614 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_environment_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_environment_test.cc
@@ -1,186 +1,186 @@
-// Copyright 2007, 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: [email protected] (Zhanyong Wan)

-//

-// Tests using global test environments.

-

-#include <stdlib.h>

-#include <stdio.h>

-#include <gtest/gtest.h>

-

-namespace testing {

-GTEST_DECLARE_string_(filter);

-}

-

-namespace {

-

-enum FailureType {

-  NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE

-};

-

-// For testing using global test environments.

-class MyEnvironment : public testing::Environment {

- public:

-  MyEnvironment() { Reset(); }

-

-  // Depending on the value of failure_in_set_up_, SetUp() will

-  // generate a non-fatal failure, generate a fatal failure, or

-  // succeed.

-  virtual void SetUp() {

-    set_up_was_run_ = true;

-

-    switch (failure_in_set_up_) {

-      case NON_FATAL_FAILURE:

-        ADD_FAILURE() << "Expected non-fatal failure in global set-up.";

-        break;

-      case FATAL_FAILURE:

-        FAIL() << "Expected fatal failure in global set-up.";

-        break;

-      default:

-        break;

-    }

-  }

-

-  // Generates a non-fatal failure.

-  virtual void TearDown() {

-    tear_down_was_run_ = true;

-    ADD_FAILURE() << "Expected non-fatal failure in global tear-down.";

-  }

-

-  // Resets the state of the environment s.t. it can be reused.

-  void Reset() {

-    failure_in_set_up_ = NO_FAILURE;

-    set_up_was_run_ = false;

-    tear_down_was_run_ = false;

-  }

-

-  // We call this function to set the type of failure SetUp() should

-  // generate.

-  void set_failure_in_set_up(FailureType type) {

-    failure_in_set_up_ = type;

-  }

-

-  // Was SetUp() run?

-  bool set_up_was_run() const { return set_up_was_run_; }

-

-  // Was TearDown() run?

-  bool tear_down_was_run() const { return tear_down_was_run_; }

- private:

-  FailureType failure_in_set_up_;

-  bool set_up_was_run_;

-  bool tear_down_was_run_;

-};

-

-// Was the TEST run?

-bool test_was_run;

-

-// The sole purpose of this TEST is to enable us to check whether it

-// was run.

-TEST(FooTest, Bar) {

-  test_was_run = true;

-}

-

-// Prints the message and aborts the program if condition is false.

-void Check(bool condition, const char* msg) {

-  if (!condition) {

-    printf("FAILED: %s\n", msg);

-    abort();

-  }

-}

-

-// Runs the tests.  Return true iff successful.

-//

-// The 'failure' parameter specifies the type of failure that should

-// be generated by the global set-up.

-int RunAllTests(MyEnvironment* env, FailureType failure) {

-  env->Reset();

-  env->set_failure_in_set_up(failure);

-  test_was_run = false;

-  return RUN_ALL_TESTS();

-}

-

-}  // namespace

-

-int main(int argc, char **argv) {

-  testing::InitGoogleTest(&argc, argv);

-

-  // Registers a global test environment, and verifies that the

-  // registration function returns its argument.

-  MyEnvironment* const env = new MyEnvironment;

-  Check(testing::AddGlobalTestEnvironment(env) == env,

-        "AddGlobalTestEnvironment() should return its argument.");

-

-  // Verifies that RUN_ALL_TESTS() runs the tests when the global

-  // set-up is successful.

-  Check(RunAllTests(env, NO_FAILURE) != 0,

-        "RUN_ALL_TESTS() should return non-zero, as the global tear-down "

-        "should generate a failure.");

-  Check(test_was_run,

-        "The tests should run, as the global set-up should generate no "

-        "failure");

-  Check(env->tear_down_was_run(),

-        "The global tear-down should run, as the global set-up was run.");

-

-  // Verifies that RUN_ALL_TESTS() runs the tests when the global

-  // set-up generates no fatal failure.

-  Check(RunAllTests(env, NON_FATAL_FAILURE) != 0,

-        "RUN_ALL_TESTS() should return non-zero, as both the global set-up "

-        "and the global tear-down should generate a non-fatal failure.");

-  Check(test_was_run,

-        "The tests should run, as the global set-up should generate no "

-        "fatal failure.");

-  Check(env->tear_down_was_run(),

-        "The global tear-down should run, as the global set-up was run.");

-

-  // Verifies that RUN_ALL_TESTS() runs no test when the global set-up

-  // generates a fatal failure.

-  Check(RunAllTests(env, FATAL_FAILURE) != 0,

-        "RUN_ALL_TESTS() should return non-zero, as the global set-up "

-        "should generate a fatal failure.");

-  Check(!test_was_run,

-        "The tests should not run, as the global set-up should generate "

-        "a fatal failure.");

-  Check(env->tear_down_was_run(),

-        "The global tear-down should run, as the global set-up was run.");

-

-  // Verifies that RUN_ALL_TESTS() doesn't do global set-up or

-  // tear-down when there is no test to run.

-  testing::GTEST_FLAG(filter) = "-*";

-  Check(RunAllTests(env, NO_FAILURE) == 0,

-        "RUN_ALL_TESTS() should return zero, as there is no test to run.");

-  Check(!env->set_up_was_run(),

-        "The global set-up should not run, as there is no test to run.");

-  Check(!env->tear_down_was_run(),

-        "The global tear-down should not run, "

-        "as the global set-up was not run.");

-

-  printf("PASS\n");

-  return 0;

-}

+// Copyright 2007, 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: [email protected] (Zhanyong Wan)
+//
+// Tests using global test environments.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <gtest/gtest.h>
+
+namespace testing {
+GTEST_DECLARE_string_(filter);
+}
+
+namespace {
+
+enum FailureType {
+  NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE
+};
+
+// For testing using global test environments.
+class MyEnvironment : public testing::Environment {
+ public:
+  MyEnvironment() { Reset(); }
+
+  // Depending on the value of failure_in_set_up_, SetUp() will
+  // generate a non-fatal failure, generate a fatal failure, or
+  // succeed.
+  virtual void SetUp() {
+    set_up_was_run_ = true;
+
+    switch (failure_in_set_up_) {
+      case NON_FATAL_FAILURE:
+        ADD_FAILURE() << "Expected non-fatal failure in global set-up.";
+        break;
+      case FATAL_FAILURE:
+        FAIL() << "Expected fatal failure in global set-up.";
+        break;
+      default:
+        break;
+    }
+  }
+
+  // Generates a non-fatal failure.
+  virtual void TearDown() {
+    tear_down_was_run_ = true;
+    ADD_FAILURE() << "Expected non-fatal failure in global tear-down.";
+  }
+
+  // Resets the state of the environment s.t. it can be reused.
+  void Reset() {
+    failure_in_set_up_ = NO_FAILURE;
+    set_up_was_run_ = false;
+    tear_down_was_run_ = false;
+  }
+
+  // We call this function to set the type of failure SetUp() should
+  // generate.
+  void set_failure_in_set_up(FailureType type) {
+    failure_in_set_up_ = type;
+  }
+
+  // Was SetUp() run?
+  bool set_up_was_run() const { return set_up_was_run_; }
+
+  // Was TearDown() run?
+  bool tear_down_was_run() const { return tear_down_was_run_; }
+ private:
+  FailureType failure_in_set_up_;
+  bool set_up_was_run_;
+  bool tear_down_was_run_;
+};
+
+// Was the TEST run?
+bool test_was_run;
+
+// The sole purpose of this TEST is to enable us to check whether it
+// was run.
+TEST(FooTest, Bar) {
+  test_was_run = true;
+}
+
+// Prints the message and aborts the program if condition is false.
+void Check(bool condition, const char* msg) {
+  if (!condition) {
+    printf("FAILED: %s\n", msg);
+    abort();
+  }
+}
+
+// Runs the tests.  Return true iff successful.
+//
+// The 'failure' parameter specifies the type of failure that should
+// be generated by the global set-up.
+int RunAllTests(MyEnvironment* env, FailureType failure) {
+  env->Reset();
+  env->set_failure_in_set_up(failure);
+  test_was_run = false;
+  return RUN_ALL_TESTS();
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  // Registers a global test environment, and verifies that the
+  // registration function returns its argument.
+  MyEnvironment* const env = new MyEnvironment;
+  Check(testing::AddGlobalTestEnvironment(env) == env,
+        "AddGlobalTestEnvironment() should return its argument.");
+
+  // Verifies that RUN_ALL_TESTS() runs the tests when the global
+  // set-up is successful.
+  Check(RunAllTests(env, NO_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as the global tear-down "
+        "should generate a failure.");
+  Check(test_was_run,
+        "The tests should run, as the global set-up should generate no "
+        "failure");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() runs the tests when the global
+  // set-up generates no fatal failure.
+  Check(RunAllTests(env, NON_FATAL_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as both the global set-up "
+        "and the global tear-down should generate a non-fatal failure.");
+  Check(test_was_run,
+        "The tests should run, as the global set-up should generate no "
+        "fatal failure.");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() runs no test when the global set-up
+  // generates a fatal failure.
+  Check(RunAllTests(env, FATAL_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as the global set-up "
+        "should generate a fatal failure.");
+  Check(!test_was_run,
+        "The tests should not run, as the global set-up should generate "
+        "a fatal failure.");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() doesn't do global set-up or
+  // tear-down when there is no test to run.
+  testing::GTEST_FLAG(filter) = "-*";
+  Check(RunAllTests(env, NO_FAILURE) == 0,
+        "RUN_ALL_TESTS() should return zero, as there is no test to run.");
+  Check(!env->set_up_was_run(),
+        "The global set-up should not run, as there is no test to run.");
+  Check(!env->tear_down_was_run(),
+        "The global tear-down should not run, "
+        "as the global set-up was not run.");
+
+  printf("PASS\n");
+  return 0;
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_filter_unittest_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_filter_unittest_.cc
index 896aacc4..325504fe 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_filter_unittest_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_filter_unittest_.cc
@@ -1,140 +1,140 @@
-// Copyright 2005, 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: [email protected] (Zhanyong Wan)

-

-// Unit test for Google Test test filters.

-//

-// A user can specify which test(s) in a Google Test program to run via

-// either the GTEST_FILTER environment variable or the --gtest_filter

-// flag.  This is used for testing such functionality.

-//

-// The program will be invoked from a Python unit test.  Don't run it

-// directly.

-

-#include <gtest/gtest.h>

-

-namespace {

-

-// Test case FooTest.

-

-class FooTest : public testing::Test {

-};

-

-TEST_F(FooTest, Abc) {

-}

-

-TEST_F(FooTest, Xyz) {

-  FAIL() << "Expected failure.";

-}

-

-// Test case BarTest.

-

-TEST(BarTest, TestOne) {

-}

-

-TEST(BarTest, TestTwo) {

-}

-

-TEST(BarTest, TestThree) {

-}

-

-TEST(BarTest, DISABLED_TestFour) {

-  FAIL() << "Expected failure.";

-}

-

-TEST(BarTest, DISABLED_TestFive) {

-  FAIL() << "Expected failure.";

-}

-

-// Test case BazTest.

-

-TEST(BazTest, TestOne) {

-  FAIL() << "Expected failure.";

-}

-

-TEST(BazTest, TestA) {

-}

-

-TEST(BazTest, TestB) {

-}

-

-TEST(BazTest, DISABLED_TestC) {

-  FAIL() << "Expected failure.";

-}

-

-// Test case HasDeathTest

-

-TEST(HasDeathTest, Test1) {

-  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");

-}

-

-// We need at least two death tests to make sure that the all death tests

-// aren't on the first shard.

-TEST(HasDeathTest, Test2) {

-  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");

-}

-

-// Test case FoobarTest

-

-TEST(DISABLED_FoobarTest, Test1) {

-  FAIL() << "Expected failure.";

-}

-

-TEST(DISABLED_FoobarTest, DISABLED_Test2) {

-  FAIL() << "Expected failure.";

-}

-

-// Test case FoobarbazTest

-

-TEST(DISABLED_FoobarbazTest, TestA) {

-  FAIL() << "Expected failure.";

-}

-

-#if GTEST_HAS_PARAM_TEST

-class ParamTest : public testing::TestWithParam<int> {

-};

-

-TEST_P(ParamTest, TestX) {

-}

-

-TEST_P(ParamTest, TestY) {

-}

-

-INSTANTIATE_TEST_CASE_P(SeqP, ParamTest, testing::Values(1, 2));

-INSTANTIATE_TEST_CASE_P(SeqQ, ParamTest, testing::Values(5, 6));

-#endif  // GTEST_HAS_PARAM_TEST

-

-}  // namespace

-

-int main(int argc, char **argv) {

-  ::testing::InitGoogleTest(&argc, argv);

-

-  return RUN_ALL_TESTS();

-}

+// Copyright 2005, 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: [email protected] (Zhanyong Wan)
+
+// Unit test for Google Test test filters.
+//
+// A user can specify which test(s) in a Google Test program to run via
+// either the GTEST_FILTER environment variable or the --gtest_filter
+// flag.  This is used for testing such functionality.
+//
+// The program will be invoked from a Python unit test.  Don't run it
+// directly.
+
+#include <gtest/gtest.h>
+
+namespace {
+
+// Test case FooTest.
+
+class FooTest : public testing::Test {
+};
+
+TEST_F(FooTest, Abc) {
+}
+
+TEST_F(FooTest, Xyz) {
+  FAIL() << "Expected failure.";
+}
+
+// Test case BarTest.
+
+TEST(BarTest, TestOne) {
+}
+
+TEST(BarTest, TestTwo) {
+}
+
+TEST(BarTest, TestThree) {
+}
+
+TEST(BarTest, DISABLED_TestFour) {
+  FAIL() << "Expected failure.";
+}
+
+TEST(BarTest, DISABLED_TestFive) {
+  FAIL() << "Expected failure.";
+}
+
+// Test case BazTest.
+
+TEST(BazTest, TestOne) {
+  FAIL() << "Expected failure.";
+}
+
+TEST(BazTest, TestA) {
+}
+
+TEST(BazTest, TestB) {
+}
+
+TEST(BazTest, DISABLED_TestC) {
+  FAIL() << "Expected failure.";
+}
+
+// Test case HasDeathTest
+
+TEST(HasDeathTest, Test1) {
+  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
+}
+
+// We need at least two death tests to make sure that the all death tests
+// aren't on the first shard.
+TEST(HasDeathTest, Test2) {
+  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
+}
+
+// Test case FoobarTest
+
+TEST(DISABLED_FoobarTest, Test1) {
+  FAIL() << "Expected failure.";
+}
+
+TEST(DISABLED_FoobarTest, DISABLED_Test2) {
+  FAIL() << "Expected failure.";
+}
+
+// Test case FoobarbazTest
+
+TEST(DISABLED_FoobarbazTest, TestA) {
+  FAIL() << "Expected failure.";
+}
+
+#if GTEST_HAS_PARAM_TEST
+class ParamTest : public testing::TestWithParam<int> {
+};
+
+TEST_P(ParamTest, TestX) {
+}
+
+TEST_P(ParamTest, TestY) {
+}
+
+INSTANTIATE_TEST_CASE_P(SeqP, ParamTest, testing::Values(1, 2));
+INSTANTIATE_TEST_CASE_P(SeqQ, ParamTest, testing::Values(5, 6));
+#endif  // GTEST_HAS_PARAM_TEST
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_help_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_help_test_.cc
index 3af8c8c4..0282bc88 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_help_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_help_test_.cc
@@ -1,42 +1,42 @@
-// 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: [email protected] (Zhanyong Wan)

-

-// This program is meant to be run by gtest_help_test.py.  Do not run

-// it directly.

-

-#include <gtest/gtest.h>

-

-// When a help flag is specified, this program should skip the tests

-// and exit with 0; otherwise the following test will be executed,

-// causing this program to exit with a non-zero code.

-TEST(HelpFlagTest, ShouldNotBeRun) {

-  ASSERT_TRUE(false) << "Tests shouldn't be run when --help is specified.";

-}

+// 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: [email protected] (Zhanyong Wan)
+
+// This program is meant to be run by gtest_help_test.py.  Do not run
+// it directly.
+
+#include <gtest/gtest.h>
+
+// When a help flag is specified, this program should skip the tests
+// and exit with 0; otherwise the following test will be executed,
+// causing this program to exit with a non-zero code.
+TEST(HelpFlagTest, ShouldNotBeRun) {
+  ASSERT_TRUE(false) << "Tests shouldn't be run when --help is specified.";
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_list_tests_unittest_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_list_tests_unittest_.cc
index 223c199e..a0ed0825 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_list_tests_unittest_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_list_tests_unittest_.cc
@@ -1,85 +1,85 @@
-// Copyright 2006, 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: [email protected] (Patrick Hanna)

-

-// Unit test for Google Test's --gtest_list_tests flag.

-//

-// A user can ask Google Test to list all tests that will run

-// so that when using a filter, a user will know what

-// tests to look for. The tests will not be run after listing.

-//

-// This program will be invoked from a Python unit test.

-// Don't run it directly.

-

-#include <gtest/gtest.h>

-

-namespace {

-

-// Several different test cases and tests that will be listed.

-TEST(Foo, Bar1) {

-}

-

-TEST(Foo, Bar2) {

-}

-

-TEST(Foo, DISABLED_Bar3) {

-}

-

-TEST(Abc, Xyz) {

-}

-

-TEST(Abc, Def) {

-}

-

-TEST(FooBar, Baz) {

-}

-

-class FooTest : public testing::Test {

-};

-

-TEST_F(FooTest, Test1) {

-}

-

-TEST_F(FooTest, DISABLED_Test2) {

-}

-

-TEST_F(FooTest, Test3) {

-}

-

-TEST(FooDeathTest, Test1) {

-}

-

-}  // namespace

-

-int main(int argc, char **argv) {

-  ::testing::InitGoogleTest(&argc, argv);

-

-  return RUN_ALL_TESTS();

-}

+// Copyright 2006, 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: [email protected] (Patrick Hanna)
+
+// Unit test for Google Test's --gtest_list_tests flag.
+//
+// A user can ask Google Test to list all tests that will run
+// so that when using a filter, a user will know what
+// tests to look for. The tests will not be run after listing.
+//
+// This program will be invoked from a Python unit test.
+// Don't run it directly.
+
+#include <gtest/gtest.h>
+
+namespace {
+
+// Several different test cases and tests that will be listed.
+TEST(Foo, Bar1) {
+}
+
+TEST(Foo, Bar2) {
+}
+
+TEST(Foo, DISABLED_Bar3) {
+}
+
+TEST(Abc, Xyz) {
+}
+
+TEST(Abc, Def) {
+}
+
+TEST(FooBar, Baz) {
+}
+
+class FooTest : public testing::Test {
+};
+
+TEST_F(FooTest, Test1) {
+}
+
+TEST_F(FooTest, DISABLED_Test2) {
+}
+
+TEST_F(FooTest, Test3) {
+}
+
+TEST(FooDeathTest, Test1) {
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_main_unittest.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_main_unittest.cc
index 74f9dd7d..7a3f0adf 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_main_unittest.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_main_unittest.cc
@@ -1,45 +1,45 @@
-// Copyright 2006, 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: [email protected] (Zhanyong Wan)

-

-#include <gtest/gtest.h>

-

-// Tests that we don't have to define main() when we link to

-// gtest_main instead of gtest.

-

-namespace {

-

-TEST(GTestMainTest, ShouldSucceed) {

-}

-

-}  // namespace

-

-// We are using the main() function defined in src/gtest_main.cc, so

-// we don't define it here.

+// Copyright 2006, 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: [email protected] (Zhanyong Wan)
+
+#include <gtest/gtest.h>
+
+// Tests that we don't have to define main() when we link to
+// gtest_main instead of gtest.
+
+namespace {
+
+TEST(GTestMainTest, ShouldSucceed) {
+}
+
+}  // namespace
+
+// We are using the main() function defined in src/gtest_main.cc, so
+// we don't define it here.
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_nc.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_nc.cc
index 8bf72dd7..73b5db6d 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_nc.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_nc.cc
@@ -1,234 +1,234 @@
-// Copyright 2007, 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: [email protected] (Zhanyong Wan)

-

-// This file is the input to a negative-compilation test for Google

-// Test.  Code here is NOT supposed to compile.  Its purpose is to

-// verify that certain incorrect usages of the Google Test API are

-// indeed rejected by the compiler.

-//

-// We still need to write the negative-compilation test itself, which

-// will be tightly coupled with the build environment.

-//

-// TODO([email protected]): finish the negative-compilation test.

-

-#ifdef TEST_CANNOT_IGNORE_RUN_ALL_TESTS_RESULT

-// Tests that the result of RUN_ALL_TESTS() cannot be ignored.

-

-#include <gtest/gtest.h>

-

-int main(int argc, char** argv) {

-  testing::InitGoogleTest(&argc, argv);

-  RUN_ALL_TESTS();  // This line shouldn't compile.

-}

-

-#elif defined(TEST_USER_CANNOT_INCLUDE_GTEST_INTERNAL_INL_H)

-// Tests that a user cannot include gtest-internal-inl.h in his code.

-

-#include "src/gtest-internal-inl.h"

-

-#elif defined(TEST_CATCHES_DECLARING_SETUP_IN_TEST_FIXTURE_WITH_TYPO)

-// Tests that the compiler catches the typo when a user declares a

-// Setup() method in a test fixture.

-

-#include <gtest/gtest.h>

-

-class MyTest : public testing::Test {

- protected:

-  void Setup() {}

-};

-

-#elif defined(TEST_CATCHES_CALLING_SETUP_IN_TEST_WITH_TYPO)

-// Tests that the compiler catches the typo when a user calls Setup()

-// from a test fixture.

-

-#include <gtest/gtest.h>

-

-class MyTest : public testing::Test {

- protected:

-  virtual void SetUp() {

-    testing::Test::Setup();  // Tries to call SetUp() in the parent class.

-  }

-};

-

-#elif defined(TEST_CATCHES_DECLARING_SETUP_IN_ENVIRONMENT_WITH_TYPO)

-// Tests that the compiler catches the typo when a user declares a

-// Setup() method in a subclass of Environment.

-

-#include <gtest/gtest.h>

-

-class MyEnvironment : public testing::Environment {

- public:

-  void Setup() {}

-};

-

-#elif defined(TEST_CATCHES_CALLING_SETUP_IN_ENVIRONMENT_WITH_TYPO)

-// Tests that the compiler catches the typo when a user calls Setup()

-// in an Environment.

-

-#include <gtest/gtest.h>

-

-class MyEnvironment : public testing::Environment {

- protected:

-  virtual void SetUp() {

-    // Tries to call SetUp() in the parent class.

-    testing::Environment::Setup();

-  }

-};

-

-#elif defined(TEST_CATCHES_WRONG_CASE_IN_TYPED_TEST_P)

-// Tests that the compiler catches using the wrong test case name in

-// TYPED_TEST_P.

-

-#include <gtest/gtest.h>

-

-template <typename T>

-class FooTest : public testing::Test {

-};

-

-template <typename T>

-class BarTest : public testing::Test {

-};

-

-TYPED_TEST_CASE_P(FooTest);

-TYPED_TEST_P(BarTest, A) {}  // Wrong test case name.

-REGISTER_TYPED_TEST_CASE_P(FooTest, A);

-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, testing::Types<int>);

-

-#elif defined(TEST_CATCHES_WRONG_CASE_IN_REGISTER_TYPED_TEST_CASE_P)

-// Tests that the compiler catches using the wrong test case name in

-// REGISTER_TYPED_TEST_CASE_P.

-

-#include <gtest/gtest.h>

-

-template <typename T>

-class FooTest : public testing::Test {

-};

-

-template <typename T>

-class BarTest : public testing::Test {

-};

-

-TYPED_TEST_CASE_P(FooTest);

-TYPED_TEST_P(FooTest, A) {}

-REGISTER_TYPED_TEST_CASE_P(BarTest, A);  // Wrong test case name.

-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, testing::Types<int>);

-

-#elif defined(TEST_CATCHES_WRONG_CASE_IN_INSTANTIATE_TYPED_TEST_CASE_P)

-// Tests that the compiler catches using the wrong test case name in

-// INSTANTIATE_TYPED_TEST_CASE_P.

-

-#include <gtest/gtest.h>

-

-template <typename T>

-class FooTest : public testing::Test {

-};

-

-template <typename T>

-class BarTest : public testing::Test {

-};

-

-TYPED_TEST_CASE_P(FooTest);

-TYPED_TEST_P(FooTest, A) {}

-REGISTER_TYPED_TEST_CASE_P(FooTest, A);

-

-// Wrong test case name.

-INSTANTIATE_TYPED_TEST_CASE_P(My, BarTest, testing::Types<int>);

-

-#elif defined(TEST_CATCHES_INSTANTIATE_TYPED_TESET_CASE_P_WITH_SAME_NAME_PREFIX)

-// Tests that the compiler catches instantiating TYPED_TEST_CASE_P

-// twice with the same name prefix.

-

-#include <gtest/gtest.h>

-

-template <typename T>

-class FooTest : public testing::Test {

-};

-

-TYPED_TEST_CASE_P(FooTest);

-TYPED_TEST_P(FooTest, A) {}

-REGISTER_TYPED_TEST_CASE_P(FooTest, A);

-

-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, testing::Types<int>);

-

-// Wrong name prefix: "My" has been used.

-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, testing::Types<double>);

-

-#elif defined(TEST_STATIC_ASSERT_TYPE_EQ_IS_NOT_A_TYPE)

-

-#include <gtest/gtest.h>

-

-// Tests that StaticAssertTypeEq<T1, T2> cannot be used as a type.

-testing::StaticAssertTypeEq<int, int> dummy;

-

-#elif defined(TEST_STATIC_ASSERT_TYPE_EQ_WORKS_IN_NAMESPACE)

-

-#include <gtest/gtest.h>

-

-// Tests that StaticAssertTypeEq<T1, T2> works in a namespace scope.

-static bool dummy = testing::StaticAssertTypeEq<int, const int>();

-

-#elif defined(TEST_STATIC_ASSERT_TYPE_EQ_WORKS_IN_CLASS)

-

-#include <gtest/gtest.h>

-

-template <typename T>

-class Helper {

- public:

-  // Tests that StaticAssertTypeEq<T1, T2> works in a class.

-  Helper() { testing::StaticAssertTypeEq<int, T>(); }

-

-  void DoSomething() {}

-};

-

-void Test() {

-  Helper<bool> h;

-  h.DoSomething();  // To avoid the "unused variable" warning.

-}

-

-#elif defined(TEST_STATIC_ASSERT_TYPE_EQ_WORKS_IN_FUNCTION)

-

-#include <gtest/gtest.h>

-

-void Test() {

-  // Tests that StaticAssertTypeEq<T1, T2> works inside a function.

-  testing::StaticAssertTypeEq<const int, int>();

-}

-

-#else

-// A sanity test.  This should compile.

-

-#include <gtest/gtest.h>

-

-int main() {

-  return RUN_ALL_TESTS();

-}

-

-#endif

+// Copyright 2007, 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: [email protected] (Zhanyong Wan)
+
+// This file is the input to a negative-compilation test for Google
+// Test.  Code here is NOT supposed to compile.  Its purpose is to
+// verify that certain incorrect usages of the Google Test API are
+// indeed rejected by the compiler.
+//
+// We still need to write the negative-compilation test itself, which
+// will be tightly coupled with the build environment.
+//
+// TODO([email protected]): finish the negative-compilation test.
+
+#ifdef TEST_CANNOT_IGNORE_RUN_ALL_TESTS_RESULT
+// Tests that the result of RUN_ALL_TESTS() cannot be ignored.
+
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  RUN_ALL_TESTS();  // This line shouldn't compile.
+}
+
+#elif defined(TEST_USER_CANNOT_INCLUDE_GTEST_INTERNAL_INL_H)
+// Tests that a user cannot include gtest-internal-inl.h in his code.
+
+#include "src/gtest-internal-inl.h"
+
+#elif defined(TEST_CATCHES_DECLARING_SETUP_IN_TEST_FIXTURE_WITH_TYPO)
+// Tests that the compiler catches the typo when a user declares a
+// Setup() method in a test fixture.
+
+#include <gtest/gtest.h>
+
+class MyTest : public testing::Test {
+ protected:
+  void Setup() {}
+};
+
+#elif defined(TEST_CATCHES_CALLING_SETUP_IN_TEST_WITH_TYPO)
+// Tests that the compiler catches the typo when a user calls Setup()
+// from a test fixture.
+
+#include <gtest/gtest.h>
+
+class MyTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    testing::Test::Setup();  // Tries to call SetUp() in the parent class.
+  }
+};
+
+#elif defined(TEST_CATCHES_DECLARING_SETUP_IN_ENVIRONMENT_WITH_TYPO)
+// Tests that the compiler catches the typo when a user declares a
+// Setup() method in a subclass of Environment.
+
+#include <gtest/gtest.h>
+
+class MyEnvironment : public testing::Environment {
+ public:
+  void Setup() {}
+};
+
+#elif defined(TEST_CATCHES_CALLING_SETUP_IN_ENVIRONMENT_WITH_TYPO)
+// Tests that the compiler catches the typo when a user calls Setup()
+// in an Environment.
+
+#include <gtest/gtest.h>
+
+class MyEnvironment : public testing::Environment {
+ protected:
+  virtual void SetUp() {
+    // Tries to call SetUp() in the parent class.
+    testing::Environment::Setup();
+  }
+};
+
+#elif defined(TEST_CATCHES_WRONG_CASE_IN_TYPED_TEST_P)
+// Tests that the compiler catches using the wrong test case name in
+// TYPED_TEST_P.
+
+#include <gtest/gtest.h>
+
+template <typename T>
+class FooTest : public testing::Test {
+};
+
+template <typename T>
+class BarTest : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(FooTest);
+TYPED_TEST_P(BarTest, A) {}  // Wrong test case name.
+REGISTER_TYPED_TEST_CASE_P(FooTest, A);
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, testing::Types<int>);
+
+#elif defined(TEST_CATCHES_WRONG_CASE_IN_REGISTER_TYPED_TEST_CASE_P)
+// Tests that the compiler catches using the wrong test case name in
+// REGISTER_TYPED_TEST_CASE_P.
+
+#include <gtest/gtest.h>
+
+template <typename T>
+class FooTest : public testing::Test {
+};
+
+template <typename T>
+class BarTest : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(FooTest);
+TYPED_TEST_P(FooTest, A) {}
+REGISTER_TYPED_TEST_CASE_P(BarTest, A);  // Wrong test case name.
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, testing::Types<int>);
+
+#elif defined(TEST_CATCHES_WRONG_CASE_IN_INSTANTIATE_TYPED_TEST_CASE_P)
+// Tests that the compiler catches using the wrong test case name in
+// INSTANTIATE_TYPED_TEST_CASE_P.
+
+#include <gtest/gtest.h>
+
+template <typename T>
+class FooTest : public testing::Test {
+};
+
+template <typename T>
+class BarTest : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(FooTest);
+TYPED_TEST_P(FooTest, A) {}
+REGISTER_TYPED_TEST_CASE_P(FooTest, A);
+
+// Wrong test case name.
+INSTANTIATE_TYPED_TEST_CASE_P(My, BarTest, testing::Types<int>);
+
+#elif defined(TEST_CATCHES_INSTANTIATE_TYPED_TESET_CASE_P_WITH_SAME_NAME_PREFIX)
+// Tests that the compiler catches instantiating TYPED_TEST_CASE_P
+// twice with the same name prefix.
+
+#include <gtest/gtest.h>
+
+template <typename T>
+class FooTest : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(FooTest);
+TYPED_TEST_P(FooTest, A) {}
+REGISTER_TYPED_TEST_CASE_P(FooTest, A);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, testing::Types<int>);
+
+// Wrong name prefix: "My" has been used.
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, testing::Types<double>);
+
+#elif defined(TEST_STATIC_ASSERT_TYPE_EQ_IS_NOT_A_TYPE)
+
+#include <gtest/gtest.h>
+
+// Tests that StaticAssertTypeEq<T1, T2> cannot be used as a type.
+testing::StaticAssertTypeEq<int, int> dummy;
+
+#elif defined(TEST_STATIC_ASSERT_TYPE_EQ_WORKS_IN_NAMESPACE)
+
+#include <gtest/gtest.h>
+
+// Tests that StaticAssertTypeEq<T1, T2> works in a namespace scope.
+static bool dummy = testing::StaticAssertTypeEq<int, const int>();
+
+#elif defined(TEST_STATIC_ASSERT_TYPE_EQ_WORKS_IN_CLASS)
+
+#include <gtest/gtest.h>
+
+template <typename T>
+class Helper {
+ public:
+  // Tests that StaticAssertTypeEq<T1, T2> works in a class.
+  Helper() { testing::StaticAssertTypeEq<int, T>(); }
+
+  void DoSomething() {}
+};
+
+void Test() {
+  Helper<bool> h;
+  h.DoSomething();  // To avoid the "unused variable" warning.
+}
+
+#elif defined(TEST_STATIC_ASSERT_TYPE_EQ_WORKS_IN_FUNCTION)
+
+#include <gtest/gtest.h>
+
+void Test() {
+  // Tests that StaticAssertTypeEq<T1, T2> works inside a function.
+  testing::StaticAssertTypeEq<const int, int>();
+}
+
+#else
+// A sanity test.  This should compile.
+
+#include <gtest/gtest.h>
+
+int main() {
+  return RUN_ALL_TESTS();
+}
+
+#endif
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_no_test_unittest.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_no_test_unittest.cc
index 0313c548..afe2dc0c 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_no_test_unittest.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_no_test_unittest.cc
@@ -1,54 +1,54 @@
-// Copyright 2006, 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.

-

-// Tests that a Google Test program that has no test defined can run

-// successfully.

-//

-// Author: [email protected] (Zhanyong Wan)

-

-#include <gtest/gtest.h>

-

-

-int main(int argc, char **argv) {

-  testing::InitGoogleTest(&argc, argv);

-

-  // An ad-hoc assertion outside of all tests.

-  //

-  // This serves two purposes:

-  //

-  // 1. It verifies that an ad-hoc assertion can be executed even if

-  //    no test is defined.

-  // 2. We had a bug where the XML output won't be generated if an

-  //    assertion is executed before RUN_ALL_TESTS() is called, even

-  //    though --gtest_output=xml is specified.  This makes sure the

-  //    bug is fixed and doesn't regress.

-  EXPECT_EQ(1, 1);

-

-  return RUN_ALL_TESTS();

-}

+// Copyright 2006, 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.
+
+// Tests that a Google Test program that has no test defined can run
+// successfully.
+//
+// Author: [email protected] (Zhanyong Wan)
+
+#include <gtest/gtest.h>
+
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  // An ad-hoc assertion outside of all tests.
+  //
+  // This serves two purposes:
+  //
+  // 1. It verifies that an ad-hoc assertion can be executed even if
+  //    no test is defined.
+  // 2. We had a bug where the XML output won't be generated if an
+  //    assertion is executed before RUN_ALL_TESTS() is called, even
+  //    though --gtest_output=xml is specified.  This makes sure the
+  //    bug is fixed and doesn't regress.
+  EXPECT_EQ(1, 1);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_output_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_output_test_.cc
index 9918bc1f..6d756027 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_output_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_output_test_.cc
@@ -1,1009 +1,1009 @@
-// Copyright 2005, 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.

-//

-// A unit test for Google Test itself.  This verifies that the basic

-// constructs of Google Test work.

-//

-// Author: [email protected] (Zhanyong Wan)

-

-#include <gtest/gtest-spi.h>

-#include <gtest/gtest.h>

-

-// 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_

-

-#include <stdlib.h>

-

-#if GTEST_HAS_PTHREAD

-#include <pthread.h>

-#endif  // GTEST_HAS_PTHREAD

-

-using testing::ScopedFakeTestPartResultReporter;

-using testing::TestPartResultArray;

-

-namespace posix = ::testing::internal::posix;

-using testing::internal::String;

-

-// Tests catching fatal failures.

-

-// A subroutine used by the following test.

-void TestEq1(int x) {

-  ASSERT_EQ(1, x);

-}

-

-// This function calls a test subroutine, catches the fatal failure it

-// generates, and then returns early.

-void TryTestSubroutine() {

-  // Calls a subrountine that yields a fatal failure.

-  TestEq1(2);

-

-  // Catches the fatal failure and aborts the test.

-  //

-  // The testing::Test:: prefix is necessary when calling

-  // HasFatalFailure() outside of a TEST, TEST_F, or test fixture.

-  if (testing::Test::HasFatalFailure()) return;

-

-  // If we get here, something is wrong.

-  FAIL() << "This should never be reached.";

-}

-

-TEST(PassingTest, PassingTest1) {

-}

-

-TEST(PassingTest, PassingTest2) {

-}

-

-// Tests catching a fatal failure in a subroutine.

-TEST(FatalFailureTest, FatalFailureInSubroutine) {

-  printf("(expecting a failure that x should be 1)\n");

-

-  TryTestSubroutine();

-}

-

-// Tests catching a fatal failure in a nested subroutine.

-TEST(FatalFailureTest, FatalFailureInNestedSubroutine) {

-  printf("(expecting a failure that x should be 1)\n");

-

-  // Calls a subrountine that yields a fatal failure.

-  TryTestSubroutine();

-

-  // Catches the fatal failure and aborts the test.

-  //

-  // When calling HasFatalFailure() inside a TEST, TEST_F, or test

-  // fixture, the testing::Test:: prefix is not needed.

-  if (HasFatalFailure()) return;

-

-  // If we get here, something is wrong.

-  FAIL() << "This should never be reached.";

-}

-

-// Tests HasFatalFailure() after a failed EXPECT check.

-TEST(FatalFailureTest, NonfatalFailureInSubroutine) {

-  printf("(expecting a failure on false)\n");

-  EXPECT_TRUE(false);  // Generates a nonfatal failure

-  ASSERT_FALSE(HasFatalFailure());  // This should succeed.

-}

-

-// Tests interleaving user logging and Google Test assertions.

-TEST(LoggingTest, InterleavingLoggingAndAssertions) {

-  static const int a[4] = {

-    3, 9, 2, 6

-  };

-

-  printf("(expecting 2 failures on (3) >= (a[i]))\n");

-  for (int i = 0; i < static_cast<int>(sizeof(a)/sizeof(*a)); i++) {

-    printf("i == %d\n", i);

-    EXPECT_GE(3, a[i]);

-  }

-}

-

-// Tests the SCOPED_TRACE macro.

-

-// A helper function for testing SCOPED_TRACE.

-void SubWithoutTrace(int n) {

-  EXPECT_EQ(1, n);

-  ASSERT_EQ(2, n);

-}

-

-// Another helper function for testing SCOPED_TRACE.

-void SubWithTrace(int n) {

-  SCOPED_TRACE(testing::Message() << "n = " << n);

-

-  SubWithoutTrace(n);

-}

-

-// Tests that SCOPED_TRACE() obeys lexical scopes.

-TEST(SCOPED_TRACETest, ObeysScopes) {

-  printf("(expected to fail)\n");

-

-  // There should be no trace before SCOPED_TRACE() is invoked.

-  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";

-

-  {

-    SCOPED_TRACE("Expected trace");

-    // After SCOPED_TRACE(), a failure in the current scope should contain

-    // the trace.

-    ADD_FAILURE() << "This failure is expected, and should have a trace.";

-  }

-

-  // Once the control leaves the scope of the SCOPED_TRACE(), there

-  // should be no trace again.

-  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";

-}

-

-// Tests that SCOPED_TRACE works inside a loop.

-TEST(SCOPED_TRACETest, WorksInLoop) {

-  printf("(expected to fail)\n");

-

-  for (int i = 1; i <= 2; i++) {

-    SCOPED_TRACE(testing::Message() << "i = " << i);

-

-    SubWithoutTrace(i);

-  }

-}

-

-// Tests that SCOPED_TRACE works in a subroutine.

-TEST(SCOPED_TRACETest, WorksInSubroutine) {

-  printf("(expected to fail)\n");

-

-  SubWithTrace(1);

-  SubWithTrace(2);

-}

-

-// Tests that SCOPED_TRACE can be nested.

-TEST(SCOPED_TRACETest, CanBeNested) {

-  printf("(expected to fail)\n");

-

-  SCOPED_TRACE("");  // A trace without a message.

-

-  SubWithTrace(2);

-}

-

-// Tests that multiple SCOPED_TRACEs can be used in the same scope.

-TEST(SCOPED_TRACETest, CanBeRepeated) {

-  printf("(expected to fail)\n");

-

-  SCOPED_TRACE("A");

-  ADD_FAILURE()

-      << "This failure is expected, and should contain trace point A.";

-

-  SCOPED_TRACE("B");

-  ADD_FAILURE()

-      << "This failure is expected, and should contain trace point A and B.";

-

-  {

-    SCOPED_TRACE("C");

-    ADD_FAILURE() << "This failure is expected, and should contain "

-                  << "trace point A, B, and C.";

-  }

-

-  SCOPED_TRACE("D");

-  ADD_FAILURE() << "This failure is expected, and should contain "

-                << "trace point A, B, and D.";

-}

-

-TEST(DisabledTestsWarningTest,

-     DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning) {

-  // This test body is intentionally empty.  Its sole purpose is for

-  // verifying that the --gtest_also_run_disabled_tests flag

-  // suppresses the "YOU HAVE 12 DISABLED TESTS" warning at the end of

-  // the test output.

-}

-

-// Tests using assertions outside of TEST and TEST_F.

-//

-// This function creates two failures intentionally.

-void AdHocTest() {

-  printf("The non-test part of the code is expected to have 2 failures.\n\n");

-  EXPECT_TRUE(false);

-  EXPECT_EQ(2, 3);

-}

-

-// Runs all TESTs, all TEST_Fs, and the ad hoc test.

-int RunAllTests() {

-  AdHocTest();

-  return RUN_ALL_TESTS();

-}

-

-// Tests non-fatal failures in the fixture constructor.

-class NonFatalFailureInFixtureConstructorTest : public testing::Test {

- protected:

-  NonFatalFailureInFixtureConstructorTest() {

-    printf("(expecting 5 failures)\n");

-    ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor.";

-  }

-

-  ~NonFatalFailureInFixtureConstructorTest() {

-    ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor.";

-  }

-

-  virtual void SetUp() {

-    ADD_FAILURE() << "Expected failure #2, in SetUp().";

-  }

-

-  virtual void TearDown() {

-    ADD_FAILURE() << "Expected failure #4, in TearDown.";

-  }

-};

-

-TEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) {

-  ADD_FAILURE() << "Expected failure #3, in the test body.";

-}

-

-// Tests fatal failures in the fixture constructor.

-class FatalFailureInFixtureConstructorTest : public testing::Test {

- protected:

-  FatalFailureInFixtureConstructorTest() {

-    printf("(expecting 2 failures)\n");

-    Init();

-  }

-

-  ~FatalFailureInFixtureConstructorTest() {

-    ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor.";

-  }

-

-  virtual void SetUp() {

-    ADD_FAILURE() << "UNEXPECTED failure in SetUp().  "

-                  << "We should never get here, as the test fixture c'tor "

-                  << "had a fatal failure.";

-  }

-

-  virtual void TearDown() {

-    ADD_FAILURE() << "UNEXPECTED failure in TearDown().  "

-                  << "We should never get here, as the test fixture c'tor "

-                  << "had a fatal failure.";

-  }

- private:

-  void Init() {

-    FAIL() << "Expected failure #1, in the test fixture c'tor.";

-  }

-};

-

-TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {

-  ADD_FAILURE() << "UNEXPECTED failure in the test body.  "

-                << "We should never get here, as the test fixture c'tor "

-                << "had a fatal failure.";

-}

-

-// Tests non-fatal failures in SetUp().

-class NonFatalFailureInSetUpTest : public testing::Test {

- protected:

-  virtual ~NonFatalFailureInSetUpTest() {

-    Deinit();

-  }

-

-  virtual void SetUp() {

-    printf("(expecting 4 failures)\n");

-    ADD_FAILURE() << "Expected failure #1, in SetUp().";

-  }

-

-  virtual void TearDown() {

-    FAIL() << "Expected failure #3, in TearDown().";

-  }

- private:

-  void Deinit() {

-    FAIL() << "Expected failure #4, in the test fixture d'tor.";

-  }

-};

-

-TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {

-  FAIL() << "Expected failure #2, in the test function.";

-}

-

-// Tests fatal failures in SetUp().

-class FatalFailureInSetUpTest : public testing::Test {

- protected:

-  virtual ~FatalFailureInSetUpTest() {

-    Deinit();

-  }

-

-  virtual void SetUp() {

-    printf("(expecting 3 failures)\n");

-    FAIL() << "Expected failure #1, in SetUp().";

-  }

-

-  virtual void TearDown() {

-    FAIL() << "Expected failure #2, in TearDown().";

-  }

- private:

-  void Deinit() {

-    FAIL() << "Expected failure #3, in the test fixture d'tor.";

-  }

-};

-

-TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {

-  FAIL() << "UNEXPECTED failure in the test function.  "

-         << "We should never get here, as SetUp() failed.";

-}

-

-#if GTEST_OS_WINDOWS

-

-// This group of tests verifies that Google Test handles SEH and C++

-// exceptions correctly.

-

-// A function that throws an SEH exception.

-static void ThrowSEH() {

-  int* p = NULL;

-  *p = 0;  // Raises an access violation.

-}

-

-// Tests exceptions thrown in the test fixture constructor.

-class ExceptionInFixtureCtorTest : public testing::Test {

- protected:

-  ExceptionInFixtureCtorTest() {

-    printf("(expecting a failure on thrown exception "

-           "in the test fixture's constructor)\n");

-

-    ThrowSEH();

-  }

-

-  virtual ~ExceptionInFixtureCtorTest() {

-    Deinit();

-  }

-

-  virtual void SetUp() {

-    FAIL() << "UNEXPECTED failure in SetUp().  "

-           << "We should never get here, as the test fixture c'tor threw.";

-  }

-

-  virtual void TearDown() {

-    FAIL() << "UNEXPECTED failure in TearDown().  "

-           << "We should never get here, as the test fixture c'tor threw.";

-  }

- private:

-  void Deinit() {

-    FAIL() << "UNEXPECTED failure in the d'tor.  "

-           << "We should never get here, as the test fixture c'tor threw.";

-  }

-};

-

-TEST_F(ExceptionInFixtureCtorTest, ExceptionInFixtureCtor) {

-  FAIL() << "UNEXPECTED failure in the test function.  "

-         << "We should never get here, as the test fixture c'tor threw.";

-}

-

-// Tests exceptions thrown in SetUp().

-class ExceptionInSetUpTest : public testing::Test {

- protected:

-  virtual ~ExceptionInSetUpTest() {

-    Deinit();

-  }

-

-  virtual void SetUp() {

-    printf("(expecting 3 failures)\n");

-

-    ThrowSEH();

-  }

-

-  virtual void TearDown() {

-    FAIL() << "Expected failure #2, in TearDown().";

-  }

- private:

-  void Deinit() {

-    FAIL() << "Expected failure #3, in the test fixture d'tor.";

-  }

-};

-

-TEST_F(ExceptionInSetUpTest, ExceptionInSetUp) {

-  FAIL() << "UNEXPECTED failure in the test function.  "

-         << "We should never get here, as SetUp() threw.";

-}

-

-// Tests that TearDown() and the test fixture d'tor are always called,

-// even when the test function throws an exception.

-class ExceptionInTestFunctionTest : public testing::Test {

- protected:

-  virtual ~ExceptionInTestFunctionTest() {

-    Deinit();

-  }

-

-  virtual void TearDown() {

-    FAIL() << "Expected failure #2, in TearDown().";

-  }

- private:

-  void Deinit() {

-    FAIL() << "Expected failure #3, in the test fixture d'tor.";

-  }

-};

-

-// Tests that the test fixture d'tor is always called, even when the

-// test function throws an SEH exception.

-TEST_F(ExceptionInTestFunctionTest, SEH) {

-  printf("(expecting 3 failures)\n");

-

-  ThrowSEH();

-}

-

-#if GTEST_HAS_EXCEPTIONS

-

-// Tests that the test fixture d'tor is always called, even when the

-// test function throws a C++ exception.  We do this only when

-// GTEST_HAS_EXCEPTIONS is non-zero, i.e. C++ exceptions are enabled.

-TEST_F(ExceptionInTestFunctionTest, CppException) {

-  throw 1;

-}

-

-// Tests exceptions thrown in TearDown().

-class ExceptionInTearDownTest : public testing::Test {

- protected:

-  virtual ~ExceptionInTearDownTest() {

-    Deinit();

-  }

-

-  virtual void TearDown() {

-    throw 1;

-  }

- private:

-  void Deinit() {

-    FAIL() << "Expected failure #2, in the test fixture d'tor.";

-  }

-};

-

-TEST_F(ExceptionInTearDownTest, ExceptionInTearDown) {

-  printf("(expecting 2 failures)\n");

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

-#endif  // GTEST_OS_WINDOWS

-

-// The MixedUpTestCaseTest test case verifies that Google Test will fail a

-// test if it uses a different fixture class than what other tests in

-// the same test case use.  It deliberately contains two fixture

-// classes with the same name but defined in different namespaces.

-

-// The MixedUpTestCaseWithSameTestNameTest test case verifies that

-// when the user defines two tests with the same test case name AND

-// same test name (but in different namespaces), the second test will

-// fail.

-

-namespace foo {

-

-class MixedUpTestCaseTest : public testing::Test {

-};

-

-TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {}

-TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {}

-

-class MixedUpTestCaseWithSameTestNameTest : public testing::Test {

-};

-

-TEST_F(MixedUpTestCaseWithSameTestNameTest,

-       TheSecondTestWithThisNameShouldFail) {}

-

-}  // namespace foo

-

-namespace bar {

-

-class MixedUpTestCaseTest : public testing::Test {

-};

-

-// The following two tests are expected to fail.  We rely on the

-// golden file to check that Google Test generates the right error message.

-TEST_F(MixedUpTestCaseTest, ThisShouldFail) {}

-TEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {}

-

-class MixedUpTestCaseWithSameTestNameTest : public testing::Test {

-};

-

-// Expected to fail.  We rely on the golden file to check that Google Test

-// generates the right error message.

-TEST_F(MixedUpTestCaseWithSameTestNameTest,

-       TheSecondTestWithThisNameShouldFail) {}

-

-}  // namespace bar

-

-// The following two test cases verify that Google Test catches the user

-// error of mixing TEST and TEST_F in the same test case.  The first

-// test case checks the scenario where TEST_F appears before TEST, and

-// the second one checks where TEST appears before TEST_F.

-

-class TEST_F_before_TEST_in_same_test_case : public testing::Test {

-};

-

-TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}

-

-// Expected to fail.  We rely on the golden file to check that Google Test

-// generates the right error message.

-TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {}

-

-class TEST_before_TEST_F_in_same_test_case : public testing::Test {

-};

-

-TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}

-

-// Expected to fail.  We rely on the golden file to check that Google Test

-// generates the right error message.

-TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {

-}

-

-// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().

-int global_integer = 0;

-

-// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.

-TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {

-  global_integer = 0;

-  EXPECT_NONFATAL_FAILURE({

-    EXPECT_EQ(1, global_integer) << "Expected non-fatal failure.";

-  }, "Expected non-fatal failure.");

-}

-

-// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables

-// (static or not).

-TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {

-  int m = 0;

-  static int n;

-  n = 1;

-  EXPECT_NONFATAL_FAILURE({

-    EXPECT_EQ(m, n) << "Expected non-fatal failure.";

-  }, "Expected non-fatal failure.");

-}

-

-// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly

-// one non-fatal failure and no fatal failure.

-TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {

-  EXPECT_NONFATAL_FAILURE({

-    ADD_FAILURE() << "Expected non-fatal failure.";

-  }, "Expected non-fatal failure.");

-}

-

-// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no

-// non-fatal failure.

-TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {

-  printf("(expecting a failure)\n");

-  EXPECT_NONFATAL_FAILURE({

-  }, "");

-}

-

-// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two

-// non-fatal failures.

-TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {

-  printf("(expecting a failure)\n");

-  EXPECT_NONFATAL_FAILURE({

-    ADD_FAILURE() << "Expected non-fatal failure 1.";

-    ADD_FAILURE() << "Expected non-fatal failure 2.";

-  }, "");

-}

-

-// Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal

-// failure.

-TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {

-  printf("(expecting a failure)\n");

-  EXPECT_NONFATAL_FAILURE({

-    FAIL() << "Expected fatal failure.";

-  }, "");

-}

-

-// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being

-// tested returns.

-TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {

-  printf("(expecting a failure)\n");

-  EXPECT_NONFATAL_FAILURE({

-    return;

-  }, "");

-}

-

-#if GTEST_HAS_EXCEPTIONS

-

-// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being

-// tested throws.

-TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {

-  printf("(expecting a failure)\n");

-  try {

-    EXPECT_NONFATAL_FAILURE({

-      throw 0;

-    }, "");

-  } catch(int) {  // NOLINT

-  }

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

-// Tests that EXPECT_FATAL_FAILURE() can reference global variables.

-TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {

-  global_integer = 0;

-  EXPECT_FATAL_FAILURE({

-    ASSERT_EQ(1, global_integer) << "Expected fatal failure.";

-  }, "Expected fatal failure.");

-}

-

-// Tests that EXPECT_FATAL_FAILURE() can reference local static

-// variables.

-TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {

-  static int n;

-  n = 1;

-  EXPECT_FATAL_FAILURE({

-    ASSERT_EQ(0, n) << "Expected fatal failure.";

-  }, "Expected fatal failure.");

-}

-

-// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly

-// one fatal failure and no non-fatal failure.

-TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {

-  EXPECT_FATAL_FAILURE({

-    FAIL() << "Expected fatal failure.";

-  }, "Expected fatal failure.");

-}

-

-// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal

-// failure.

-TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {

-  printf("(expecting a failure)\n");

-  EXPECT_FATAL_FAILURE({

-  }, "");

-}

-

-// A helper for generating a fatal failure.

-void FatalFailure() {

-  FAIL() << "Expected fatal failure.";

-}

-

-// Tests that EXPECT_FATAL_FAILURE() fails when there are two

-// fatal failures.

-TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {

-  printf("(expecting a failure)\n");

-  EXPECT_FATAL_FAILURE({

-    FatalFailure();

-    FatalFailure();

-  }, "");

-}

-

-// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal

-// failure.

-TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {

-  printf("(expecting a failure)\n");

-  EXPECT_FATAL_FAILURE({

-    ADD_FAILURE() << "Expected non-fatal failure.";

-  }, "");

-}

-

-// Tests that EXPECT_FATAL_FAILURE() fails when the statement being

-// tested returns.

-TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {

-  printf("(expecting a failure)\n");

-  EXPECT_FATAL_FAILURE({

-    return;

-  }, "");

-}

-

-#if GTEST_HAS_EXCEPTIONS

-

-// Tests that EXPECT_FATAL_FAILURE() fails when the statement being

-// tested throws.

-TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {

-  printf("(expecting a failure)\n");

-  try {

-    EXPECT_FATAL_FAILURE({

-      throw 0;

-    }, "");

-  } catch(int) {  // NOLINT

-  }

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

-// This #ifdef block tests the output of typed tests.

-#if GTEST_HAS_TYPED_TEST

-

-template <typename T>

-class TypedTest : public testing::Test {

-};

-

-TYPED_TEST_CASE(TypedTest, testing::Types<int>);

-

-TYPED_TEST(TypedTest, Success) {

-  EXPECT_EQ(0, TypeParam());

-}

-

-TYPED_TEST(TypedTest, Failure) {

-  EXPECT_EQ(1, TypeParam()) << "Expected failure";

-}

-

-#endif  // GTEST_HAS_TYPED_TEST

-

-// This #ifdef block tests the output of type-parameterized tests.

-#if GTEST_HAS_TYPED_TEST_P

-

-template <typename T>

-class TypedTestP : public testing::Test {

-};

-

-TYPED_TEST_CASE_P(TypedTestP);

-

-TYPED_TEST_P(TypedTestP, Success) {

-  EXPECT_EQ(0U, TypeParam());

-}

-

-TYPED_TEST_P(TypedTestP, Failure) {

-  EXPECT_EQ(1U, TypeParam()) << "Expected failure";

-}

-

-REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure);

-

-typedef testing::Types<unsigned char, unsigned int> UnsignedTypes;

-INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes);

-

-#endif  // GTEST_HAS_TYPED_TEST_P

-

-#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.

-

-TEST(ADeathTest, ShouldRunFirst) {

-}

-

-#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.

-

-template <typename T>

-class ATypedDeathTest : public testing::Test {

-};

-

-typedef testing::Types<int, double> NumericTypes;

-TYPED_TEST_CASE(ATypedDeathTest, NumericTypes);

-

-TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {

-}

-

-#endif  // GTEST_HAS_TYPED_TEST

-

-#if GTEST_HAS_TYPED_TEST_P

-

-

-// We rely on the golden file to verify that type-parameterized tests

-// whose test case name ends with DeathTest are run first.

-

-template <typename T>

-class ATypeParamDeathTest : public testing::Test {

-};

-

-TYPED_TEST_CASE_P(ATypeParamDeathTest);

-

-TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {

-}

-

-REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst);

-

-INSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes);

-

-#endif  // GTEST_HAS_TYPED_TEST_P

-

-#endif  // GTEST_HAS_DEATH_TEST

-

-// Tests various failure conditions of

-// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.

-class ExpectFailureTest : public testing::Test {

- public:  // Must be public and not protected due to a bug in g++ 3.4.2.

-  enum FailureMode {

-    FATAL_FAILURE,

-    NONFATAL_FAILURE

-  };

-  static void AddFailure(FailureMode failure) {

-    if (failure == FATAL_FAILURE) {

-      FAIL() << "Expected fatal failure.";

-    } else {

-      ADD_FAILURE() << "Expected non-fatal failure.";

-    }

-  }

-};

-

-TEST_F(ExpectFailureTest, ExpectFatalFailure) {

-  // Expected fatal failure, but succeeds.

-  printf("(expecting 1 failure)\n");

-  EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");

-  // Expected fatal failure, but got a non-fatal failure.

-  printf("(expecting 1 failure)\n");

-  EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Expected non-fatal "

-                       "failure.");

-  // Wrong message.

-  printf("(expecting 1 failure)\n");

-  EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure "

-                       "expected.");

-}

-

-TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {

-  // Expected non-fatal failure, but succeeds.

-  printf("(expecting 1 failure)\n");

-  EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure.");

-  // Expected non-fatal failure, but got a fatal failure.

-  printf("(expecting 1 failure)\n");

-  EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure.");

-  // Wrong message.

-  printf("(expecting 1 failure)\n");

-  EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal "

-                          "failure.");

-}

-

-#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD

-

-class ExpectFailureWithThreadsTest : public ExpectFailureTest {

- protected:

-  static void AddFailureInOtherThread(FailureMode failure) {

-    pthread_t tid;

-    pthread_create(&tid,

-                   NULL,

-                   ExpectFailureWithThreadsTest::FailureThread,

-                   &failure);

-    pthread_join(tid, NULL);

-  }

- private:

-  static void* FailureThread(void* attr) {

-    FailureMode* failure = static_cast<FailureMode*>(attr);

-    AddFailure(*failure);

-    return NULL;

-  }

-};

-

-TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailure) {

-  // We only intercept the current thread.

-  printf("(expecting 2 failures)\n");

-  EXPECT_FATAL_FAILURE(AddFailureInOtherThread(FATAL_FAILURE),

-                       "Expected fatal failure.");

-}

-

-TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailure) {

-  // We only intercept the current thread.

-  printf("(expecting 2 failures)\n");

-  EXPECT_NONFATAL_FAILURE(AddFailureInOtherThread(NONFATAL_FAILURE),

-                          "Expected non-fatal failure.");

-}

-

-typedef ExpectFailureWithThreadsTest ScopedFakeTestPartResultReporterTest;

-

-// Tests that the ScopedFakeTestPartResultReporter only catches failures from

-// the current thread if it is instantiated with INTERCEPT_ONLY_CURRENT_THREAD.

-TEST_F(ScopedFakeTestPartResultReporterTest, InterceptOnlyCurrentThread) {

-  printf("(expecting 2 failures)\n");

-  TestPartResultArray results;

-  {

-    ScopedFakeTestPartResultReporter reporter(

-        ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,

-        &results);

-    AddFailureInOtherThread(FATAL_FAILURE);

-    AddFailureInOtherThread(NONFATAL_FAILURE);

-  }

-  // The two failures should not have been intercepted.

-  EXPECT_EQ(0, results.size()) << "This shouldn't fail.";

-}

-

-#endif  // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD

-

-TEST_F(ExpectFailureTest, ExpectFatalFailureOnAllThreads) {

-  // Expected fatal failure, but succeeds.

-  printf("(expecting 1 failure)\n");

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected fatal failure.");

-  // Expected fatal failure, but got a non-fatal failure.

-  printf("(expecting 1 failure)\n");

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),

-                                      "Expected non-fatal failure.");

-  // Wrong message.

-  printf("(expecting 1 failure)\n");

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),

-                                      "Some other fatal failure expected.");

-}

-

-TEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) {

-  // Expected non-fatal failure, but succeeds.

-  printf("(expecting 1 failure)\n");

-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal "

-                                         "failure.");

-  // Expected non-fatal failure, but got a fatal failure.

-  printf("(expecting 1 failure)\n");

-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),

-                                         "Expected fatal failure.");

-  // Wrong message.

-  printf("(expecting 1 failure)\n");

-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),

-                                         "Some other non-fatal failure.");

-}

-

-

-// Two test environments for testing testing::AddGlobalTestEnvironment().

-

-class FooEnvironment : public testing::Environment {

- public:

-  virtual void SetUp() {

-    printf("%s", "FooEnvironment::SetUp() called.\n");

-  }

-

-  virtual void TearDown() {

-    printf("%s", "FooEnvironment::TearDown() called.\n");

-    FAIL() << "Expected fatal failure.";

-  }

-};

-

-class BarEnvironment : public testing::Environment {

- public:

-  virtual void SetUp() {

-    printf("%s", "BarEnvironment::SetUp() called.\n");

-  }

-

-  virtual void TearDown() {

-    printf("%s", "BarEnvironment::TearDown() called.\n");

-    ADD_FAILURE() << "Expected non-fatal failure.";

-  }

-};

-

-GTEST_DEFINE_bool_(internal_skip_environment_and_ad_hoc_tests, false,

-                   "This flag causes the program to skip test environment "

-                   "tests and ad hoc tests.");

-

-// The main function.

-//

-// The idea is to use Google Test to run all the tests we have defined (some

-// of them are intended to fail), and then compare the test results

-// with the "golden" file.

-int main(int argc, char **argv) {

-  testing::GTEST_FLAG(print_time) = false;

-

-  // We just run the tests, knowing some of them are intended to fail.

-  // We will use a separate Python script to compare the output of

-  // this program with the golden file.

-

-  // It's hard to test InitGoogleTest() directly, as it has many

-  // global side effects.  The following line serves as a sanity test

-  // for it.

-  testing::InitGoogleTest(&argc, argv);

-  if (argc >= 2 &&

-      String(argv[1]) == "--gtest_internal_skip_environment_and_ad_hoc_tests")

-    GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests) = true;

-

-#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.

-#if GTEST_OS_WINDOWS

-    posix::FReopen("nul:", "w", stdout);

-#else

-    posix::FReopen("/dev/null", "w", stdout);

-#endif  // GTEST_OS_WINDOWS

-    return RUN_ALL_TESTS();

-  }

-#endif  // GTEST_HAS_DEATH_TEST

-

-  if (GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests))

-    return RUN_ALL_TESTS();

-

-  // Registers two global test environments.

-  // The golden file verifies that they are set up in the order they

-  // are registered, and torn down in the reverse order.

-  testing::AddGlobalTestEnvironment(new FooEnvironment);

-  testing::AddGlobalTestEnvironment(new BarEnvironment);

-

-  return RunAllTests();

-}

+// Copyright 2005, 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.
+//
+// A unit test for Google Test itself.  This verifies that the basic
+// constructs of Google Test work.
+//
+// Author: [email protected] (Zhanyong Wan)
+
+#include <gtest/gtest-spi.h>
+#include <gtest/gtest.h>
+
+// 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_
+
+#include <stdlib.h>
+
+#if GTEST_HAS_PTHREAD
+#include <pthread.h>
+#endif  // GTEST_HAS_PTHREAD
+
+using testing::ScopedFakeTestPartResultReporter;
+using testing::TestPartResultArray;
+
+namespace posix = ::testing::internal::posix;
+using testing::internal::String;
+
+// Tests catching fatal failures.
+
+// A subroutine used by the following test.
+void TestEq1(int x) {
+  ASSERT_EQ(1, x);
+}
+
+// This function calls a test subroutine, catches the fatal failure it
+// generates, and then returns early.
+void TryTestSubroutine() {
+  // Calls a subrountine that yields a fatal failure.
+  TestEq1(2);
+
+  // Catches the fatal failure and aborts the test.
+  //
+  // The testing::Test:: prefix is necessary when calling
+  // HasFatalFailure() outside of a TEST, TEST_F, or test fixture.
+  if (testing::Test::HasFatalFailure()) return;
+
+  // If we get here, something is wrong.
+  FAIL() << "This should never be reached.";
+}
+
+TEST(PassingTest, PassingTest1) {
+}
+
+TEST(PassingTest, PassingTest2) {
+}
+
+// Tests catching a fatal failure in a subroutine.
+TEST(FatalFailureTest, FatalFailureInSubroutine) {
+  printf("(expecting a failure that x should be 1)\n");
+
+  TryTestSubroutine();
+}
+
+// Tests catching a fatal failure in a nested subroutine.
+TEST(FatalFailureTest, FatalFailureInNestedSubroutine) {
+  printf("(expecting a failure that x should be 1)\n");
+
+  // Calls a subrountine that yields a fatal failure.
+  TryTestSubroutine();
+
+  // Catches the fatal failure and aborts the test.
+  //
+  // When calling HasFatalFailure() inside a TEST, TEST_F, or test
+  // fixture, the testing::Test:: prefix is not needed.
+  if (HasFatalFailure()) return;
+
+  // If we get here, something is wrong.
+  FAIL() << "This should never be reached.";
+}
+
+// Tests HasFatalFailure() after a failed EXPECT check.
+TEST(FatalFailureTest, NonfatalFailureInSubroutine) {
+  printf("(expecting a failure on false)\n");
+  EXPECT_TRUE(false);  // Generates a nonfatal failure
+  ASSERT_FALSE(HasFatalFailure());  // This should succeed.
+}
+
+// Tests interleaving user logging and Google Test assertions.
+TEST(LoggingTest, InterleavingLoggingAndAssertions) {
+  static const int a[4] = {
+    3, 9, 2, 6
+  };
+
+  printf("(expecting 2 failures on (3) >= (a[i]))\n");
+  for (int i = 0; i < static_cast<int>(sizeof(a)/sizeof(*a)); i++) {
+    printf("i == %d\n", i);
+    EXPECT_GE(3, a[i]);
+  }
+}
+
+// Tests the SCOPED_TRACE macro.
+
+// A helper function for testing SCOPED_TRACE.
+void SubWithoutTrace(int n) {
+  EXPECT_EQ(1, n);
+  ASSERT_EQ(2, n);
+}
+
+// Another helper function for testing SCOPED_TRACE.
+void SubWithTrace(int n) {
+  SCOPED_TRACE(testing::Message() << "n = " << n);
+
+  SubWithoutTrace(n);
+}
+
+// Tests that SCOPED_TRACE() obeys lexical scopes.
+TEST(SCOPED_TRACETest, ObeysScopes) {
+  printf("(expected to fail)\n");
+
+  // There should be no trace before SCOPED_TRACE() is invoked.
+  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
+
+  {
+    SCOPED_TRACE("Expected trace");
+    // After SCOPED_TRACE(), a failure in the current scope should contain
+    // the trace.
+    ADD_FAILURE() << "This failure is expected, and should have a trace.";
+  }
+
+  // Once the control leaves the scope of the SCOPED_TRACE(), there
+  // should be no trace again.
+  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
+}
+
+// Tests that SCOPED_TRACE works inside a loop.
+TEST(SCOPED_TRACETest, WorksInLoop) {
+  printf("(expected to fail)\n");
+
+  for (int i = 1; i <= 2; i++) {
+    SCOPED_TRACE(testing::Message() << "i = " << i);
+
+    SubWithoutTrace(i);
+  }
+}
+
+// Tests that SCOPED_TRACE works in a subroutine.
+TEST(SCOPED_TRACETest, WorksInSubroutine) {
+  printf("(expected to fail)\n");
+
+  SubWithTrace(1);
+  SubWithTrace(2);
+}
+
+// Tests that SCOPED_TRACE can be nested.
+TEST(SCOPED_TRACETest, CanBeNested) {
+  printf("(expected to fail)\n");
+
+  SCOPED_TRACE("");  // A trace without a message.
+
+  SubWithTrace(2);
+}
+
+// Tests that multiple SCOPED_TRACEs can be used in the same scope.
+TEST(SCOPED_TRACETest, CanBeRepeated) {
+  printf("(expected to fail)\n");
+
+  SCOPED_TRACE("A");
+  ADD_FAILURE()
+      << "This failure is expected, and should contain trace point A.";
+
+  SCOPED_TRACE("B");
+  ADD_FAILURE()
+      << "This failure is expected, and should contain trace point A and B.";
+
+  {
+    SCOPED_TRACE("C");
+    ADD_FAILURE() << "This failure is expected, and should contain "
+                  << "trace point A, B, and C.";
+  }
+
+  SCOPED_TRACE("D");
+  ADD_FAILURE() << "This failure is expected, and should contain "
+                << "trace point A, B, and D.";
+}
+
+TEST(DisabledTestsWarningTest,
+     DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning) {
+  // This test body is intentionally empty.  Its sole purpose is for
+  // verifying that the --gtest_also_run_disabled_tests flag
+  // suppresses the "YOU HAVE 12 DISABLED TESTS" warning at the end of
+  // the test output.
+}
+
+// Tests using assertions outside of TEST and TEST_F.
+//
+// This function creates two failures intentionally.
+void AdHocTest() {
+  printf("The non-test part of the code is expected to have 2 failures.\n\n");
+  EXPECT_TRUE(false);
+  EXPECT_EQ(2, 3);
+}
+
+// Runs all TESTs, all TEST_Fs, and the ad hoc test.
+int RunAllTests() {
+  AdHocTest();
+  return RUN_ALL_TESTS();
+}
+
+// Tests non-fatal failures in the fixture constructor.
+class NonFatalFailureInFixtureConstructorTest : public testing::Test {
+ protected:
+  NonFatalFailureInFixtureConstructorTest() {
+    printf("(expecting 5 failures)\n");
+    ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor.";
+  }
+
+  ~NonFatalFailureInFixtureConstructorTest() {
+    ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor.";
+  }
+
+  virtual void SetUp() {
+    ADD_FAILURE() << "Expected failure #2, in SetUp().";
+  }
+
+  virtual void TearDown() {
+    ADD_FAILURE() << "Expected failure #4, in TearDown.";
+  }
+};
+
+TEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) {
+  ADD_FAILURE() << "Expected failure #3, in the test body.";
+}
+
+// Tests fatal failures in the fixture constructor.
+class FatalFailureInFixtureConstructorTest : public testing::Test {
+ protected:
+  FatalFailureInFixtureConstructorTest() {
+    printf("(expecting 2 failures)\n");
+    Init();
+  }
+
+  ~FatalFailureInFixtureConstructorTest() {
+    ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor.";
+  }
+
+  virtual void SetUp() {
+    ADD_FAILURE() << "UNEXPECTED failure in SetUp().  "
+                  << "We should never get here, as the test fixture c'tor "
+                  << "had a fatal failure.";
+  }
+
+  virtual void TearDown() {
+    ADD_FAILURE() << "UNEXPECTED failure in TearDown().  "
+                  << "We should never get here, as the test fixture c'tor "
+                  << "had a fatal failure.";
+  }
+ private:
+  void Init() {
+    FAIL() << "Expected failure #1, in the test fixture c'tor.";
+  }
+};
+
+TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {
+  ADD_FAILURE() << "UNEXPECTED failure in the test body.  "
+                << "We should never get here, as the test fixture c'tor "
+                << "had a fatal failure.";
+}
+
+// Tests non-fatal failures in SetUp().
+class NonFatalFailureInSetUpTest : public testing::Test {
+ protected:
+  virtual ~NonFatalFailureInSetUpTest() {
+    Deinit();
+  }
+
+  virtual void SetUp() {
+    printf("(expecting 4 failures)\n");
+    ADD_FAILURE() << "Expected failure #1, in SetUp().";
+  }
+
+  virtual void TearDown() {
+    FAIL() << "Expected failure #3, in TearDown().";
+  }
+ private:
+  void Deinit() {
+    FAIL() << "Expected failure #4, in the test fixture d'tor.";
+  }
+};
+
+TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {
+  FAIL() << "Expected failure #2, in the test function.";
+}
+
+// Tests fatal failures in SetUp().
+class FatalFailureInSetUpTest : public testing::Test {
+ protected:
+  virtual ~FatalFailureInSetUpTest() {
+    Deinit();
+  }
+
+  virtual void SetUp() {
+    printf("(expecting 3 failures)\n");
+    FAIL() << "Expected failure #1, in SetUp().";
+  }
+
+  virtual void TearDown() {
+    FAIL() << "Expected failure #2, in TearDown().";
+  }
+ private:
+  void Deinit() {
+    FAIL() << "Expected failure #3, in the test fixture d'tor.";
+  }
+};
+
+TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {
+  FAIL() << "UNEXPECTED failure in the test function.  "
+         << "We should never get here, as SetUp() failed.";
+}
+
+#if GTEST_OS_WINDOWS
+
+// This group of tests verifies that Google Test handles SEH and C++
+// exceptions correctly.
+
+// A function that throws an SEH exception.
+static void ThrowSEH() {
+  int* p = NULL;
+  *p = 0;  // Raises an access violation.
+}
+
+// Tests exceptions thrown in the test fixture constructor.
+class ExceptionInFixtureCtorTest : public testing::Test {
+ protected:
+  ExceptionInFixtureCtorTest() {
+    printf("(expecting a failure on thrown exception "
+           "in the test fixture's constructor)\n");
+
+    ThrowSEH();
+  }
+
+  virtual ~ExceptionInFixtureCtorTest() {
+    Deinit();
+  }
+
+  virtual void SetUp() {
+    FAIL() << "UNEXPECTED failure in SetUp().  "
+           << "We should never get here, as the test fixture c'tor threw.";
+  }
+
+  virtual void TearDown() {
+    FAIL() << "UNEXPECTED failure in TearDown().  "
+           << "We should never get here, as the test fixture c'tor threw.";
+  }
+ private:
+  void Deinit() {
+    FAIL() << "UNEXPECTED failure in the d'tor.  "
+           << "We should never get here, as the test fixture c'tor threw.";
+  }
+};
+
+TEST_F(ExceptionInFixtureCtorTest, ExceptionInFixtureCtor) {
+  FAIL() << "UNEXPECTED failure in the test function.  "
+         << "We should never get here, as the test fixture c'tor threw.";
+}
+
+// Tests exceptions thrown in SetUp().
+class ExceptionInSetUpTest : public testing::Test {
+ protected:
+  virtual ~ExceptionInSetUpTest() {
+    Deinit();
+  }
+
+  virtual void SetUp() {
+    printf("(expecting 3 failures)\n");
+
+    ThrowSEH();
+  }
+
+  virtual void TearDown() {
+    FAIL() << "Expected failure #2, in TearDown().";
+  }
+ private:
+  void Deinit() {
+    FAIL() << "Expected failure #3, in the test fixture d'tor.";
+  }
+};
+
+TEST_F(ExceptionInSetUpTest, ExceptionInSetUp) {
+  FAIL() << "UNEXPECTED failure in the test function.  "
+         << "We should never get here, as SetUp() threw.";
+}
+
+// Tests that TearDown() and the test fixture d'tor are always called,
+// even when the test function throws an exception.
+class ExceptionInTestFunctionTest : public testing::Test {
+ protected:
+  virtual ~ExceptionInTestFunctionTest() {
+    Deinit();
+  }
+
+  virtual void TearDown() {
+    FAIL() << "Expected failure #2, in TearDown().";
+  }
+ private:
+  void Deinit() {
+    FAIL() << "Expected failure #3, in the test fixture d'tor.";
+  }
+};
+
+// Tests that the test fixture d'tor is always called, even when the
+// test function throws an SEH exception.
+TEST_F(ExceptionInTestFunctionTest, SEH) {
+  printf("(expecting 3 failures)\n");
+
+  ThrowSEH();
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Tests that the test fixture d'tor is always called, even when the
+// test function throws a C++ exception.  We do this only when
+// GTEST_HAS_EXCEPTIONS is non-zero, i.e. C++ exceptions are enabled.
+TEST_F(ExceptionInTestFunctionTest, CppException) {
+  throw 1;
+}
+
+// Tests exceptions thrown in TearDown().
+class ExceptionInTearDownTest : public testing::Test {
+ protected:
+  virtual ~ExceptionInTearDownTest() {
+    Deinit();
+  }
+
+  virtual void TearDown() {
+    throw 1;
+  }
+ private:
+  void Deinit() {
+    FAIL() << "Expected failure #2, in the test fixture d'tor.";
+  }
+};
+
+TEST_F(ExceptionInTearDownTest, ExceptionInTearDown) {
+  printf("(expecting 2 failures)\n");
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#endif  // GTEST_OS_WINDOWS
+
+// The MixedUpTestCaseTest test case verifies that Google Test will fail a
+// test if it uses a different fixture class than what other tests in
+// the same test case use.  It deliberately contains two fixture
+// classes with the same name but defined in different namespaces.
+
+// The MixedUpTestCaseWithSameTestNameTest test case verifies that
+// when the user defines two tests with the same test case name AND
+// same test name (but in different namespaces), the second test will
+// fail.
+
+namespace foo {
+
+class MixedUpTestCaseTest : public testing::Test {
+};
+
+TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {}
+TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {}
+
+class MixedUpTestCaseWithSameTestNameTest : public testing::Test {
+};
+
+TEST_F(MixedUpTestCaseWithSameTestNameTest,
+       TheSecondTestWithThisNameShouldFail) {}
+
+}  // namespace foo
+
+namespace bar {
+
+class MixedUpTestCaseTest : public testing::Test {
+};
+
+// The following two tests are expected to fail.  We rely on the
+// golden file to check that Google Test generates the right error message.
+TEST_F(MixedUpTestCaseTest, ThisShouldFail) {}
+TEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {}
+
+class MixedUpTestCaseWithSameTestNameTest : public testing::Test {
+};
+
+// Expected to fail.  We rely on the golden file to check that Google Test
+// generates the right error message.
+TEST_F(MixedUpTestCaseWithSameTestNameTest,
+       TheSecondTestWithThisNameShouldFail) {}
+
+}  // namespace bar
+
+// The following two test cases verify that Google Test catches the user
+// error of mixing TEST and TEST_F in the same test case.  The first
+// test case checks the scenario where TEST_F appears before TEST, and
+// the second one checks where TEST appears before TEST_F.
+
+class TEST_F_before_TEST_in_same_test_case : public testing::Test {
+};
+
+TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}
+
+// Expected to fail.  We rely on the golden file to check that Google Test
+// generates the right error message.
+TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {}
+
+class TEST_before_TEST_F_in_same_test_case : public testing::Test {
+};
+
+TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}
+
+// Expected to fail.  We rely on the golden file to check that Google Test
+// generates the right error message.
+TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {
+}
+
+// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().
+int global_integer = 0;
+
+// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.
+TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {
+  global_integer = 0;
+  EXPECT_NONFATAL_FAILURE({
+    EXPECT_EQ(1, global_integer) << "Expected non-fatal failure.";
+  }, "Expected non-fatal failure.");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables
+// (static or not).
+TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {
+  int m = 0;
+  static int n;
+  n = 1;
+  EXPECT_NONFATAL_FAILURE({
+    EXPECT_EQ(m, n) << "Expected non-fatal failure.";
+  }, "Expected non-fatal failure.");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly
+// one non-fatal failure and no fatal failure.
+TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {
+  EXPECT_NONFATAL_FAILURE({
+    ADD_FAILURE() << "Expected non-fatal failure.";
+  }, "Expected non-fatal failure.");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no
+// non-fatal failure.
+TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {
+  printf("(expecting a failure)\n");
+  EXPECT_NONFATAL_FAILURE({
+  }, "");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two
+// non-fatal failures.
+TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {
+  printf("(expecting a failure)\n");
+  EXPECT_NONFATAL_FAILURE({
+    ADD_FAILURE() << "Expected non-fatal failure 1.";
+    ADD_FAILURE() << "Expected non-fatal failure 2.";
+  }, "");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal
+// failure.
+TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {
+  printf("(expecting a failure)\n");
+  EXPECT_NONFATAL_FAILURE({
+    FAIL() << "Expected fatal failure.";
+  }, "");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
+// tested returns.
+TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {
+  printf("(expecting a failure)\n");
+  EXPECT_NONFATAL_FAILURE({
+    return;
+  }, "");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
+// tested throws.
+TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {
+  printf("(expecting a failure)\n");
+  try {
+    EXPECT_NONFATAL_FAILURE({
+      throw 0;
+    }, "");
+  } catch(int) {  // NOLINT
+  }
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Tests that EXPECT_FATAL_FAILURE() can reference global variables.
+TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {
+  global_integer = 0;
+  EXPECT_FATAL_FAILURE({
+    ASSERT_EQ(1, global_integer) << "Expected fatal failure.";
+  }, "Expected fatal failure.");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() can reference local static
+// variables.
+TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {
+  static int n;
+  n = 1;
+  EXPECT_FATAL_FAILURE({
+    ASSERT_EQ(0, n) << "Expected fatal failure.";
+  }, "Expected fatal failure.");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly
+// one fatal failure and no non-fatal failure.
+TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {
+  EXPECT_FATAL_FAILURE({
+    FAIL() << "Expected fatal failure.";
+  }, "Expected fatal failure.");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal
+// failure.
+TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {
+  printf("(expecting a failure)\n");
+  EXPECT_FATAL_FAILURE({
+  }, "");
+}
+
+// A helper for generating a fatal failure.
+void FatalFailure() {
+  FAIL() << "Expected fatal failure.";
+}
+
+// Tests that EXPECT_FATAL_FAILURE() fails when there are two
+// fatal failures.
+TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {
+  printf("(expecting a failure)\n");
+  EXPECT_FATAL_FAILURE({
+    FatalFailure();
+    FatalFailure();
+  }, "");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal
+// failure.
+TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {
+  printf("(expecting a failure)\n");
+  EXPECT_FATAL_FAILURE({
+    ADD_FAILURE() << "Expected non-fatal failure.";
+  }, "");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
+// tested returns.
+TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {
+  printf("(expecting a failure)\n");
+  EXPECT_FATAL_FAILURE({
+    return;
+  }, "");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
+// tested throws.
+TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {
+  printf("(expecting a failure)\n");
+  try {
+    EXPECT_FATAL_FAILURE({
+      throw 0;
+    }, "");
+  } catch(int) {  // NOLINT
+  }
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// This #ifdef block tests the output of typed tests.
+#if GTEST_HAS_TYPED_TEST
+
+template <typename T>
+class TypedTest : public testing::Test {
+};
+
+TYPED_TEST_CASE(TypedTest, testing::Types<int>);
+
+TYPED_TEST(TypedTest, Success) {
+  EXPECT_EQ(0, TypeParam());
+}
+
+TYPED_TEST(TypedTest, Failure) {
+  EXPECT_EQ(1, TypeParam()) << "Expected failure";
+}
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+// This #ifdef block tests the output of type-parameterized tests.
+#if GTEST_HAS_TYPED_TEST_P
+
+template <typename T>
+class TypedTestP : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(TypedTestP);
+
+TYPED_TEST_P(TypedTestP, Success) {
+  EXPECT_EQ(0U, TypeParam());
+}
+
+TYPED_TEST_P(TypedTestP, Failure) {
+  EXPECT_EQ(1U, TypeParam()) << "Expected failure";
+}
+
+REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure);
+
+typedef testing::Types<unsigned char, unsigned int> UnsignedTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes);
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+#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.
+
+TEST(ADeathTest, ShouldRunFirst) {
+}
+
+#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.
+
+template <typename T>
+class ATypedDeathTest : public testing::Test {
+};
+
+typedef testing::Types<int, double> NumericTypes;
+TYPED_TEST_CASE(ATypedDeathTest, NumericTypes);
+
+TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {
+}
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+#if GTEST_HAS_TYPED_TEST_P
+
+
+// We rely on the golden file to verify that type-parameterized tests
+// whose test case name ends with DeathTest are run first.
+
+template <typename T>
+class ATypeParamDeathTest : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(ATypeParamDeathTest);
+
+TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {
+}
+
+REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes);
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Tests various failure conditions of
+// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.
+class ExpectFailureTest : public testing::Test {
+ public:  // Must be public and not protected due to a bug in g++ 3.4.2.
+  enum FailureMode {
+    FATAL_FAILURE,
+    NONFATAL_FAILURE
+  };
+  static void AddFailure(FailureMode failure) {
+    if (failure == FATAL_FAILURE) {
+      FAIL() << "Expected fatal failure.";
+    } else {
+      ADD_FAILURE() << "Expected non-fatal failure.";
+    }
+  }
+};
+
+TEST_F(ExpectFailureTest, ExpectFatalFailure) {
+  // Expected fatal failure, but succeeds.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");
+  // Expected fatal failure, but got a non-fatal failure.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Expected non-fatal "
+                       "failure.");
+  // Wrong message.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure "
+                       "expected.");
+}
+
+TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {
+  // Expected non-fatal failure, but succeeds.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure.");
+  // Expected non-fatal failure, but got a fatal failure.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure.");
+  // Wrong message.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal "
+                          "failure.");
+}
+
+#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
+
+class ExpectFailureWithThreadsTest : public ExpectFailureTest {
+ protected:
+  static void AddFailureInOtherThread(FailureMode failure) {
+    pthread_t tid;
+    pthread_create(&tid,
+                   NULL,
+                   ExpectFailureWithThreadsTest::FailureThread,
+                   &failure);
+    pthread_join(tid, NULL);
+  }
+ private:
+  static void* FailureThread(void* attr) {
+    FailureMode* failure = static_cast<FailureMode*>(attr);
+    AddFailure(*failure);
+    return NULL;
+  }
+};
+
+TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailure) {
+  // We only intercept the current thread.
+  printf("(expecting 2 failures)\n");
+  EXPECT_FATAL_FAILURE(AddFailureInOtherThread(FATAL_FAILURE),
+                       "Expected fatal failure.");
+}
+
+TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailure) {
+  // We only intercept the current thread.
+  printf("(expecting 2 failures)\n");
+  EXPECT_NONFATAL_FAILURE(AddFailureInOtherThread(NONFATAL_FAILURE),
+                          "Expected non-fatal failure.");
+}
+
+typedef ExpectFailureWithThreadsTest ScopedFakeTestPartResultReporterTest;
+
+// Tests that the ScopedFakeTestPartResultReporter only catches failures from
+// the current thread if it is instantiated with INTERCEPT_ONLY_CURRENT_THREAD.
+TEST_F(ScopedFakeTestPartResultReporterTest, InterceptOnlyCurrentThread) {
+  printf("(expecting 2 failures)\n");
+  TestPartResultArray results;
+  {
+    ScopedFakeTestPartResultReporter reporter(
+        ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,
+        &results);
+    AddFailureInOtherThread(FATAL_FAILURE);
+    AddFailureInOtherThread(NONFATAL_FAILURE);
+  }
+  // The two failures should not have been intercepted.
+  EXPECT_EQ(0, results.size()) << "This shouldn't fail.";
+}
+
+#endif  // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
+
+TEST_F(ExpectFailureTest, ExpectFatalFailureOnAllThreads) {
+  // Expected fatal failure, but succeeds.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected fatal failure.");
+  // Expected fatal failure, but got a non-fatal failure.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
+                                      "Expected non-fatal failure.");
+  // Wrong message.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
+                                      "Some other fatal failure expected.");
+}
+
+TEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) {
+  // Expected non-fatal failure, but succeeds.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal "
+                                         "failure.");
+  // Expected non-fatal failure, but got a fatal failure.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
+                                         "Expected fatal failure.");
+  // Wrong message.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
+                                         "Some other non-fatal failure.");
+}
+
+
+// Two test environments for testing testing::AddGlobalTestEnvironment().
+
+class FooEnvironment : public testing::Environment {
+ public:
+  virtual void SetUp() {
+    printf("%s", "FooEnvironment::SetUp() called.\n");
+  }
+
+  virtual void TearDown() {
+    printf("%s", "FooEnvironment::TearDown() called.\n");
+    FAIL() << "Expected fatal failure.";
+  }
+};
+
+class BarEnvironment : public testing::Environment {
+ public:
+  virtual void SetUp() {
+    printf("%s", "BarEnvironment::SetUp() called.\n");
+  }
+
+  virtual void TearDown() {
+    printf("%s", "BarEnvironment::TearDown() called.\n");
+    ADD_FAILURE() << "Expected non-fatal failure.";
+  }
+};
+
+GTEST_DEFINE_bool_(internal_skip_environment_and_ad_hoc_tests, false,
+                   "This flag causes the program to skip test environment "
+                   "tests and ad hoc tests.");
+
+// The main function.
+//
+// The idea is to use Google Test to run all the tests we have defined (some
+// of them are intended to fail), and then compare the test results
+// with the "golden" file.
+int main(int argc, char **argv) {
+  testing::GTEST_FLAG(print_time) = false;
+
+  // We just run the tests, knowing some of them are intended to fail.
+  // We will use a separate Python script to compare the output of
+  // this program with the golden file.
+
+  // It's hard to test InitGoogleTest() directly, as it has many
+  // global side effects.  The following line serves as a sanity test
+  // for it.
+  testing::InitGoogleTest(&argc, argv);
+  if (argc >= 2 &&
+      String(argv[1]) == "--gtest_internal_skip_environment_and_ad_hoc_tests")
+    GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests) = true;
+
+#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.
+#if GTEST_OS_WINDOWS
+    posix::FReopen("nul:", "w", stdout);
+#else
+    posix::FReopen("/dev/null", "w", stdout);
+#endif  // GTEST_OS_WINDOWS
+    return RUN_ALL_TESTS();
+  }
+#endif  // GTEST_HAS_DEATH_TEST
+
+  if (GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests))
+    return RUN_ALL_TESTS();
+
+  // Registers two global test environments.
+  // The golden file verifies that they are set up in the order they
+  // are registered, and torn down in the reverse order.
+  testing::AddGlobalTestEnvironment(new FooEnvironment);
+  testing::AddGlobalTestEnvironment(new BarEnvironment);
+
+  return RunAllTests();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_output_test_golden_win.txt b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_output_test_golden_win.txt
index 5ff2e14d..313c3aaf 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_output_test_golden_win.txt
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_output_test_golden_win.txt
@@ -1,605 +1,605 @@
-The non-test part of the code is expected to have 2 failures.

-

-gtest_output_test_.cc:#: error: Value of: false

-  Actual: false

-Expected: true

-gtest_output_test_.cc:#: error: Value of: 3

-Expected: 2

-[==========] Running 61 tests from 27 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

-[ RUN      ] PassingTest.PassingTest2

-[       OK ] PassingTest.PassingTest2

-[----------] 3 tests from FatalFailureTest

-[ RUN      ] FatalFailureTest.FatalFailureInSubroutine

-(expecting a failure that x should be 1)

-gtest_output_test_.cc:#: error: Value of: x

-  Actual: 2

-Expected: 1

-[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine

-[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine

-(expecting a failure that x should be 1)

-gtest_output_test_.cc:#: error: Value of: x

-  Actual: 2

-Expected: 1

-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine

-[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine

-(expecting a failure on false)

-gtest_output_test_.cc:#: error: Value of: false

-  Actual: false

-Expected: true

-[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine

-[----------] 1 test from LoggingTest

-[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions

-(expecting 2 failures on (3) >= (a[i]))

-i == 0

-i == 1

-gtest_output_test_.cc:#: error: Expected: (3) >= (a[i]), actual: 3 vs 9

-i == 2

-i == 3

-gtest_output_test_.cc:#: error: Expected: (3) >= (a[i]), actual: 3 vs 6

-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions

-[----------] 5 tests from SCOPED_TRACETest

-[ RUN      ] SCOPED_TRACETest.ObeysScopes

-(expected to fail)

-gtest_output_test_.cc:#: error: Failed

-This failure is expected, and shouldn't have a trace.

-gtest_output_test_.cc:#: error: Failed

-This failure is expected, and should have a trace.

-Google Test trace:

-gtest_output_test_.cc:#: Expected trace

-gtest_output_test_.cc:#: error: Failed

-This failure is expected, and shouldn't have a trace.

-[  FAILED  ] SCOPED_TRACETest.ObeysScopes

-[ RUN      ] SCOPED_TRACETest.WorksInLoop

-(expected to fail)

-gtest_output_test_.cc:#: error: Value of: n

-  Actual: 1

-Expected: 2

-Google Test trace:

-gtest_output_test_.cc:#: i = 1

-gtest_output_test_.cc:#: error: Value of: n

-  Actual: 2

-Expected: 1

-Google Test trace:

-gtest_output_test_.cc:#: i = 2

-[  FAILED  ] SCOPED_TRACETest.WorksInLoop

-[ RUN      ] SCOPED_TRACETest.WorksInSubroutine

-(expected to fail)

-gtest_output_test_.cc:#: error: Value of: n

-  Actual: 1

-Expected: 2

-Google Test trace:

-gtest_output_test_.cc:#: n = 1

-gtest_output_test_.cc:#: error: Value of: n

-  Actual: 2

-Expected: 1

-Google Test trace:

-gtest_output_test_.cc:#: n = 2

-[  FAILED  ] SCOPED_TRACETest.WorksInSubroutine

-[ RUN      ] SCOPED_TRACETest.CanBeNested

-(expected to fail)

-gtest_output_test_.cc:#: error: Value of: n

-  Actual: 2

-Expected: 1

-Google Test trace:

-gtest_output_test_.cc:#: n = 2

-gtest_output_test_.cc:#: 

-[  FAILED  ] SCOPED_TRACETest.CanBeNested

-[ RUN      ] SCOPED_TRACETest.CanBeRepeated

-(expected to fail)

-gtest_output_test_.cc:#: error: Failed

-This failure is expected, and should contain trace point A.

-Google Test trace:

-gtest_output_test_.cc:#: A

-gtest_output_test_.cc:#: error: Failed

-This failure is expected, and should contain trace point A and B.

-Google Test trace:

-gtest_output_test_.cc:#: B

-gtest_output_test_.cc:#: A

-gtest_output_test_.cc:#: error: Failed

-This failure is expected, and should contain trace point A, B, and C.

-Google Test trace:

-gtest_output_test_.cc:#: C

-gtest_output_test_.cc:#: B

-gtest_output_test_.cc:#: A

-gtest_output_test_.cc:#: error: Failed

-This failure is expected, and should contain trace point A, B, and D.

-Google Test trace:

-gtest_output_test_.cc:#: D

-gtest_output_test_.cc:#: B

-gtest_output_test_.cc:#: A

-[  FAILED  ] SCOPED_TRACETest.CanBeRepeated

-[----------] 1 test from NonFatalFailureInFixtureConstructorTest

-[ RUN      ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor

-(expecting 5 failures)

-gtest_output_test_.cc:#: error: Failed

-Expected failure #1, in the test fixture c'tor.

-gtest_output_test_.cc:#: error: Failed

-Expected failure #2, in SetUp().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #3, in the test body.

-gtest_output_test_.cc:#: error: Failed

-Expected failure #4, in TearDown.

-gtest_output_test_.cc:#: error: Failed

-Expected failure #5, in the test fixture d'tor.

-[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor

-[----------] 1 test from FatalFailureInFixtureConstructorTest

-[ RUN      ] FatalFailureInFixtureConstructorTest.FailureInConstructor

-(expecting 2 failures)

-gtest_output_test_.cc:#: error: Failed

-Expected failure #1, in the test fixture c'tor.

-gtest_output_test_.cc:#: error: Failed

-Expected failure #2, in the test fixture d'tor.

-[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor

-[----------] 1 test from NonFatalFailureInSetUpTest

-[ RUN      ] NonFatalFailureInSetUpTest.FailureInSetUp

-(expecting 4 failures)

-gtest_output_test_.cc:#: error: Failed

-Expected failure #1, in SetUp().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #2, in the test function.

-gtest_output_test_.cc:#: error: Failed

-Expected failure #3, in TearDown().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #4, in the test fixture d'tor.

-[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp

-[----------] 1 test from FatalFailureInSetUpTest

-[ RUN      ] FatalFailureInSetUpTest.FailureInSetUp

-(expecting 3 failures)

-gtest_output_test_.cc:#: error: Failed

-Expected failure #1, in SetUp().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #2, in TearDown().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #3, in the test fixture d'tor.

-[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp

-[----------] 1 test from ExceptionInFixtureCtorTest

-[ RUN      ] ExceptionInFixtureCtorTest.ExceptionInFixtureCtor

-(expecting a failure on thrown exception in the test fixture's constructor)

-unknown file: error: Exception thrown with code 0xc0000005 in the test fixture's constructor.

-[----------] 1 test from ExceptionInSetUpTest

-[ RUN      ] ExceptionInSetUpTest.ExceptionInSetUp

-(expecting 3 failures)

-unknown file: error: Exception thrown with code 0xc0000005 in SetUp().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #2, in TearDown().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #3, in the test fixture d'tor.

-[  FAILED  ] ExceptionInSetUpTest.ExceptionInSetUp

-[----------] 2 tests from ExceptionInTestFunctionTest

-[ RUN      ] ExceptionInTestFunctionTest.SEH

-(expecting 3 failures)

-unknown file: error: Exception thrown with code 0xc0000005 in the test body.

-gtest_output_test_.cc:#: error: Failed

-Expected failure #2, in TearDown().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #3, in the test fixture d'tor.

-[  FAILED  ] ExceptionInTestFunctionTest.SEH

-[ RUN      ] ExceptionInTestFunctionTest.CppException

-unknown file: error: Exception thrown with code 0xe06d7363 in the test body.

-gtest_output_test_.cc:#: error: Failed

-Expected failure #2, in TearDown().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #3, in the test fixture d'tor.

-[  FAILED  ] ExceptionInTestFunctionTest.CppException

-[----------] 1 test from ExceptionInTearDownTest

-[ RUN      ] ExceptionInTearDownTest.ExceptionInTearDown

-(expecting 2 failures)

-unknown file: error: Exception thrown with code 0xe06d7363 in TearDown().

-gtest_output_test_.cc:#: error: Failed

-Expected failure #2, in the test fixture d'tor.

-[  FAILED  ] ExceptionInTearDownTest.ExceptionInTearDown

-[----------] 4 tests from MixedUpTestCaseTest

-[ RUN      ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo

-[       OK ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo

-[ RUN      ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo

-[       OK ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo

-[ RUN      ] MixedUpTestCaseTest.ThisShouldFail

-gtest.cc:#: error: Failed

-All tests in the same test case must use the same test fixture

-class.  However, in test case MixedUpTestCaseTest,

-you defined test FirstTestFromNamespaceFoo and test ThisShouldFail

-using two different test fixture classes.  This can happen if

-the two classes are from different namespaces or translation

-units and have the same name.  You should probably rename one

-of the classes to put the tests into different test cases.

-[  FAILED  ] MixedUpTestCaseTest.ThisShouldFail

-[ RUN      ] MixedUpTestCaseTest.ThisShouldFailToo

-gtest.cc:#: error: Failed

-All tests in the same test case must use the same test fixture

-class.  However, in test case MixedUpTestCaseTest,

-you defined test FirstTestFromNamespaceFoo and test ThisShouldFailToo

-using two different test fixture classes.  This can happen if

-the two classes are from different namespaces or translation

-units and have the same name.  You should probably rename one

-of the classes to put the tests into different test cases.

-[  FAILED  ] MixedUpTestCaseTest.ThisShouldFailToo

-[----------] 2 tests from MixedUpTestCaseWithSameTestNameTest

-[ RUN      ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail

-[       OK ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail

-[ RUN      ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail

-gtest.cc:#: error: Failed

-All tests in the same test case must use the same test fixture

-class.  However, in test case MixedUpTestCaseWithSameTestNameTest,

-you defined test TheSecondTestWithThisNameShouldFail and test TheSecondTestWithThisNameShouldFail

-using two different test fixture classes.  This can happen if

-the two classes are from different namespaces or translation

-units and have the same name.  You should probably rename one

-of the classes to put the tests into different test cases.

-[  FAILED  ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail

-[----------] 2 tests from TEST_F_before_TEST_in_same_test_case

-[ RUN      ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F

-[       OK ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F

-[ RUN      ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail

-gtest.cc:#: error: Failed

-All tests in the same test case must use the same test fixture

-class, so mixing TEST_F and TEST in the same test case is

-illegal.  In test case TEST_F_before_TEST_in_same_test_case,

-test DefinedUsingTEST_F is defined using TEST_F but

-test DefinedUsingTESTAndShouldFail is defined using TEST.  You probably

-want to change the TEST to TEST_F or move it to another test

-case.

-[  FAILED  ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail

-[----------] 2 tests from TEST_before_TEST_F_in_same_test_case

-[ RUN      ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST

-[       OK ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST

-[ RUN      ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail

-gtest.cc:#: error: Failed

-All tests in the same test case must use the same test fixture

-class, so mixing TEST_F and TEST in the same test case is

-illegal.  In test case TEST_before_TEST_F_in_same_test_case,

-test DefinedUsingTEST_FAndShouldFail is defined using TEST_F but

-test DefinedUsingTEST is defined using TEST.  You probably

-want to change the TEST to TEST_F or move it to another test

-case.

-[  FAILED  ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail

-[----------] 8 tests from ExpectNonfatalFailureTest

-[ RUN      ] ExpectNonfatalFailureTest.CanReferenceGlobalVariables

-[       OK ] ExpectNonfatalFailureTest.CanReferenceGlobalVariables

-[ RUN      ] ExpectNonfatalFailureTest.CanReferenceLocalVariables

-[       OK ] ExpectNonfatalFailureTest.CanReferenceLocalVariables

-[ RUN      ] ExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure

-[       OK ] ExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure

-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure

-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual: 2 failures

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure 1.

-

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure 2.

-

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures

-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure

-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementReturns

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns

-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementThrows

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementThrows

-[----------] 8 tests from ExpectFatalFailureTest

-[ RUN      ] ExpectFatalFailureTest.CanReferenceGlobalVariables

-[       OK ] ExpectFatalFailureTest.CanReferenceGlobalVariables

-[ RUN      ] ExpectFatalFailureTest.CanReferenceLocalStaticVariables

-[       OK ] ExpectFatalFailureTest.CanReferenceLocalStaticVariables

-[ RUN      ] ExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure

-[       OK ] ExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure

-[ RUN      ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure

-[ RUN      ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual: 2 failures

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures

-[ RUN      ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure.

-

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure

-[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementReturns

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns

-[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementThrows

-(expecting a failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementThrows

-[----------] 2 tests from TypedTest/0, where TypeParam = int

-[ RUN      ] TypedTest/0.Success

-[       OK ] TypedTest/0.Success

-[ RUN      ] TypedTest/0.Failure

-gtest_output_test_.cc:#: error: Value of: TypeParam()

-  Actual: 0

-Expected: 1

-Expected failure

-[  FAILED  ] TypedTest/0.Failure

-[----------] 2 tests from Unsigned/TypedTestP/0, where TypeParam = unsigned char

-[ RUN      ] Unsigned/TypedTestP/0.Success

-[       OK ] Unsigned/TypedTestP/0.Success

-[ RUN      ] Unsigned/TypedTestP/0.Failure

-gtest_output_test_.cc:#: error: Value of: TypeParam()

-  Actual: \0

-Expected: 1U

-Which is: 1

-Expected failure

-[  FAILED  ] Unsigned/TypedTestP/0.Failure

-[----------] 2 tests from Unsigned/TypedTestP/1, where TypeParam = unsigned int

-[ RUN      ] Unsigned/TypedTestP/1.Success

-[       OK ] Unsigned/TypedTestP/1.Success

-[ RUN      ] Unsigned/TypedTestP/1.Failure

-gtest_output_test_.cc:#: error: Value of: TypeParam()

-  Actual: 0

-Expected: 1U

-Which is: 1

-Expected failure

-[  FAILED  ] Unsigned/TypedTestP/1.Failure

-[----------] 4 tests from ExpectFailureTest

-[ RUN      ] ExpectFailureTest.ExpectFatalFailure

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Success:

-Succeeded

-

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure.

-

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 fatal failure containing "Some other fatal failure expected."

-  Actual:

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-[  FAILED  ] ExpectFailureTest.ExpectFatalFailure

-[ RUN      ] ExpectFailureTest.ExpectNonFatalFailure

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Success:

-Succeeded

-

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure containing "Some other non-fatal failure."

-  Actual:

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure.

-

-[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailure

-[ RUN      ] ExpectFailureTest.ExpectFatalFailureOnAllThreads

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Success:

-Succeeded

-

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure.

-

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 fatal failure containing "Some other fatal failure expected."

-  Actual:

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-[  FAILED  ] ExpectFailureTest.ExpectFatalFailureOnAllThreads

-[ RUN      ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Success:

-Succeeded

-

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-(expecting 1 failure)

-gtest.cc:#: error: Expected: 1 non-fatal failure containing "Some other non-fatal failure."

-  Actual:

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure.

-

-[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads

-[----------] Global test environment tear-down

-BarEnvironment::TearDown() called.

-gtest_output_test_.cc:#: error: Failed

-Expected non-fatal failure.

-FooEnvironment::TearDown() called.

-gtest_output_test_.cc:#: error: Failed

-Expected fatal failure.

-[==========] 61 tests from 27 test cases ran.

-[  PASSED  ] 21 tests.

-[  FAILED  ] 40 tests, listed below:

-[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine

-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine

-[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine

-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions

-[  FAILED  ] SCOPED_TRACETest.ObeysScopes

-[  FAILED  ] SCOPED_TRACETest.WorksInLoop

-[  FAILED  ] SCOPED_TRACETest.WorksInSubroutine

-[  FAILED  ] SCOPED_TRACETest.CanBeNested

-[  FAILED  ] SCOPED_TRACETest.CanBeRepeated

-[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor

-[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor

-[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp

-[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp

-[  FAILED  ] ExceptionInFixtureCtorTest.ExceptionInFixtureCtor

-[  FAILED  ] ExceptionInSetUpTest.ExceptionInSetUp

-[  FAILED  ] ExceptionInTestFunctionTest.SEH

-[  FAILED  ] ExceptionInTestFunctionTest.CppException

-[  FAILED  ] ExceptionInTearDownTest.ExceptionInTearDown

-[  FAILED  ] MixedUpTestCaseTest.ThisShouldFail

-[  FAILED  ] MixedUpTestCaseTest.ThisShouldFailToo

-[  FAILED  ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail

-[  FAILED  ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail

-[  FAILED  ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementThrows

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementThrows

-[  FAILED  ] TypedTest/0.Failure, where TypeParam = int

-[  FAILED  ] Unsigned/TypedTestP/0.Failure, where TypeParam = unsigned char

-[  FAILED  ] Unsigned/TypedTestP/1.Failure, where TypeParam = unsigned int

-[  FAILED  ] ExpectFailureTest.ExpectFatalFailure

-[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailure

-[  FAILED  ] ExpectFailureTest.ExpectFatalFailureOnAllThreads

-[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads

-

-40 FAILED TESTS

-  YOU HAVE 1 DISABLED TEST

-

-Note: Google Test filter = FatalFailureTest.*:LoggingTest.*

-[==========] Running 4 tests from 2 test cases.

-[----------] Global test environment set-up.

-[----------] 3 tests from FatalFailureTest

-[ RUN      ] FatalFailureTest.FatalFailureInSubroutine

-(expecting a failure that x should be 1)

-gtest_output_test_.cc:#: error: Value of: x

-  Actual: 2

-Expected: 1

-[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine (? ms)

-[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine

-(expecting a failure that x should be 1)

-gtest_output_test_.cc:#: error: Value of: x

-  Actual: 2

-Expected: 1

-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)

-[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine

-(expecting a failure on false)

-gtest_output_test_.cc:#: error: Value of: false

-  Actual: false

-Expected: true

-[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine (? ms)

-[----------] 3 tests from FatalFailureTest (? ms total)

-

-[----------] 1 test from LoggingTest

-[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions

-(expecting 2 failures on (3) >= (a[i]))

-i == 0

-i == 1

-gtest_output_test_.cc:#: error: Expected: (3) >= (a[i]), actual: 3 vs 9

-i == 2

-i == 3

-gtest_output_test_.cc:#: error: Expected: (3) >= (a[i]), actual: 3 vs 6

-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions (? ms)

-[----------] 1 test from LoggingTest (? ms total)

-

-[----------] Global test environment tear-down

-[==========] 4 tests from 2 test cases ran. (? ms total)

-[  PASSED  ] 0 tests.

-[  FAILED  ] 4 tests, listed below:

-[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine

-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine

-[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine

-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions

-

- 4 FAILED TESTS

-  YOU HAVE 1 DISABLED TEST

-

-Note: Google Test filter = *DISABLED_*

-[==========] Running 1 test from 1 test case.

-[----------] Global test environment set-up.

-[----------] 1 test from DisabledTestsWarningTest

-[ RUN      ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning

-[       OK ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning

-[----------] Global test environment tear-down

-[==========] 1 test from 1 test case ran.

-[  PASSED  ] 1 test.

-Note: Google Test filter = PassingTest.*

-Note: This is test shard 1 of 2.

-[==========] Running 1 test from 1 test case.

-[----------] Global test environment set-up.

-[----------] 1 test from PassingTest

-[ RUN      ] PassingTest.PassingTest2

-[       OK ] PassingTest.PassingTest2

-[----------] Global test environment tear-down

-[==========] 1 test from 1 test case ran.

-[  PASSED  ] 1 test.

-

-  YOU HAVE 1 DISABLED TEST

-

+The non-test part of the code is expected to have 2 failures.
+
+gtest_output_test_.cc:#: error: Value of: false
+  Actual: false
+Expected: true
+gtest_output_test_.cc:#: error: Value of: 3
+Expected: 2
+[==========] Running 61 tests from 27 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
+[ RUN      ] PassingTest.PassingTest2
+[       OK ] PassingTest.PassingTest2
+[----------] 3 tests from FatalFailureTest
+[ RUN      ] FatalFailureTest.FatalFailureInSubroutine
+(expecting a failure that x should be 1)
+gtest_output_test_.cc:#: error: Value of: x
+  Actual: 2
+Expected: 1
+[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
+[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine
+(expecting a failure that x should be 1)
+gtest_output_test_.cc:#: error: Value of: x
+  Actual: 2
+Expected: 1
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
+[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
+(expecting a failure on false)
+gtest_output_test_.cc:#: error: Value of: false
+  Actual: false
+Expected: true
+[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
+[----------] 1 test from LoggingTest
+[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions
+(expecting 2 failures on (3) >= (a[i]))
+i == 0
+i == 1
+gtest_output_test_.cc:#: error: Expected: (3) >= (a[i]), actual: 3 vs 9
+i == 2
+i == 3
+gtest_output_test_.cc:#: error: Expected: (3) >= (a[i]), actual: 3 vs 6
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
+[----------] 5 tests from SCOPED_TRACETest
+[ RUN      ] SCOPED_TRACETest.ObeysScopes
+(expected to fail)
+gtest_output_test_.cc:#: error: Failed
+This failure is expected, and shouldn't have a trace.
+gtest_output_test_.cc:#: error: Failed
+This failure is expected, and should have a trace.
+Google Test trace:
+gtest_output_test_.cc:#: Expected trace
+gtest_output_test_.cc:#: error: Failed
+This failure is expected, and shouldn't have a trace.
+[  FAILED  ] SCOPED_TRACETest.ObeysScopes
+[ RUN      ] SCOPED_TRACETest.WorksInLoop
+(expected to fail)
+gtest_output_test_.cc:#: error: Value of: n
+  Actual: 1
+Expected: 2
+Google Test trace:
+gtest_output_test_.cc:#: i = 1
+gtest_output_test_.cc:#: error: Value of: n
+  Actual: 2
+Expected: 1
+Google Test trace:
+gtest_output_test_.cc:#: i = 2
+[  FAILED  ] SCOPED_TRACETest.WorksInLoop
+[ RUN      ] SCOPED_TRACETest.WorksInSubroutine
+(expected to fail)
+gtest_output_test_.cc:#: error: Value of: n
+  Actual: 1
+Expected: 2
+Google Test trace:
+gtest_output_test_.cc:#: n = 1
+gtest_output_test_.cc:#: error: Value of: n
+  Actual: 2
+Expected: 1
+Google Test trace:
+gtest_output_test_.cc:#: n = 2
+[  FAILED  ] SCOPED_TRACETest.WorksInSubroutine
+[ RUN      ] SCOPED_TRACETest.CanBeNested
+(expected to fail)
+gtest_output_test_.cc:#: error: Value of: n
+  Actual: 2
+Expected: 1
+Google Test trace:
+gtest_output_test_.cc:#: n = 2
+gtest_output_test_.cc:#: 
+[  FAILED  ] SCOPED_TRACETest.CanBeNested
+[ RUN      ] SCOPED_TRACETest.CanBeRepeated
+(expected to fail)
+gtest_output_test_.cc:#: error: Failed
+This failure is expected, and should contain trace point A.
+Google Test trace:
+gtest_output_test_.cc:#: A
+gtest_output_test_.cc:#: error: Failed
+This failure is expected, and should contain trace point A and B.
+Google Test trace:
+gtest_output_test_.cc:#: B
+gtest_output_test_.cc:#: A
+gtest_output_test_.cc:#: error: Failed
+This failure is expected, and should contain trace point A, B, and C.
+Google Test trace:
+gtest_output_test_.cc:#: C
+gtest_output_test_.cc:#: B
+gtest_output_test_.cc:#: A
+gtest_output_test_.cc:#: error: Failed
+This failure is expected, and should contain trace point A, B, and D.
+Google Test trace:
+gtest_output_test_.cc:#: D
+gtest_output_test_.cc:#: B
+gtest_output_test_.cc:#: A
+[  FAILED  ] SCOPED_TRACETest.CanBeRepeated
+[----------] 1 test from NonFatalFailureInFixtureConstructorTest
+[ RUN      ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
+(expecting 5 failures)
+gtest_output_test_.cc:#: error: Failed
+Expected failure #1, in the test fixture c'tor.
+gtest_output_test_.cc:#: error: Failed
+Expected failure #2, in SetUp().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #3, in the test body.
+gtest_output_test_.cc:#: error: Failed
+Expected failure #4, in TearDown.
+gtest_output_test_.cc:#: error: Failed
+Expected failure #5, in the test fixture d'tor.
+[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
+[----------] 1 test from FatalFailureInFixtureConstructorTest
+[ RUN      ] FatalFailureInFixtureConstructorTest.FailureInConstructor
+(expecting 2 failures)
+gtest_output_test_.cc:#: error: Failed
+Expected failure #1, in the test fixture c'tor.
+gtest_output_test_.cc:#: error: Failed
+Expected failure #2, in the test fixture d'tor.
+[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor
+[----------] 1 test from NonFatalFailureInSetUpTest
+[ RUN      ] NonFatalFailureInSetUpTest.FailureInSetUp
+(expecting 4 failures)
+gtest_output_test_.cc:#: error: Failed
+Expected failure #1, in SetUp().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #2, in the test function.
+gtest_output_test_.cc:#: error: Failed
+Expected failure #3, in TearDown().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #4, in the test fixture d'tor.
+[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp
+[----------] 1 test from FatalFailureInSetUpTest
+[ RUN      ] FatalFailureInSetUpTest.FailureInSetUp
+(expecting 3 failures)
+gtest_output_test_.cc:#: error: Failed
+Expected failure #1, in SetUp().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #2, in TearDown().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #3, in the test fixture d'tor.
+[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp
+[----------] 1 test from ExceptionInFixtureCtorTest
+[ RUN      ] ExceptionInFixtureCtorTest.ExceptionInFixtureCtor
+(expecting a failure on thrown exception in the test fixture's constructor)
+unknown file: error: Exception thrown with code 0xc0000005 in the test fixture's constructor.
+[----------] 1 test from ExceptionInSetUpTest
+[ RUN      ] ExceptionInSetUpTest.ExceptionInSetUp
+(expecting 3 failures)
+unknown file: error: Exception thrown with code 0xc0000005 in SetUp().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #2, in TearDown().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #3, in the test fixture d'tor.
+[  FAILED  ] ExceptionInSetUpTest.ExceptionInSetUp
+[----------] 2 tests from ExceptionInTestFunctionTest
+[ RUN      ] ExceptionInTestFunctionTest.SEH
+(expecting 3 failures)
+unknown file: error: Exception thrown with code 0xc0000005 in the test body.
+gtest_output_test_.cc:#: error: Failed
+Expected failure #2, in TearDown().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #3, in the test fixture d'tor.
+[  FAILED  ] ExceptionInTestFunctionTest.SEH
+[ RUN      ] ExceptionInTestFunctionTest.CppException
+unknown file: error: Exception thrown with code 0xe06d7363 in the test body.
+gtest_output_test_.cc:#: error: Failed
+Expected failure #2, in TearDown().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #3, in the test fixture d'tor.
+[  FAILED  ] ExceptionInTestFunctionTest.CppException
+[----------] 1 test from ExceptionInTearDownTest
+[ RUN      ] ExceptionInTearDownTest.ExceptionInTearDown
+(expecting 2 failures)
+unknown file: error: Exception thrown with code 0xe06d7363 in TearDown().
+gtest_output_test_.cc:#: error: Failed
+Expected failure #2, in the test fixture d'tor.
+[  FAILED  ] ExceptionInTearDownTest.ExceptionInTearDown
+[----------] 4 tests from MixedUpTestCaseTest
+[ RUN      ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo
+[       OK ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo
+[ RUN      ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo
+[       OK ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo
+[ RUN      ] MixedUpTestCaseTest.ThisShouldFail
+gtest.cc:#: error: Failed
+All tests in the same test case must use the same test fixture
+class.  However, in test case MixedUpTestCaseTest,
+you defined test FirstTestFromNamespaceFoo and test ThisShouldFail
+using two different test fixture classes.  This can happen if
+the two classes are from different namespaces or translation
+units and have the same name.  You should probably rename one
+of the classes to put the tests into different test cases.
+[  FAILED  ] MixedUpTestCaseTest.ThisShouldFail
+[ RUN      ] MixedUpTestCaseTest.ThisShouldFailToo
+gtest.cc:#: error: Failed
+All tests in the same test case must use the same test fixture
+class.  However, in test case MixedUpTestCaseTest,
+you defined test FirstTestFromNamespaceFoo and test ThisShouldFailToo
+using two different test fixture classes.  This can happen if
+the two classes are from different namespaces or translation
+units and have the same name.  You should probably rename one
+of the classes to put the tests into different test cases.
+[  FAILED  ] MixedUpTestCaseTest.ThisShouldFailToo
+[----------] 2 tests from MixedUpTestCaseWithSameTestNameTest
+[ RUN      ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+[       OK ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+[ RUN      ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+gtest.cc:#: error: Failed
+All tests in the same test case must use the same test fixture
+class.  However, in test case MixedUpTestCaseWithSameTestNameTest,
+you defined test TheSecondTestWithThisNameShouldFail and test TheSecondTestWithThisNameShouldFail
+using two different test fixture classes.  This can happen if
+the two classes are from different namespaces or translation
+units and have the same name.  You should probably rename one
+of the classes to put the tests into different test cases.
+[  FAILED  ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+[----------] 2 tests from TEST_F_before_TEST_in_same_test_case
+[ RUN      ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
+[       OK ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
+[ RUN      ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
+gtest.cc:#: error: Failed
+All tests in the same test case must use the same test fixture
+class, so mixing TEST_F and TEST in the same test case is
+illegal.  In test case TEST_F_before_TEST_in_same_test_case,
+test DefinedUsingTEST_F is defined using TEST_F but
+test DefinedUsingTESTAndShouldFail is defined using TEST.  You probably
+want to change the TEST to TEST_F or move it to another test
+case.
+[  FAILED  ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
+[----------] 2 tests from TEST_before_TEST_F_in_same_test_case
+[ RUN      ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
+[       OK ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
+[ RUN      ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
+gtest.cc:#: error: Failed
+All tests in the same test case must use the same test fixture
+class, so mixing TEST_F and TEST in the same test case is
+illegal.  In test case TEST_before_TEST_F_in_same_test_case,
+test DefinedUsingTEST_FAndShouldFail is defined using TEST_F but
+test DefinedUsingTEST is defined using TEST.  You probably
+want to change the TEST to TEST_F or move it to another test
+case.
+[  FAILED  ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
+[----------] 8 tests from ExpectNonfatalFailureTest
+[ RUN      ] ExpectNonfatalFailureTest.CanReferenceGlobalVariables
+[       OK ] ExpectNonfatalFailureTest.CanReferenceGlobalVariables
+[ RUN      ] ExpectNonfatalFailureTest.CanReferenceLocalVariables
+[       OK ] ExpectNonfatalFailureTest.CanReferenceLocalVariables
+[ RUN      ] ExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
+[       OK ] ExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual: 2 failures
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure 1.
+
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure 2.
+
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
+[----------] 8 tests from ExpectFatalFailureTest
+[ RUN      ] ExpectFatalFailureTest.CanReferenceGlobalVariables
+[       OK ] ExpectFatalFailureTest.CanReferenceGlobalVariables
+[ RUN      ] ExpectFatalFailureTest.CanReferenceLocalStaticVariables
+[       OK ] ExpectFatalFailureTest.CanReferenceLocalStaticVariables
+[ RUN      ] ExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
+[       OK ] ExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
+[ RUN      ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
+[ RUN      ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual: 2 failures
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
+[ RUN      ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
+[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementReturns
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns
+[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementThrows
+(expecting a failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementThrows
+[----------] 2 tests from TypedTest/0, where TypeParam = int
+[ RUN      ] TypedTest/0.Success
+[       OK ] TypedTest/0.Success
+[ RUN      ] TypedTest/0.Failure
+gtest_output_test_.cc:#: error: Value of: TypeParam()
+  Actual: 0
+Expected: 1
+Expected failure
+[  FAILED  ] TypedTest/0.Failure
+[----------] 2 tests from Unsigned/TypedTestP/0, where TypeParam = unsigned char
+[ RUN      ] Unsigned/TypedTestP/0.Success
+[       OK ] Unsigned/TypedTestP/0.Success
+[ RUN      ] Unsigned/TypedTestP/0.Failure
+gtest_output_test_.cc:#: error: Value of: TypeParam()
+  Actual: \0
+Expected: 1U
+Which is: 1
+Expected failure
+[  FAILED  ] Unsigned/TypedTestP/0.Failure
+[----------] 2 tests from Unsigned/TypedTestP/1, where TypeParam = unsigned int
+[ RUN      ] Unsigned/TypedTestP/1.Success
+[       OK ] Unsigned/TypedTestP/1.Success
+[ RUN      ] Unsigned/TypedTestP/1.Failure
+gtest_output_test_.cc:#: error: Value of: TypeParam()
+  Actual: 0
+Expected: 1U
+Which is: 1
+Expected failure
+[  FAILED  ] Unsigned/TypedTestP/1.Failure
+[----------] 4 tests from ExpectFailureTest
+[ RUN      ] ExpectFailureTest.ExpectFatalFailure
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 fatal failure containing "Some other fatal failure expected."
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+[  FAILED  ] ExpectFailureTest.ExpectFatalFailure
+[ RUN      ] ExpectFailureTest.ExpectNonFatalFailure
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure containing "Some other non-fatal failure."
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailure
+[ RUN      ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 fatal failure containing "Some other fatal failure expected."
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+[  FAILED  ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
+[ RUN      ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: error: Expected: 1 non-fatal failure containing "Some other non-fatal failure."
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
+[----------] Global test environment tear-down
+BarEnvironment::TearDown() called.
+gtest_output_test_.cc:#: error: Failed
+Expected non-fatal failure.
+FooEnvironment::TearDown() called.
+gtest_output_test_.cc:#: error: Failed
+Expected fatal failure.
+[==========] 61 tests from 27 test cases ran.
+[  PASSED  ] 21 tests.
+[  FAILED  ] 40 tests, listed below:
+[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
+[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
+[  FAILED  ] SCOPED_TRACETest.ObeysScopes
+[  FAILED  ] SCOPED_TRACETest.WorksInLoop
+[  FAILED  ] SCOPED_TRACETest.WorksInSubroutine
+[  FAILED  ] SCOPED_TRACETest.CanBeNested
+[  FAILED  ] SCOPED_TRACETest.CanBeRepeated
+[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
+[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor
+[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp
+[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp
+[  FAILED  ] ExceptionInFixtureCtorTest.ExceptionInFixtureCtor
+[  FAILED  ] ExceptionInSetUpTest.ExceptionInSetUp
+[  FAILED  ] ExceptionInTestFunctionTest.SEH
+[  FAILED  ] ExceptionInTestFunctionTest.CppException
+[  FAILED  ] ExceptionInTearDownTest.ExceptionInTearDown
+[  FAILED  ] MixedUpTestCaseTest.ThisShouldFail
+[  FAILED  ] MixedUpTestCaseTest.ThisShouldFailToo
+[  FAILED  ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+[  FAILED  ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
+[  FAILED  ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementThrows
+[  FAILED  ] TypedTest/0.Failure, where TypeParam = int
+[  FAILED  ] Unsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
+[  FAILED  ] Unsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
+[  FAILED  ] ExpectFailureTest.ExpectFatalFailure
+[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailure
+[  FAILED  ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
+[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
+
+40 FAILED TESTS
+  YOU HAVE 1 DISABLED TEST
+
+Note: Google Test filter = FatalFailureTest.*:LoggingTest.*
+[==========] Running 4 tests from 2 test cases.
+[----------] Global test environment set-up.
+[----------] 3 tests from FatalFailureTest
+[ RUN      ] FatalFailureTest.FatalFailureInSubroutine
+(expecting a failure that x should be 1)
+gtest_output_test_.cc:#: error: Value of: x
+  Actual: 2
+Expected: 1
+[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine (? ms)
+[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine
+(expecting a failure that x should be 1)
+gtest_output_test_.cc:#: error: Value of: x
+  Actual: 2
+Expected: 1
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)
+[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
+(expecting a failure on false)
+gtest_output_test_.cc:#: error: Value of: false
+  Actual: false
+Expected: true
+[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine (? ms)
+[----------] 3 tests from FatalFailureTest (? ms total)
+
+[----------] 1 test from LoggingTest
+[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions
+(expecting 2 failures on (3) >= (a[i]))
+i == 0
+i == 1
+gtest_output_test_.cc:#: error: Expected: (3) >= (a[i]), actual: 3 vs 9
+i == 2
+i == 3
+gtest_output_test_.cc:#: error: Expected: (3) >= (a[i]), actual: 3 vs 6
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions (? ms)
+[----------] 1 test from LoggingTest (? ms total)
+
+[----------] Global test environment tear-down
+[==========] 4 tests from 2 test cases ran. (? ms total)
+[  PASSED  ] 0 tests.
+[  FAILED  ] 4 tests, listed below:
+[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
+[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
+
+ 4 FAILED TESTS
+  YOU HAVE 1 DISABLED TEST
+
+Note: Google Test filter = *DISABLED_*
+[==========] Running 1 test from 1 test case.
+[----------] Global test environment set-up.
+[----------] 1 test from DisabledTestsWarningTest
+[ RUN      ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
+[       OK ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
+[----------] Global test environment tear-down
+[==========] 1 test from 1 test case ran.
+[  PASSED  ] 1 test.
+Note: Google Test filter = PassingTest.*
+Note: This is test shard 1 of 2.
+[==========] Running 1 test from 1 test case.
+[----------] Global test environment set-up.
+[----------] 1 test from PassingTest
+[ RUN      ] PassingTest.PassingTest2
+[       OK ] PassingTest.PassingTest2
+[----------] Global test environment tear-down
+[==========] 1 test from 1 test case ran.
+[  PASSED  ] 1 test.
+
+  YOU HAVE 1 DISABLED TEST
+
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_pred_impl_unittest.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_pred_impl_unittest.cc
index 89486175..e7ee54b5 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_pred_impl_unittest.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_pred_impl_unittest.cc
@@ -1,2432 +1,2432 @@
-// Copyright 2006, 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.

-

-// This file is AUTOMATICALLY GENERATED on 10/02/2008 by command

-// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!

-

-// Regression test for gtest_pred_impl.h

-//

-// This file is generated by a script and quite long.  If you intend to

-// learn how Google Test works by reading its unit tests, read

-// gtest_unittest.cc instead.

-//

-// This is intended as a regression test for the Google Test predicate

-// assertions.  We compile it as part of the gtest_unittest target

-// only to keep the implementation tidy and compact, as it is quite

-// involved to set up the stage for testing Google Test using Google

-// Test itself.

-//

-// Currently, gtest_unittest takes ~11 seconds to run in the testing

-// daemon.  In the future, if it grows too large and needs much more

-// time to finish, we should consider separating this file into a

-// stand-alone regression test.

-

-#include <iostream>

-

-#include <gtest/gtest.h>

-#include <gtest/gtest-spi.h>

-

-// A user-defined data type.

-struct Bool {

-  explicit Bool(int val) : value(val != 0) {}

-

-  bool operator>(int n) const { return value > Bool(n).value; }

-

-  Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }

-

-  bool operator==(const Bool& rhs) const { return value == rhs.value; }

-

-  bool value;

-};

-

-// Enables Bool to be used in assertions.

-std::ostream& operator<<(std::ostream& os, const Bool& x) {

-  return os << (x.value ? "true" : "false");

-}

-

-// Sample functions/functors for testing unary predicate assertions.

-

-// A unary predicate function.

-template <typename T1>

-bool PredFunction1(T1 v1) {

-  return v1 > 0;

-}

-

-// The following two functions are needed to circumvent a bug in

-// gcc 2.95.3, which sometimes has problem with the above template

-// function.

-bool PredFunction1Int(int v1) {

-  return v1 > 0;

-}

-bool PredFunction1Bool(Bool v1) {

-  return v1 > 0;

-}

-

-// A unary predicate functor.

-struct PredFunctor1 {

-  template <typename T1>

-  bool operator()(const T1& v1) {

-    return v1 > 0;

-  }

-};

-

-// A unary predicate-formatter function.

-template <typename T1>

-testing::AssertionResult PredFormatFunction1(const char* e1,

-                                             const T1& v1) {

-  if (PredFunction1(v1))

-    return testing::AssertionSuccess();

-

-  testing::Message msg;

-  msg << e1

-      << " is expected to be positive, but evaluates to "

-      << v1 << ".";

-  return testing::AssertionFailure(msg);

-}

-

-// A unary predicate-formatter functor.

-struct PredFormatFunctor1 {

-  template <typename T1>

-  testing::AssertionResult operator()(const char* e1,

-                                      const T1& v1) const {

-    return PredFormatFunction1(e1, v1);

-  }

-};

-

-// Tests for {EXPECT|ASSERT}_PRED_FORMAT1.

-

-class Predicate1Test : public testing::Test {

- protected:

-  virtual void SetUp() {

-    expected_to_finish_ = true;

-    finished_ = false;

-    n1_ = 0;

-  }

-

-  virtual void TearDown() {

-    // Verifies that each of the predicate's arguments was evaluated

-    // exactly once.

-    EXPECT_EQ(1, n1_) <<

-        "The predicate assertion didn't evaluate argument 2 "

-        "exactly once.";

-

-    // Verifies that the control flow in the test function is expected.

-    if (expected_to_finish_ && !finished_) {

-      FAIL() << "The predicate assertion unexpactedly aborted the test.";

-    } else if (!expected_to_finish_ && finished_) {

-      FAIL() << "The failed predicate assertion didn't abort the test "

-                "as expected.";

-    }

-  }

-

-  // true iff the test function is expected to run to finish.

-  static bool expected_to_finish_;

-

-  // true iff the test function did run to finish.

-  static bool finished_;

-

-  static int n1_;

-};

-

-bool Predicate1Test::expected_to_finish_;

-bool Predicate1Test::finished_;

-int Predicate1Test::n1_;

-

-typedef Predicate1Test EXPECT_PRED_FORMAT1Test;

-typedef Predicate1Test ASSERT_PRED_FORMAT1Test;

-typedef Predicate1Test EXPECT_PRED1Test;

-typedef Predicate1Test ASSERT_PRED1Test;

-

-// Tests a successful EXPECT_PRED1 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED1(PredFunction1Int,

-               ++n1_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED1 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED1(PredFunction1Bool,

-               Bool(++n1_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED1 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED1(PredFunctor1(),

-               ++n1_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED1 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED1(PredFunctor1(),

-               Bool(++n1_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED1 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED1(PredFunction1Int,

-                 n1_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED1 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED1(PredFunction1Bool,

-                 Bool(n1_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED1 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED1(PredFunctor1(),

-                 n1_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED1 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED1(PredFunctor1(),

-                 Bool(n1_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED1 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED1(PredFunction1Int,

-               ++n1_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED1 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED1(PredFunction1Bool,

-               Bool(++n1_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED1 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED1(PredFunctor1(),

-               ++n1_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED1 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED1(PredFunctor1(),

-               Bool(++n1_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED1 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED1(PredFunction1Int,

-                 n1_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED1 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED1(PredFunction1Bool,

-                 Bool(n1_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED1 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED1(PredFunctor1(),

-                 n1_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED1 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED1(PredFunctor1(),

-                 Bool(n1_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful EXPECT_PRED_FORMAT1 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT1(PredFormatFunction1,

-                      ++n1_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT1 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT1(PredFormatFunction1,

-                      Bool(++n1_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT1 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),

-                      ++n1_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT1 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),

-                      Bool(++n1_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED_FORMAT1 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT1(PredFormatFunction1,

-                        n1_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT1 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT1(PredFormatFunction1,

-                        Bool(n1_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT1 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),

-                        n1_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT1 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),

-                        Bool(n1_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED_FORMAT1 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT1(PredFormatFunction1,

-                      ++n1_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT1 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT1(PredFormatFunction1,

-                      Bool(++n1_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT1 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),

-                      ++n1_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT1 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),

-                      Bool(++n1_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED_FORMAT1 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT1(PredFormatFunction1,

-                        n1_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT1 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT1(PredFormatFunction1,

-                        Bool(n1_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT1 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),

-                        n1_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT1 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),

-                        Bool(n1_++));

-    finished_ = true;

-  }, "");

-}

-// Sample functions/functors for testing binary predicate assertions.

-

-// A binary predicate function.

-template <typename T1, typename T2>

-bool PredFunction2(T1 v1, T2 v2) {

-  return v1 + v2 > 0;

-}

-

-// The following two functions are needed to circumvent a bug in

-// gcc 2.95.3, which sometimes has problem with the above template

-// function.

-bool PredFunction2Int(int v1, int v2) {

-  return v1 + v2 > 0;

-}

-bool PredFunction2Bool(Bool v1, Bool v2) {

-  return v1 + v2 > 0;

-}

-

-// A binary predicate functor.

-struct PredFunctor2 {

-  template <typename T1, typename T2>

-  bool operator()(const T1& v1,

-                  const T2& v2) {

-    return v1 + v2 > 0;

-  }

-};

-

-// A binary predicate-formatter function.

-template <typename T1, typename T2>

-testing::AssertionResult PredFormatFunction2(const char* e1,

-                                             const char* e2,

-                                             const T1& v1,

-                                             const T2& v2) {

-  if (PredFunction2(v1, v2))

-    return testing::AssertionSuccess();

-

-  testing::Message msg;

-  msg << e1 << " + " << e2

-      << " is expected to be positive, but evaluates to "

-      << v1 + v2 << ".";

-  return testing::AssertionFailure(msg);

-}

-

-// A binary predicate-formatter functor.

-struct PredFormatFunctor2 {

-  template <typename T1, typename T2>

-  testing::AssertionResult operator()(const char* e1,

-                                      const char* e2,

-                                      const T1& v1,

-                                      const T2& v2) const {

-    return PredFormatFunction2(e1, e2, v1, v2);

-  }

-};

-

-// Tests for {EXPECT|ASSERT}_PRED_FORMAT2.

-

-class Predicate2Test : public testing::Test {

- protected:

-  virtual void SetUp() {

-    expected_to_finish_ = true;

-    finished_ = false;

-    n1_ = n2_ = 0;

-  }

-

-  virtual void TearDown() {

-    // Verifies that each of the predicate's arguments was evaluated

-    // exactly once.

-    EXPECT_EQ(1, n1_) <<

-        "The predicate assertion didn't evaluate argument 2 "

-        "exactly once.";

-    EXPECT_EQ(1, n2_) <<

-        "The predicate assertion didn't evaluate argument 3 "

-        "exactly once.";

-

-    // Verifies that the control flow in the test function is expected.

-    if (expected_to_finish_ && !finished_) {

-      FAIL() << "The predicate assertion unexpactedly aborted the test.";

-    } else if (!expected_to_finish_ && finished_) {

-      FAIL() << "The failed predicate assertion didn't abort the test "

-                "as expected.";

-    }

-  }

-

-  // true iff the test function is expected to run to finish.

-  static bool expected_to_finish_;

-

-  // true iff the test function did run to finish.

-  static bool finished_;

-

-  static int n1_;

-  static int n2_;

-};

-

-bool Predicate2Test::expected_to_finish_;

-bool Predicate2Test::finished_;

-int Predicate2Test::n1_;

-int Predicate2Test::n2_;

-

-typedef Predicate2Test EXPECT_PRED_FORMAT2Test;

-typedef Predicate2Test ASSERT_PRED_FORMAT2Test;

-typedef Predicate2Test EXPECT_PRED2Test;

-typedef Predicate2Test ASSERT_PRED2Test;

-

-// Tests a successful EXPECT_PRED2 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED2(PredFunction2Int,

-               ++n1_,

-               ++n2_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED2 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED2(PredFunction2Bool,

-               Bool(++n1_),

-               Bool(++n2_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED2 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED2(PredFunctor2(),

-               ++n1_,

-               ++n2_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED2 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED2(PredFunctor2(),

-               Bool(++n1_),

-               Bool(++n2_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED2 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED2(PredFunction2Int,

-                 n1_++,

-                 n2_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED2 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED2(PredFunction2Bool,

-                 Bool(n1_++),

-                 Bool(n2_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED2 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED2(PredFunctor2(),

-                 n1_++,

-                 n2_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED2 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED2(PredFunctor2(),

-                 Bool(n1_++),

-                 Bool(n2_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED2 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED2(PredFunction2Int,

-               ++n1_,

-               ++n2_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED2 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED2(PredFunction2Bool,

-               Bool(++n1_),

-               Bool(++n2_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED2 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED2(PredFunctor2(),

-               ++n1_,

-               ++n2_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED2 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED2(PredFunctor2(),

-               Bool(++n1_),

-               Bool(++n2_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED2 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED2(PredFunction2Int,

-                 n1_++,

-                 n2_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED2 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED2(PredFunction2Bool,

-                 Bool(n1_++),

-                 Bool(n2_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED2 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED2(PredFunctor2(),

-                 n1_++,

-                 n2_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED2 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED2(PredFunctor2(),

-                 Bool(n1_++),

-                 Bool(n2_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful EXPECT_PRED_FORMAT2 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT2(PredFormatFunction2,

-                      ++n1_,

-                      ++n2_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT2 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT2(PredFormatFunction2,

-                      Bool(++n1_),

-                      Bool(++n2_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT2 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),

-                      ++n1_,

-                      ++n2_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT2 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),

-                      Bool(++n1_),

-                      Bool(++n2_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED_FORMAT2 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(PredFormatFunction2,

-                        n1_++,

-                        n2_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT2 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(PredFormatFunction2,

-                        Bool(n1_++),

-                        Bool(n2_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT2 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),

-                        n1_++,

-                        n2_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT2 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),

-                        Bool(n1_++),

-                        Bool(n2_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED_FORMAT2 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT2(PredFormatFunction2,

-                      ++n1_,

-                      ++n2_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT2 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT2(PredFormatFunction2,

-                      Bool(++n1_),

-                      Bool(++n2_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT2 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),

-                      ++n1_,

-                      ++n2_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT2 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),

-                      Bool(++n1_),

-                      Bool(++n2_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED_FORMAT2 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT2(PredFormatFunction2,

-                        n1_++,

-                        n2_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT2 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT2(PredFormatFunction2,

-                        Bool(n1_++),

-                        Bool(n2_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT2 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),

-                        n1_++,

-                        n2_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT2 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),

-                        Bool(n1_++),

-                        Bool(n2_++));

-    finished_ = true;

-  }, "");

-}

-// Sample functions/functors for testing ternary predicate assertions.

-

-// A ternary predicate function.

-template <typename T1, typename T2, typename T3>

-bool PredFunction3(T1 v1, T2 v2, T3 v3) {

-  return v1 + v2 + v3 > 0;

-}

-

-// The following two functions are needed to circumvent a bug in

-// gcc 2.95.3, which sometimes has problem with the above template

-// function.

-bool PredFunction3Int(int v1, int v2, int v3) {

-  return v1 + v2 + v3 > 0;

-}

-bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) {

-  return v1 + v2 + v3 > 0;

-}

-

-// A ternary predicate functor.

-struct PredFunctor3 {

-  template <typename T1, typename T2, typename T3>

-  bool operator()(const T1& v1,

-                  const T2& v2,

-                  const T3& v3) {

-    return v1 + v2 + v3 > 0;

-  }

-};

-

-// A ternary predicate-formatter function.

-template <typename T1, typename T2, typename T3>

-testing::AssertionResult PredFormatFunction3(const char* e1,

-                                             const char* e2,

-                                             const char* e3,

-                                             const T1& v1,

-                                             const T2& v2,

-                                             const T3& v3) {

-  if (PredFunction3(v1, v2, v3))

-    return testing::AssertionSuccess();

-

-  testing::Message msg;

-  msg << e1 << " + " << e2 << " + " << e3

-      << " is expected to be positive, but evaluates to "

-      << v1 + v2 + v3 << ".";

-  return testing::AssertionFailure(msg);

-}

-

-// A ternary predicate-formatter functor.

-struct PredFormatFunctor3 {

-  template <typename T1, typename T2, typename T3>

-  testing::AssertionResult operator()(const char* e1,

-                                      const char* e2,

-                                      const char* e3,

-                                      const T1& v1,

-                                      const T2& v2,

-                                      const T3& v3) const {

-    return PredFormatFunction3(e1, e2, e3, v1, v2, v3);

-  }

-};

-

-// Tests for {EXPECT|ASSERT}_PRED_FORMAT3.

-

-class Predicate3Test : public testing::Test {

- protected:

-  virtual void SetUp() {

-    expected_to_finish_ = true;

-    finished_ = false;

-    n1_ = n2_ = n3_ = 0;

-  }

-

-  virtual void TearDown() {

-    // Verifies that each of the predicate's arguments was evaluated

-    // exactly once.

-    EXPECT_EQ(1, n1_) <<

-        "The predicate assertion didn't evaluate argument 2 "

-        "exactly once.";

-    EXPECT_EQ(1, n2_) <<

-        "The predicate assertion didn't evaluate argument 3 "

-        "exactly once.";

-    EXPECT_EQ(1, n3_) <<

-        "The predicate assertion didn't evaluate argument 4 "

-        "exactly once.";

-

-    // Verifies that the control flow in the test function is expected.

-    if (expected_to_finish_ && !finished_) {

-      FAIL() << "The predicate assertion unexpactedly aborted the test.";

-    } else if (!expected_to_finish_ && finished_) {

-      FAIL() << "The failed predicate assertion didn't abort the test "

-                "as expected.";

-    }

-  }

-

-  // true iff the test function is expected to run to finish.

-  static bool expected_to_finish_;

-

-  // true iff the test function did run to finish.

-  static bool finished_;

-

-  static int n1_;

-  static int n2_;

-  static int n3_;

-};

-

-bool Predicate3Test::expected_to_finish_;

-bool Predicate3Test::finished_;

-int Predicate3Test::n1_;

-int Predicate3Test::n2_;

-int Predicate3Test::n3_;

-

-typedef Predicate3Test EXPECT_PRED_FORMAT3Test;

-typedef Predicate3Test ASSERT_PRED_FORMAT3Test;

-typedef Predicate3Test EXPECT_PRED3Test;

-typedef Predicate3Test ASSERT_PRED3Test;

-

-// Tests a successful EXPECT_PRED3 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED3(PredFunction3Int,

-               ++n1_,

-               ++n2_,

-               ++n3_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED3 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED3(PredFunction3Bool,

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED3 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED3(PredFunctor3(),

-               ++n1_,

-               ++n2_,

-               ++n3_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED3 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED3(PredFunctor3(),

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED3 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED3(PredFunction3Int,

-                 n1_++,

-                 n2_++,

-                 n3_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED3 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED3(PredFunction3Bool,

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED3 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED3(PredFunctor3(),

-                 n1_++,

-                 n2_++,

-                 n3_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED3 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED3(PredFunctor3(),

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED3 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED3(PredFunction3Int,

-               ++n1_,

-               ++n2_,

-               ++n3_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED3 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED3(PredFunction3Bool,

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED3 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED3(PredFunctor3(),

-               ++n1_,

-               ++n2_,

-               ++n3_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED3 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED3(PredFunctor3(),

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED3 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED3(PredFunction3Int,

-                 n1_++,

-                 n2_++,

-                 n3_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED3 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED3(PredFunction3Bool,

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED3 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED3(PredFunctor3(),

-                 n1_++,

-                 n2_++,

-                 n3_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED3 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED3(PredFunctor3(),

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful EXPECT_PRED_FORMAT3 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT3(PredFormatFunction3,

-                      ++n1_,

-                      ++n2_,

-                      ++n3_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT3 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT3(PredFormatFunction3,

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT3 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),

-                      ++n1_,

-                      ++n2_,

-                      ++n3_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT3 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED_FORMAT3 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT3(PredFormatFunction3,

-                        n1_++,

-                        n2_++,

-                        n3_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT3 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT3(PredFormatFunction3,

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT3 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),

-                        n1_++,

-                        n2_++,

-                        n3_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT3 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED_FORMAT3 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT3(PredFormatFunction3,

-                      ++n1_,

-                      ++n2_,

-                      ++n3_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT3 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT3(PredFormatFunction3,

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT3 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),

-                      ++n1_,

-                      ++n2_,

-                      ++n3_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT3 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED_FORMAT3 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT3(PredFormatFunction3,

-                        n1_++,

-                        n2_++,

-                        n3_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT3 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT3(PredFormatFunction3,

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT3 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),

-                        n1_++,

-                        n2_++,

-                        n3_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT3 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++));

-    finished_ = true;

-  }, "");

-}

-// Sample functions/functors for testing 4-ary predicate assertions.

-

-// A 4-ary predicate function.

-template <typename T1, typename T2, typename T3, typename T4>

-bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {

-  return v1 + v2 + v3 + v4 > 0;

-}

-

-// The following two functions are needed to circumvent a bug in

-// gcc 2.95.3, which sometimes has problem with the above template

-// function.

-bool PredFunction4Int(int v1, int v2, int v3, int v4) {

-  return v1 + v2 + v3 + v4 > 0;

-}

-bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {

-  return v1 + v2 + v3 + v4 > 0;

-}

-

-// A 4-ary predicate functor.

-struct PredFunctor4 {

-  template <typename T1, typename T2, typename T3, typename T4>

-  bool operator()(const T1& v1,

-                  const T2& v2,

-                  const T3& v3,

-                  const T4& v4) {

-    return v1 + v2 + v3 + v4 > 0;

-  }

-};

-

-// A 4-ary predicate-formatter function.

-template <typename T1, typename T2, typename T3, typename T4>

-testing::AssertionResult PredFormatFunction4(const char* e1,

-                                             const char* e2,

-                                             const char* e3,

-                                             const char* e4,

-                                             const T1& v1,

-                                             const T2& v2,

-                                             const T3& v3,

-                                             const T4& v4) {

-  if (PredFunction4(v1, v2, v3, v4))

-    return testing::AssertionSuccess();

-

-  testing::Message msg;

-  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4

-      << " is expected to be positive, but evaluates to "

-      << v1 + v2 + v3 + v4 << ".";

-  return testing::AssertionFailure(msg);

-}

-

-// A 4-ary predicate-formatter functor.

-struct PredFormatFunctor4 {

-  template <typename T1, typename T2, typename T3, typename T4>

-  testing::AssertionResult operator()(const char* e1,

-                                      const char* e2,

-                                      const char* e3,

-                                      const char* e4,

-                                      const T1& v1,

-                                      const T2& v2,

-                                      const T3& v3,

-                                      const T4& v4) const {

-    return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);

-  }

-};

-

-// Tests for {EXPECT|ASSERT}_PRED_FORMAT4.

-

-class Predicate4Test : public testing::Test {

- protected:

-  virtual void SetUp() {

-    expected_to_finish_ = true;

-    finished_ = false;

-    n1_ = n2_ = n3_ = n4_ = 0;

-  }

-

-  virtual void TearDown() {

-    // Verifies that each of the predicate's arguments was evaluated

-    // exactly once.

-    EXPECT_EQ(1, n1_) <<

-        "The predicate assertion didn't evaluate argument 2 "

-        "exactly once.";

-    EXPECT_EQ(1, n2_) <<

-        "The predicate assertion didn't evaluate argument 3 "

-        "exactly once.";

-    EXPECT_EQ(1, n3_) <<

-        "The predicate assertion didn't evaluate argument 4 "

-        "exactly once.";

-    EXPECT_EQ(1, n4_) <<

-        "The predicate assertion didn't evaluate argument 5 "

-        "exactly once.";

-

-    // Verifies that the control flow in the test function is expected.

-    if (expected_to_finish_ && !finished_) {

-      FAIL() << "The predicate assertion unexpactedly aborted the test.";

-    } else if (!expected_to_finish_ && finished_) {

-      FAIL() << "The failed predicate assertion didn't abort the test "

-                "as expected.";

-    }

-  }

-

-  // true iff the test function is expected to run to finish.

-  static bool expected_to_finish_;

-

-  // true iff the test function did run to finish.

-  static bool finished_;

-

-  static int n1_;

-  static int n2_;

-  static int n3_;

-  static int n4_;

-};

-

-bool Predicate4Test::expected_to_finish_;

-bool Predicate4Test::finished_;

-int Predicate4Test::n1_;

-int Predicate4Test::n2_;

-int Predicate4Test::n3_;

-int Predicate4Test::n4_;

-

-typedef Predicate4Test EXPECT_PRED_FORMAT4Test;

-typedef Predicate4Test ASSERT_PRED_FORMAT4Test;

-typedef Predicate4Test EXPECT_PRED4Test;

-typedef Predicate4Test ASSERT_PRED4Test;

-

-// Tests a successful EXPECT_PRED4 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED4(PredFunction4Int,

-               ++n1_,

-               ++n2_,

-               ++n3_,

-               ++n4_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED4 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED4(PredFunction4Bool,

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_),

-               Bool(++n4_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED4 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED4(PredFunctor4(),

-               ++n1_,

-               ++n2_,

-               ++n3_,

-               ++n4_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED4 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED4(PredFunctor4(),

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_),

-               Bool(++n4_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED4 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED4(PredFunction4Int,

-                 n1_++,

-                 n2_++,

-                 n3_++,

-                 n4_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED4 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED4(PredFunction4Bool,

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++),

-                 Bool(n4_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED4 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED4(PredFunctor4(),

-                 n1_++,

-                 n2_++,

-                 n3_++,

-                 n4_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED4 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED4(PredFunctor4(),

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++),

-                 Bool(n4_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED4 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED4(PredFunction4Int,

-               ++n1_,

-               ++n2_,

-               ++n3_,

-               ++n4_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED4 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED4(PredFunction4Bool,

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_),

-               Bool(++n4_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED4 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED4(PredFunctor4(),

-               ++n1_,

-               ++n2_,

-               ++n3_,

-               ++n4_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED4 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED4(PredFunctor4(),

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_),

-               Bool(++n4_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED4 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED4(PredFunction4Int,

-                 n1_++,

-                 n2_++,

-                 n3_++,

-                 n4_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED4 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED4(PredFunction4Bool,

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++),

-                 Bool(n4_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED4 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED4(PredFunctor4(),

-                 n1_++,

-                 n2_++,

-                 n3_++,

-                 n4_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED4 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED4(PredFunctor4(),

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++),

-                 Bool(n4_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful EXPECT_PRED_FORMAT4 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT4(PredFormatFunction4,

-                      ++n1_,

-                      ++n2_,

-                      ++n3_,

-                      ++n4_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT4 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT4(PredFormatFunction4,

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_),

-                      Bool(++n4_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT4 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),

-                      ++n1_,

-                      ++n2_,

-                      ++n3_,

-                      ++n4_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT4 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_),

-                      Bool(++n4_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED_FORMAT4 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT4(PredFormatFunction4,

-                        n1_++,

-                        n2_++,

-                        n3_++,

-                        n4_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT4 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT4(PredFormatFunction4,

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++),

-                        Bool(n4_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT4 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),

-                        n1_++,

-                        n2_++,

-                        n3_++,

-                        n4_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT4 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++),

-                        Bool(n4_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED_FORMAT4 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT4(PredFormatFunction4,

-                      ++n1_,

-                      ++n2_,

-                      ++n3_,

-                      ++n4_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT4 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT4(PredFormatFunction4,

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_),

-                      Bool(++n4_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT4 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),

-                      ++n1_,

-                      ++n2_,

-                      ++n3_,

-                      ++n4_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT4 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_),

-                      Bool(++n4_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED_FORMAT4 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT4(PredFormatFunction4,

-                        n1_++,

-                        n2_++,

-                        n3_++,

-                        n4_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT4 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT4(PredFormatFunction4,

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++),

-                        Bool(n4_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT4 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),

-                        n1_++,

-                        n2_++,

-                        n3_++,

-                        n4_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT4 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++),

-                        Bool(n4_++));

-    finished_ = true;

-  }, "");

-}

-// Sample functions/functors for testing 5-ary predicate assertions.

-

-// A 5-ary predicate function.

-template <typename T1, typename T2, typename T3, typename T4, typename T5>

-bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {

-  return v1 + v2 + v3 + v4 + v5 > 0;

-}

-

-// The following two functions are needed to circumvent a bug in

-// gcc 2.95.3, which sometimes has problem with the above template

-// function.

-bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {

-  return v1 + v2 + v3 + v4 + v5 > 0;

-}

-bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {

-  return v1 + v2 + v3 + v4 + v5 > 0;

-}

-

-// A 5-ary predicate functor.

-struct PredFunctor5 {

-  template <typename T1, typename T2, typename T3, typename T4, typename T5>

-  bool operator()(const T1& v1,

-                  const T2& v2,

-                  const T3& v3,

-                  const T4& v4,

-                  const T5& v5) {

-    return v1 + v2 + v3 + v4 + v5 > 0;

-  }

-};

-

-// A 5-ary predicate-formatter function.

-template <typename T1, typename T2, typename T3, typename T4, typename T5>

-testing::AssertionResult PredFormatFunction5(const char* e1,

-                                             const char* e2,

-                                             const char* e3,

-                                             const char* e4,

-                                             const char* e5,

-                                             const T1& v1,

-                                             const T2& v2,

-                                             const T3& v3,

-                                             const T4& v4,

-                                             const T5& v5) {

-  if (PredFunction5(v1, v2, v3, v4, v5))

-    return testing::AssertionSuccess();

-

-  testing::Message msg;

-  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5

-      << " is expected to be positive, but evaluates to "

-      << v1 + v2 + v3 + v4 + v5 << ".";

-  return testing::AssertionFailure(msg);

-}

-

-// A 5-ary predicate-formatter functor.

-struct PredFormatFunctor5 {

-  template <typename T1, typename T2, typename T3, typename T4, typename T5>

-  testing::AssertionResult operator()(const char* e1,

-                                      const char* e2,

-                                      const char* e3,

-                                      const char* e4,

-                                      const char* e5,

-                                      const T1& v1,

-                                      const T2& v2,

-                                      const T3& v3,

-                                      const T4& v4,

-                                      const T5& v5) const {

-    return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);

-  }

-};

-

-// Tests for {EXPECT|ASSERT}_PRED_FORMAT5.

-

-class Predicate5Test : public testing::Test {

- protected:

-  virtual void SetUp() {

-    expected_to_finish_ = true;

-    finished_ = false;

-    n1_ = n2_ = n3_ = n4_ = n5_ = 0;

-  }

-

-  virtual void TearDown() {

-    // Verifies that each of the predicate's arguments was evaluated

-    // exactly once.

-    EXPECT_EQ(1, n1_) <<

-        "The predicate assertion didn't evaluate argument 2 "

-        "exactly once.";

-    EXPECT_EQ(1, n2_) <<

-        "The predicate assertion didn't evaluate argument 3 "

-        "exactly once.";

-    EXPECT_EQ(1, n3_) <<

-        "The predicate assertion didn't evaluate argument 4 "

-        "exactly once.";

-    EXPECT_EQ(1, n4_) <<

-        "The predicate assertion didn't evaluate argument 5 "

-        "exactly once.";

-    EXPECT_EQ(1, n5_) <<

-        "The predicate assertion didn't evaluate argument 6 "

-        "exactly once.";

-

-    // Verifies that the control flow in the test function is expected.

-    if (expected_to_finish_ && !finished_) {

-      FAIL() << "The predicate assertion unexpactedly aborted the test.";

-    } else if (!expected_to_finish_ && finished_) {

-      FAIL() << "The failed predicate assertion didn't abort the test "

-                "as expected.";

-    }

-  }

-

-  // true iff the test function is expected to run to finish.

-  static bool expected_to_finish_;

-

-  // true iff the test function did run to finish.

-  static bool finished_;

-

-  static int n1_;

-  static int n2_;

-  static int n3_;

-  static int n4_;

-  static int n5_;

-};

-

-bool Predicate5Test::expected_to_finish_;

-bool Predicate5Test::finished_;

-int Predicate5Test::n1_;

-int Predicate5Test::n2_;

-int Predicate5Test::n3_;

-int Predicate5Test::n4_;

-int Predicate5Test::n5_;

-

-typedef Predicate5Test EXPECT_PRED_FORMAT5Test;

-typedef Predicate5Test ASSERT_PRED_FORMAT5Test;

-typedef Predicate5Test EXPECT_PRED5Test;

-typedef Predicate5Test ASSERT_PRED5Test;

-

-// Tests a successful EXPECT_PRED5 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED5(PredFunction5Int,

-               ++n1_,

-               ++n2_,

-               ++n3_,

-               ++n4_,

-               ++n5_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED5 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED5(PredFunction5Bool,

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_),

-               Bool(++n4_),

-               Bool(++n5_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED5 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED5(PredFunctor5(),

-               ++n1_,

-               ++n2_,

-               ++n3_,

-               ++n4_,

-               ++n5_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED5 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED5(PredFunctor5(),

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_),

-               Bool(++n4_),

-               Bool(++n5_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED5 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED5(PredFunction5Int,

-                 n1_++,

-                 n2_++,

-                 n3_++,

-                 n4_++,

-                 n5_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED5 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED5(PredFunction5Bool,

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++),

-                 Bool(n4_++),

-                 Bool(n5_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED5 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED5(PredFunctor5(),

-                 n1_++,

-                 n2_++,

-                 n3_++,

-                 n4_++,

-                 n5_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED5 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED5(PredFunctor5(),

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++),

-                 Bool(n4_++),

-                 Bool(n5_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED5 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED5(PredFunction5Int,

-               ++n1_,

-               ++n2_,

-               ++n3_,

-               ++n4_,

-               ++n5_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED5 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED5(PredFunction5Bool,

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_),

-               Bool(++n4_),

-               Bool(++n5_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED5 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED5(PredFunctor5(),

-               ++n1_,

-               ++n2_,

-               ++n3_,

-               ++n4_,

-               ++n5_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED5 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED5(PredFunctor5(),

-               Bool(++n1_),

-               Bool(++n2_),

-               Bool(++n3_),

-               Bool(++n4_),

-               Bool(++n5_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED5 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED5(PredFunction5Int,

-                 n1_++,

-                 n2_++,

-                 n3_++,

-                 n4_++,

-                 n5_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED5 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED5(PredFunction5Bool,

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++),

-                 Bool(n4_++),

-                 Bool(n5_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED5 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED5(PredFunctor5(),

-                 n1_++,

-                 n2_++,

-                 n3_++,

-                 n4_++,

-                 n5_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED5 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED5(PredFunctor5(),

-                 Bool(n1_++),

-                 Bool(n2_++),

-                 Bool(n3_++),

-                 Bool(n4_++),

-                 Bool(n5_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful EXPECT_PRED_FORMAT5 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT5(PredFormatFunction5,

-                      ++n1_,

-                      ++n2_,

-                      ++n3_,

-                      ++n4_,

-                      ++n5_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT5 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT5(PredFormatFunction5,

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_),

-                      Bool(++n4_),

-                      Bool(++n5_));

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT5 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {

-  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),

-                      ++n1_,

-                      ++n2_,

-                      ++n3_,

-                      ++n4_,

-                      ++n5_);

-  finished_ = true;

-}

-

-// Tests a successful EXPECT_PRED_FORMAT5 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {

-  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_),

-                      Bool(++n4_),

-                      Bool(++n5_));

-  finished_ = true;

-}

-

-// Tests a failed EXPECT_PRED_FORMAT5 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT5(PredFormatFunction5,

-                        n1_++,

-                        n2_++,

-                        n3_++,

-                        n4_++,

-                        n5_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT5 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT5(PredFormatFunction5,

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++),

-                        Bool(n4_++),

-                        Bool(n5_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT5 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),

-                        n1_++,

-                        n2_++,

-                        n3_++,

-                        n4_++,

-                        n5_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed EXPECT_PRED_FORMAT5 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++),

-                        Bool(n4_++),

-                        Bool(n5_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a successful ASSERT_PRED_FORMAT5 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT5(PredFormatFunction5,

-                      ++n1_,

-                      ++n2_,

-                      ++n3_,

-                      ++n4_,

-                      ++n5_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT5 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT5(PredFormatFunction5,

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_),

-                      Bool(++n4_),

-                      Bool(++n5_));

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT5 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {

-  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),

-                      ++n1_,

-                      ++n2_,

-                      ++n3_,

-                      ++n4_,

-                      ++n5_);

-  finished_ = true;

-}

-

-// Tests a successful ASSERT_PRED_FORMAT5 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {

-  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),

-                      Bool(++n1_),

-                      Bool(++n2_),

-                      Bool(++n3_),

-                      Bool(++n4_),

-                      Bool(++n5_));

-  finished_ = true;

-}

-

-// Tests a failed ASSERT_PRED_FORMAT5 where the

-// predicate-formatter is a function on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT5(PredFormatFunction5,

-                        n1_++,

-                        n2_++,

-                        n3_++,

-                        n4_++,

-                        n5_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT5 where the

-// predicate-formatter is a function on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT5(PredFormatFunction5,

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++),

-                        Bool(n4_++),

-                        Bool(n5_++));

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT5 where the

-// predicate-formatter is a functor on a built-in type (int).

-TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),

-                        n1_++,

-                        n2_++,

-                        n3_++,

-                        n4_++,

-                        n5_++);

-    finished_ = true;

-  }, "");

-}

-

-// Tests a failed ASSERT_PRED_FORMAT5 where the

-// predicate-formatter is a functor on a user-defined type (Bool).

-TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {

-  expected_to_finish_ = false;

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),

-                        Bool(n1_++),

-                        Bool(n2_++),

-                        Bool(n3_++),

-                        Bool(n4_++),

-                        Bool(n5_++));

-    finished_ = true;

-  }, "");

-}

+// Copyright 2006, 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.
+
+// This file is AUTOMATICALLY GENERATED on 10/02/2008 by command
+// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
+
+// Regression test for gtest_pred_impl.h
+//
+// This file is generated by a script and quite long.  If you intend to
+// learn how Google Test works by reading its unit tests, read
+// gtest_unittest.cc instead.
+//
+// This is intended as a regression test for the Google Test predicate
+// assertions.  We compile it as part of the gtest_unittest target
+// only to keep the implementation tidy and compact, as it is quite
+// involved to set up the stage for testing Google Test using Google
+// Test itself.
+//
+// Currently, gtest_unittest takes ~11 seconds to run in the testing
+// daemon.  In the future, if it grows too large and needs much more
+// time to finish, we should consider separating this file into a
+// stand-alone regression test.
+
+#include <iostream>
+
+#include <gtest/gtest.h>
+#include <gtest/gtest-spi.h>
+
+// A user-defined data type.
+struct Bool {
+  explicit Bool(int val) : value(val != 0) {}
+
+  bool operator>(int n) const { return value > Bool(n).value; }
+
+  Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
+
+  bool operator==(const Bool& rhs) const { return value == rhs.value; }
+
+  bool value;
+};
+
+// Enables Bool to be used in assertions.
+std::ostream& operator<<(std::ostream& os, const Bool& x) {
+  return os << (x.value ? "true" : "false");
+}
+
+// Sample functions/functors for testing unary predicate assertions.
+
+// A unary predicate function.
+template <typename T1>
+bool PredFunction1(T1 v1) {
+  return v1 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction1Int(int v1) {
+  return v1 > 0;
+}
+bool PredFunction1Bool(Bool v1) {
+  return v1 > 0;
+}
+
+// A unary predicate functor.
+struct PredFunctor1 {
+  template <typename T1>
+  bool operator()(const T1& v1) {
+    return v1 > 0;
+  }
+};
+
+// A unary predicate-formatter function.
+template <typename T1>
+testing::AssertionResult PredFormatFunction1(const char* e1,
+                                             const T1& v1) {
+  if (PredFunction1(v1))
+    return testing::AssertionSuccess();
+
+  testing::Message msg;
+  msg << e1
+      << " is expected to be positive, but evaluates to "
+      << v1 << ".";
+  return testing::AssertionFailure(msg);
+}
+
+// A unary predicate-formatter functor.
+struct PredFormatFunctor1 {
+  template <typename T1>
+  testing::AssertionResult operator()(const char* e1,
+                                      const T1& v1) const {
+    return PredFormatFunction1(e1, v1);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT1.
+
+class Predicate1Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+};
+
+bool Predicate1Test::expected_to_finish_;
+bool Predicate1Test::finished_;
+int Predicate1Test::n1_;
+
+typedef Predicate1Test EXPECT_PRED_FORMAT1Test;
+typedef Predicate1Test ASSERT_PRED_FORMAT1Test;
+typedef Predicate1Test EXPECT_PRED1Test;
+typedef Predicate1Test ASSERT_PRED1Test;
+
+// Tests a successful EXPECT_PRED1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED1(PredFunction1Int,
+               ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED1(PredFunction1Bool,
+               Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED1(PredFunctor1(),
+               ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED1(PredFunctor1(),
+               Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(PredFunction1Int,
+                 n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(PredFunction1Bool,
+                 Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(PredFunctor1(),
+                 n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(PredFunctor1(),
+                 Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED1(PredFunction1Int,
+               ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED1(PredFunction1Bool,
+               Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED1(PredFunctor1(),
+               ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED1(PredFunctor1(),
+               Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED1(PredFunction1Int,
+                 n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED1(PredFunction1Bool,
+                 Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED1(PredFunctor1(),
+                 n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED1(PredFunctor1(),
+                 Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT1(PredFormatFunction1,
+                      ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT1(PredFormatFunction1,
+                      Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
+                      ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
+                      Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT1(PredFormatFunction1,
+                        n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT1(PredFormatFunction1,
+                        Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
+                        n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
+                        Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT1(PredFormatFunction1,
+                      ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT1(PredFormatFunction1,
+                      Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
+                      ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
+                      Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(PredFormatFunction1,
+                        n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(PredFormatFunction1,
+                        Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
+                        n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
+                        Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+// Sample functions/functors for testing binary predicate assertions.
+
+// A binary predicate function.
+template <typename T1, typename T2>
+bool PredFunction2(T1 v1, T2 v2) {
+  return v1 + v2 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction2Int(int v1, int v2) {
+  return v1 + v2 > 0;
+}
+bool PredFunction2Bool(Bool v1, Bool v2) {
+  return v1 + v2 > 0;
+}
+
+// A binary predicate functor.
+struct PredFunctor2 {
+  template <typename T1, typename T2>
+  bool operator()(const T1& v1,
+                  const T2& v2) {
+    return v1 + v2 > 0;
+  }
+};
+
+// A binary predicate-formatter function.
+template <typename T1, typename T2>
+testing::AssertionResult PredFormatFunction2(const char* e1,
+                                             const char* e2,
+                                             const T1& v1,
+                                             const T2& v2) {
+  if (PredFunction2(v1, v2))
+    return testing::AssertionSuccess();
+
+  testing::Message msg;
+  msg << e1 << " + " << e2
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 << ".";
+  return testing::AssertionFailure(msg);
+}
+
+// A binary predicate-formatter functor.
+struct PredFormatFunctor2 {
+  template <typename T1, typename T2>
+  testing::AssertionResult operator()(const char* e1,
+                                      const char* e2,
+                                      const T1& v1,
+                                      const T2& v2) const {
+    return PredFormatFunction2(e1, e2, v1, v2);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT2.
+
+class Predicate2Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = n2_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+    EXPECT_EQ(1, n2_) <<
+        "The predicate assertion didn't evaluate argument 3 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+  static int n2_;
+};
+
+bool Predicate2Test::expected_to_finish_;
+bool Predicate2Test::finished_;
+int Predicate2Test::n1_;
+int Predicate2Test::n2_;
+
+typedef Predicate2Test EXPECT_PRED_FORMAT2Test;
+typedef Predicate2Test ASSERT_PRED_FORMAT2Test;
+typedef Predicate2Test EXPECT_PRED2Test;
+typedef Predicate2Test ASSERT_PRED2Test;
+
+// Tests a successful EXPECT_PRED2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED2(PredFunction2Int,
+               ++n1_,
+               ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED2(PredFunction2Bool,
+               Bool(++n1_),
+               Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED2(PredFunctor2(),
+               ++n1_,
+               ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED2(PredFunctor2(),
+               Bool(++n1_),
+               Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(PredFunction2Int,
+                 n1_++,
+                 n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(PredFunction2Bool,
+                 Bool(n1_++),
+                 Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(PredFunctor2(),
+                 n1_++,
+                 n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(PredFunctor2(),
+                 Bool(n1_++),
+                 Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED2(PredFunction2Int,
+               ++n1_,
+               ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED2(PredFunction2Bool,
+               Bool(++n1_),
+               Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED2(PredFunctor2(),
+               ++n1_,
+               ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED2(PredFunctor2(),
+               Bool(++n1_),
+               Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED2(PredFunction2Int,
+                 n1_++,
+                 n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED2(PredFunction2Bool,
+                 Bool(n1_++),
+                 Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED2(PredFunctor2(),
+                 n1_++,
+                 n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED2(PredFunctor2(),
+                 Bool(n1_++),
+                 Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT2(PredFormatFunction2,
+                      ++n1_,
+                      ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT2(PredFormatFunction2,
+                      Bool(++n1_),
+                      Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
+                      ++n1_,
+                      ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
+                      Bool(++n1_),
+                      Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(PredFormatFunction2,
+                        n1_++,
+                        n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(PredFormatFunction2,
+                        Bool(n1_++),
+                        Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
+                        n1_++,
+                        n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
+                        Bool(n1_++),
+                        Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT2(PredFormatFunction2,
+                      ++n1_,
+                      ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT2(PredFormatFunction2,
+                      Bool(++n1_),
+                      Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
+                      ++n1_,
+                      ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
+                      Bool(++n1_),
+                      Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(PredFormatFunction2,
+                        n1_++,
+                        n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(PredFormatFunction2,
+                        Bool(n1_++),
+                        Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
+                        n1_++,
+                        n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
+                        Bool(n1_++),
+                        Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+// Sample functions/functors for testing ternary predicate assertions.
+
+// A ternary predicate function.
+template <typename T1, typename T2, typename T3>
+bool PredFunction3(T1 v1, T2 v2, T3 v3) {
+  return v1 + v2 + v3 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction3Int(int v1, int v2, int v3) {
+  return v1 + v2 + v3 > 0;
+}
+bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) {
+  return v1 + v2 + v3 > 0;
+}
+
+// A ternary predicate functor.
+struct PredFunctor3 {
+  template <typename T1, typename T2, typename T3>
+  bool operator()(const T1& v1,
+                  const T2& v2,
+                  const T3& v3) {
+    return v1 + v2 + v3 > 0;
+  }
+};
+
+// A ternary predicate-formatter function.
+template <typename T1, typename T2, typename T3>
+testing::AssertionResult PredFormatFunction3(const char* e1,
+                                             const char* e2,
+                                             const char* e3,
+                                             const T1& v1,
+                                             const T2& v2,
+                                             const T3& v3) {
+  if (PredFunction3(v1, v2, v3))
+    return testing::AssertionSuccess();
+
+  testing::Message msg;
+  msg << e1 << " + " << e2 << " + " << e3
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 << ".";
+  return testing::AssertionFailure(msg);
+}
+
+// A ternary predicate-formatter functor.
+struct PredFormatFunctor3 {
+  template <typename T1, typename T2, typename T3>
+  testing::AssertionResult operator()(const char* e1,
+                                      const char* e2,
+                                      const char* e3,
+                                      const T1& v1,
+                                      const T2& v2,
+                                      const T3& v3) const {
+    return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT3.
+
+class Predicate3Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = n2_ = n3_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+    EXPECT_EQ(1, n2_) <<
+        "The predicate assertion didn't evaluate argument 3 "
+        "exactly once.";
+    EXPECT_EQ(1, n3_) <<
+        "The predicate assertion didn't evaluate argument 4 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+  static int n2_;
+  static int n3_;
+};
+
+bool Predicate3Test::expected_to_finish_;
+bool Predicate3Test::finished_;
+int Predicate3Test::n1_;
+int Predicate3Test::n2_;
+int Predicate3Test::n3_;
+
+typedef Predicate3Test EXPECT_PRED_FORMAT3Test;
+typedef Predicate3Test ASSERT_PRED_FORMAT3Test;
+typedef Predicate3Test EXPECT_PRED3Test;
+typedef Predicate3Test ASSERT_PRED3Test;
+
+// Tests a successful EXPECT_PRED3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED3(PredFunction3Int,
+               ++n1_,
+               ++n2_,
+               ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED3(PredFunction3Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED3(PredFunctor3(),
+               ++n1_,
+               ++n2_,
+               ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED3(PredFunctor3(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(PredFunction3Int,
+                 n1_++,
+                 n2_++,
+                 n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(PredFunction3Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(PredFunctor3(),
+                 n1_++,
+                 n2_++,
+                 n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(PredFunctor3(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED3(PredFunction3Int,
+               ++n1_,
+               ++n2_,
+               ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED3(PredFunction3Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED3(PredFunctor3(),
+               ++n1_,
+               ++n2_,
+               ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED3(PredFunctor3(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(PredFunction3Int,
+                 n1_++,
+                 n2_++,
+                 n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(PredFunction3Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(PredFunctor3(),
+                 n1_++,
+                 n2_++,
+                 n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(PredFunctor3(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT3(PredFormatFunction3,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT3(PredFormatFunction3,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT3(PredFormatFunction3,
+                        n1_++,
+                        n2_++,
+                        n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT3(PredFormatFunction3,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
+                        n1_++,
+                        n2_++,
+                        n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT3(PredFormatFunction3,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT3(PredFormatFunction3,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT3(PredFormatFunction3,
+                        n1_++,
+                        n2_++,
+                        n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT3(PredFormatFunction3,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
+                        n1_++,
+                        n2_++,
+                        n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+// Sample functions/functors for testing 4-ary predicate assertions.
+
+// A 4-ary predicate function.
+template <typename T1, typename T2, typename T3, typename T4>
+bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {
+  return v1 + v2 + v3 + v4 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction4Int(int v1, int v2, int v3, int v4) {
+  return v1 + v2 + v3 + v4 > 0;
+}
+bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {
+  return v1 + v2 + v3 + v4 > 0;
+}
+
+// A 4-ary predicate functor.
+struct PredFunctor4 {
+  template <typename T1, typename T2, typename T3, typename T4>
+  bool operator()(const T1& v1,
+                  const T2& v2,
+                  const T3& v3,
+                  const T4& v4) {
+    return v1 + v2 + v3 + v4 > 0;
+  }
+};
+
+// A 4-ary predicate-formatter function.
+template <typename T1, typename T2, typename T3, typename T4>
+testing::AssertionResult PredFormatFunction4(const char* e1,
+                                             const char* e2,
+                                             const char* e3,
+                                             const char* e4,
+                                             const T1& v1,
+                                             const T2& v2,
+                                             const T3& v3,
+                                             const T4& v4) {
+  if (PredFunction4(v1, v2, v3, v4))
+    return testing::AssertionSuccess();
+
+  testing::Message msg;
+  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 + v4 << ".";
+  return testing::AssertionFailure(msg);
+}
+
+// A 4-ary predicate-formatter functor.
+struct PredFormatFunctor4 {
+  template <typename T1, typename T2, typename T3, typename T4>
+  testing::AssertionResult operator()(const char* e1,
+                                      const char* e2,
+                                      const char* e3,
+                                      const char* e4,
+                                      const T1& v1,
+                                      const T2& v2,
+                                      const T3& v3,
+                                      const T4& v4) const {
+    return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT4.
+
+class Predicate4Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = n2_ = n3_ = n4_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+    EXPECT_EQ(1, n2_) <<
+        "The predicate assertion didn't evaluate argument 3 "
+        "exactly once.";
+    EXPECT_EQ(1, n3_) <<
+        "The predicate assertion didn't evaluate argument 4 "
+        "exactly once.";
+    EXPECT_EQ(1, n4_) <<
+        "The predicate assertion didn't evaluate argument 5 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+  static int n2_;
+  static int n3_;
+  static int n4_;
+};
+
+bool Predicate4Test::expected_to_finish_;
+bool Predicate4Test::finished_;
+int Predicate4Test::n1_;
+int Predicate4Test::n2_;
+int Predicate4Test::n3_;
+int Predicate4Test::n4_;
+
+typedef Predicate4Test EXPECT_PRED_FORMAT4Test;
+typedef Predicate4Test ASSERT_PRED_FORMAT4Test;
+typedef Predicate4Test EXPECT_PRED4Test;
+typedef Predicate4Test ASSERT_PRED4Test;
+
+// Tests a successful EXPECT_PRED4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED4(PredFunction4Int,
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED4(PredFunction4Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED4(PredFunctor4(),
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED4(PredFunctor4(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED4(PredFunction4Int,
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED4(PredFunction4Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED4(PredFunctor4(),
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED4(PredFunctor4(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED4(PredFunction4Int,
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED4(PredFunction4Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED4(PredFunctor4(),
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED4(PredFunctor4(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED4(PredFunction4Int,
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED4(PredFunction4Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED4(PredFunctor4(),
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED4(PredFunctor4(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT4(PredFormatFunction4,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT4(PredFormatFunction4,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(PredFormatFunction4,
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(PredFormatFunction4,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT4(PredFormatFunction4,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT4(PredFormatFunction4,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT4(PredFormatFunction4,
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT4(PredFormatFunction4,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+// Sample functions/functors for testing 5-ary predicate assertions.
+
+// A 5-ary predicate function.
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+  return v1 + v2 + v3 + v4 + v5 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {
+  return v1 + v2 + v3 + v4 + v5 > 0;
+}
+bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {
+  return v1 + v2 + v3 + v4 + v5 > 0;
+}
+
+// A 5-ary predicate functor.
+struct PredFunctor5 {
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  bool operator()(const T1& v1,
+                  const T2& v2,
+                  const T3& v3,
+                  const T4& v4,
+                  const T5& v5) {
+    return v1 + v2 + v3 + v4 + v5 > 0;
+  }
+};
+
+// A 5-ary predicate-formatter function.
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+testing::AssertionResult PredFormatFunction5(const char* e1,
+                                             const char* e2,
+                                             const char* e3,
+                                             const char* e4,
+                                             const char* e5,
+                                             const T1& v1,
+                                             const T2& v2,
+                                             const T3& v3,
+                                             const T4& v4,
+                                             const T5& v5) {
+  if (PredFunction5(v1, v2, v3, v4, v5))
+    return testing::AssertionSuccess();
+
+  testing::Message msg;
+  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 + v4 + v5 << ".";
+  return testing::AssertionFailure(msg);
+}
+
+// A 5-ary predicate-formatter functor.
+struct PredFormatFunctor5 {
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  testing::AssertionResult operator()(const char* e1,
+                                      const char* e2,
+                                      const char* e3,
+                                      const char* e4,
+                                      const char* e5,
+                                      const T1& v1,
+                                      const T2& v2,
+                                      const T3& v3,
+                                      const T4& v4,
+                                      const T5& v5) const {
+    return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT5.
+
+class Predicate5Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = n2_ = n3_ = n4_ = n5_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+    EXPECT_EQ(1, n2_) <<
+        "The predicate assertion didn't evaluate argument 3 "
+        "exactly once.";
+    EXPECT_EQ(1, n3_) <<
+        "The predicate assertion didn't evaluate argument 4 "
+        "exactly once.";
+    EXPECT_EQ(1, n4_) <<
+        "The predicate assertion didn't evaluate argument 5 "
+        "exactly once.";
+    EXPECT_EQ(1, n5_) <<
+        "The predicate assertion didn't evaluate argument 6 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+  static int n2_;
+  static int n3_;
+  static int n4_;
+  static int n5_;
+};
+
+bool Predicate5Test::expected_to_finish_;
+bool Predicate5Test::finished_;
+int Predicate5Test::n1_;
+int Predicate5Test::n2_;
+int Predicate5Test::n3_;
+int Predicate5Test::n4_;
+int Predicate5Test::n5_;
+
+typedef Predicate5Test EXPECT_PRED_FORMAT5Test;
+typedef Predicate5Test ASSERT_PRED_FORMAT5Test;
+typedef Predicate5Test EXPECT_PRED5Test;
+typedef Predicate5Test ASSERT_PRED5Test;
+
+// Tests a successful EXPECT_PRED5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED5(PredFunction5Int,
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_,
+               ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED5(PredFunction5Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_),
+               Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED5(PredFunctor5(),
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_,
+               ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED5(PredFunctor5(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_),
+               Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED5(PredFunction5Int,
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++,
+                 n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED5(PredFunction5Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++),
+                 Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED5(PredFunctor5(),
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++,
+                 n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED5(PredFunctor5(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++),
+                 Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED5(PredFunction5Int,
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_,
+               ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED5(PredFunction5Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_),
+               Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED5(PredFunctor5(),
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_,
+               ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED5(PredFunctor5(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_),
+               Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED5(PredFunction5Int,
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++,
+                 n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED5(PredFunction5Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++),
+                 Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED5(PredFunctor5(),
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++,
+                 n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED5(PredFunctor5(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++),
+                 Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT5(PredFormatFunction5,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_,
+                      ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT5(PredFormatFunction5,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_),
+                      Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_,
+                      ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_),
+                      Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT5(PredFormatFunction5,
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++,
+                        n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT5(PredFormatFunction5,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++),
+                        Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++,
+                        n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++),
+                        Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT5(PredFormatFunction5,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_,
+                      ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT5(PredFormatFunction5,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_),
+                      Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_,
+                      ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_),
+                      Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(PredFormatFunction5,
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++,
+                        n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(PredFormatFunction5,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++),
+                        Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++,
+                        n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++),
+                        Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_prod_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_prod_test.cc
index b082d950..bc3201d0 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_prod_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_prod_test.cc
@@ -1,57 +1,57 @@
-// Copyright 2006, 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: [email protected] (Zhanyong Wan)

-//

-// Unit test for include/gtest/gtest_prod.h.

-

-#include <gtest/gtest.h>

-#include "test/production.h"

-

-// Tests that private members can be accessed from a TEST declared as

-// a friend of the class.

-TEST(PrivateCodeTest, CanAccessPrivateMembers) {

-  PrivateCode a;

-  EXPECT_EQ(0, a.x_);

-

-  a.set_x(1);

-  EXPECT_EQ(1, a.x_);

-}

-

-typedef testing::Test PrivateCodeFixtureTest;

-

-// Tests that private members can be accessed from a TEST_F declared

-// as a friend of the class.

-TEST_F(PrivateCodeFixtureTest, CanAccessPrivateMembers) {

-  PrivateCode a;

-  EXPECT_EQ(0, a.x_);

-

-  a.set_x(2);

-  EXPECT_EQ(2, a.x_);

-}

+// Copyright 2006, 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: [email protected] (Zhanyong Wan)
+//
+// Unit test for include/gtest/gtest_prod.h.
+
+#include <gtest/gtest.h>
+#include "test/production.h"
+
+// Tests that private members can be accessed from a TEST declared as
+// a friend of the class.
+TEST(PrivateCodeTest, CanAccessPrivateMembers) {
+  PrivateCode a;
+  EXPECT_EQ(0, a.x_);
+
+  a.set_x(1);
+  EXPECT_EQ(1, a.x_);
+}
+
+typedef testing::Test PrivateCodeFixtureTest;
+
+// Tests that private members can be accessed from a TEST_F declared
+// as a friend of the class.
+TEST_F(PrivateCodeFixtureTest, CanAccessPrivateMembers) {
+  PrivateCode a;
+  EXPECT_EQ(0, a.x_);
+
+  a.set_x(2);
+  EXPECT_EQ(2, a.x_);
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_repeat_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_repeat_test.cc
index db30f278..df6868b8 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_repeat_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_repeat_test.cc
@@ -1,253 +1,253 @@
-// Copyright 2008, 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: [email protected] (Zhanyong Wan)

-

-// Tests the --gtest_repeat=number flag.

-

-#include <stdlib.h>

-#include <iostream>

-#include <gtest/gtest.h>

-

-// 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_

-

-namespace testing {

-

-GTEST_DECLARE_string_(death_test_style);

-GTEST_DECLARE_string_(filter);

-GTEST_DECLARE_int32_(repeat);

-

-}  // namespace testing

-

-using testing::GTEST_FLAG(death_test_style);

-using testing::GTEST_FLAG(filter);

-using testing::GTEST_FLAG(repeat);

-

-namespace {

-

-// We need this when we are testing Google Test itself and therefore

-// cannot use Google Test assertions.

-#define GTEST_CHECK_INT_EQ_(expected, actual) \

-  do {\

-    const int expected_val = (expected);\

-    const int actual_val = (actual);\

-    if (::testing::internal::IsTrue(expected_val != actual_val)) {\

-      ::std::cout << "Value of: " #actual "\n"\

-                  << "  Actual: " << actual_val << "\n"\

-                  << "Expected: " #expected "\n"\

-                  << "Which is: " << expected_val << "\n";\

-      abort();\

-    }\

-  } while(::testing::internal::AlwaysFalse())

-

-

-// Used for verifying that global environment set-up and tear-down are

-// inside the gtest_repeat loop.

-

-int g_environment_set_up_count = 0;

-int g_environment_tear_down_count = 0;

-

-class MyEnvironment : public testing::Environment {

- public:

-  MyEnvironment() {}

-  virtual void SetUp() { g_environment_set_up_count++; }

-  virtual void TearDown() { g_environment_tear_down_count++; }

-};

-

-// A test that should fail.

-

-int g_should_fail_count = 0;

-

-TEST(FooTest, ShouldFail) {

-  g_should_fail_count++;

-  EXPECT_EQ(0, 1) << "Expected failure.";

-}

-

-// A test that should pass.

-

-int g_should_pass_count = 0;

-

-TEST(FooTest, ShouldPass) {

-  g_should_pass_count++;

-}

-

-// A test that contains a thread-safe death test and a fast death

-// test.  It should pass.

-

-int g_death_test_count = 0;

-

-TEST(BarDeathTest, ThreadSafeAndFast) {

-  g_death_test_count++;

-

-  GTEST_FLAG(death_test_style) = "threadsafe";

-  EXPECT_DEATH_IF_SUPPORTED(abort(), "");

-

-  GTEST_FLAG(death_test_style) = "fast";

-  EXPECT_DEATH_IF_SUPPORTED(abort(), "");

-}

-

-#if GTEST_HAS_PARAM_TEST

-int g_param_test_count = 0;

-

-const int kNumberOfParamTests = 10;

-

-class MyParamTest : public testing::TestWithParam<int> {};

-

-TEST_P(MyParamTest, ShouldPass) {

-  // TODO([email protected]): Make parameter value checking robust

-  //                         WRT order of tests.

-  GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam());

-  g_param_test_count++;

-}

-INSTANTIATE_TEST_CASE_P(MyParamSequence,

-                        MyParamTest,

-                        testing::Range(0, kNumberOfParamTests));

-#endif  // GTEST_HAS_PARAM_TEST

-

-// Resets the count for each test.

-void ResetCounts() {

-  g_environment_set_up_count = 0;

-  g_environment_tear_down_count = 0;

-  g_should_fail_count = 0;

-  g_should_pass_count = 0;

-  g_death_test_count = 0;

-#if GTEST_HAS_PARAM_TEST

-  g_param_test_count = 0;

-#endif  // GTEST_HAS_PARAM_TEST

-}

-

-// Checks that the count for each test is expected.

-void CheckCounts(int expected) {

-  GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count);

-  GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count);

-  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);

-#if GTEST_HAS_PARAM_TEST

-  GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count);

-#endif  // GTEST_HAS_PARAM_TEST

-}

-

-// Tests the behavior of Google Test when --gtest_repeat is not specified.

-void TestRepeatUnspecified() {

-  ResetCounts();

-  GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());

-  CheckCounts(1);

-}

-

-// Tests the behavior of Google Test when --gtest_repeat has the given value.

-void TestRepeat(int repeat) {

-  GTEST_FLAG(repeat) = repeat;

-

-  ResetCounts();

-  GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS());

-  CheckCounts(repeat);

-}

-

-// Tests using --gtest_repeat when --gtest_filter specifies an empty

-// set of tests.

-void TestRepeatWithEmptyFilter(int repeat) {

-  GTEST_FLAG(repeat) = repeat;

-  GTEST_FLAG(filter) = "None";

-

-  ResetCounts();

-  GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());

-  CheckCounts(0);

-}

-

-// Tests using --gtest_repeat when --gtest_filter specifies a set of

-// successful tests.

-void TestRepeatWithFilterForSuccessfulTests(int repeat) {

-  GTEST_FLAG(repeat) = repeat;

-  GTEST_FLAG(filter) = "*-*ShouldFail";

-

-  ResetCounts();

-  GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());

-  GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);

-  GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);

-  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);

-#if GTEST_HAS_PARAM_TEST

-  GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count);

-#endif  // GTEST_HAS_PARAM_TEST

-}

-

-// Tests using --gtest_repeat when --gtest_filter specifies a set of

-// failed tests.

-void TestRepeatWithFilterForFailedTests(int repeat) {

-  GTEST_FLAG(repeat) = repeat;

-  GTEST_FLAG(filter) = "*ShouldFail";

-

-  ResetCounts();

-  GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());

-  GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);

-  GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);

-  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);

-#if GTEST_HAS_PARAM_TEST

-  GTEST_CHECK_INT_EQ_(0, g_param_test_count);

-#endif  // GTEST_HAS_PARAM_TEST

-}

-

-}  // namespace

-

-int main(int argc, char **argv) {

-  testing::InitGoogleTest(&argc, argv);

-  testing::AddGlobalTestEnvironment(new MyEnvironment);

-

-  TestRepeatUnspecified();

-  TestRepeat(0);

-  TestRepeat(1);

-  TestRepeat(5);

-

-  TestRepeatWithEmptyFilter(2);

-  TestRepeatWithEmptyFilter(3);

-

-  TestRepeatWithFilterForSuccessfulTests(3);

-

-  TestRepeatWithFilterForFailedTests(4);

-

-  // It would be nice to verify that the tests indeed loop forever

-  // when GTEST_FLAG(repeat) is negative, but this test will be quite

-  // complicated to write.  Since this flag is for interactive

-  // debugging only and doesn't affect the normal test result, such a

-  // test would be an overkill.

-

-  printf("PASS\n");

-  return 0;

-}

+// Copyright 2008, 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: [email protected] (Zhanyong Wan)
+
+// Tests the --gtest_repeat=number flag.
+
+#include <stdlib.h>
+#include <iostream>
+#include <gtest/gtest.h>
+
+// 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_
+
+namespace testing {
+
+GTEST_DECLARE_string_(death_test_style);
+GTEST_DECLARE_string_(filter);
+GTEST_DECLARE_int32_(repeat);
+
+}  // namespace testing
+
+using testing::GTEST_FLAG(death_test_style);
+using testing::GTEST_FLAG(filter);
+using testing::GTEST_FLAG(repeat);
+
+namespace {
+
+// We need this when we are testing Google Test itself and therefore
+// cannot use Google Test assertions.
+#define GTEST_CHECK_INT_EQ_(expected, actual) \
+  do {\
+    const int expected_val = (expected);\
+    const int actual_val = (actual);\
+    if (::testing::internal::IsTrue(expected_val != actual_val)) {\
+      ::std::cout << "Value of: " #actual "\n"\
+                  << "  Actual: " << actual_val << "\n"\
+                  << "Expected: " #expected "\n"\
+                  << "Which is: " << expected_val << "\n";\
+      abort();\
+    }\
+  } while(::testing::internal::AlwaysFalse())
+
+
+// Used for verifying that global environment set-up and tear-down are
+// inside the gtest_repeat loop.
+
+int g_environment_set_up_count = 0;
+int g_environment_tear_down_count = 0;
+
+class MyEnvironment : public testing::Environment {
+ public:
+  MyEnvironment() {}
+  virtual void SetUp() { g_environment_set_up_count++; }
+  virtual void TearDown() { g_environment_tear_down_count++; }
+};
+
+// A test that should fail.
+
+int g_should_fail_count = 0;
+
+TEST(FooTest, ShouldFail) {
+  g_should_fail_count++;
+  EXPECT_EQ(0, 1) << "Expected failure.";
+}
+
+// A test that should pass.
+
+int g_should_pass_count = 0;
+
+TEST(FooTest, ShouldPass) {
+  g_should_pass_count++;
+}
+
+// A test that contains a thread-safe death test and a fast death
+// test.  It should pass.
+
+int g_death_test_count = 0;
+
+TEST(BarDeathTest, ThreadSafeAndFast) {
+  g_death_test_count++;
+
+  GTEST_FLAG(death_test_style) = "threadsafe";
+  EXPECT_DEATH_IF_SUPPORTED(abort(), "");
+
+  GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_DEATH_IF_SUPPORTED(abort(), "");
+}
+
+#if GTEST_HAS_PARAM_TEST
+int g_param_test_count = 0;
+
+const int kNumberOfParamTests = 10;
+
+class MyParamTest : public testing::TestWithParam<int> {};
+
+TEST_P(MyParamTest, ShouldPass) {
+  // TODO([email protected]): Make parameter value checking robust
+  //                         WRT order of tests.
+  GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam());
+  g_param_test_count++;
+}
+INSTANTIATE_TEST_CASE_P(MyParamSequence,
+                        MyParamTest,
+                        testing::Range(0, kNumberOfParamTests));
+#endif  // GTEST_HAS_PARAM_TEST
+
+// Resets the count for each test.
+void ResetCounts() {
+  g_environment_set_up_count = 0;
+  g_environment_tear_down_count = 0;
+  g_should_fail_count = 0;
+  g_should_pass_count = 0;
+  g_death_test_count = 0;
+#if GTEST_HAS_PARAM_TEST
+  g_param_test_count = 0;
+#endif  // GTEST_HAS_PARAM_TEST
+}
+
+// Checks that the count for each test is expected.
+void CheckCounts(int expected) {
+  GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count);
+  GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count);
+  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);
+#if GTEST_HAS_PARAM_TEST
+  GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count);
+#endif  // GTEST_HAS_PARAM_TEST
+}
+
+// Tests the behavior of Google Test when --gtest_repeat is not specified.
+void TestRepeatUnspecified() {
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
+  CheckCounts(1);
+}
+
+// Tests the behavior of Google Test when --gtest_repeat has the given value.
+void TestRepeat(int repeat) {
+  GTEST_FLAG(repeat) = repeat;
+
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS());
+  CheckCounts(repeat);
+}
+
+// Tests using --gtest_repeat when --gtest_filter specifies an empty
+// set of tests.
+void TestRepeatWithEmptyFilter(int repeat) {
+  GTEST_FLAG(repeat) = repeat;
+  GTEST_FLAG(filter) = "None";
+
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
+  CheckCounts(0);
+}
+
+// Tests using --gtest_repeat when --gtest_filter specifies a set of
+// successful tests.
+void TestRepeatWithFilterForSuccessfulTests(int repeat) {
+  GTEST_FLAG(repeat) = repeat;
+  GTEST_FLAG(filter) = "*-*ShouldFail";
+
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
+  GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
+  GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
+  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);
+#if GTEST_HAS_PARAM_TEST
+  GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count);
+#endif  // GTEST_HAS_PARAM_TEST
+}
+
+// Tests using --gtest_repeat when --gtest_filter specifies a set of
+// failed tests.
+void TestRepeatWithFilterForFailedTests(int repeat) {
+  GTEST_FLAG(repeat) = repeat;
+  GTEST_FLAG(filter) = "*ShouldFail";
+
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
+  GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
+  GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
+  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);
+#if GTEST_HAS_PARAM_TEST
+  GTEST_CHECK_INT_EQ_(0, g_param_test_count);
+#endif  // GTEST_HAS_PARAM_TEST
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  testing::AddGlobalTestEnvironment(new MyEnvironment);
+
+  TestRepeatUnspecified();
+  TestRepeat(0);
+  TestRepeat(1);
+  TestRepeat(5);
+
+  TestRepeatWithEmptyFilter(2);
+  TestRepeatWithEmptyFilter(3);
+
+  TestRepeatWithFilterForSuccessfulTests(3);
+
+  TestRepeatWithFilterForFailedTests(4);
+
+  // It would be nice to verify that the tests indeed loop forever
+  // when GTEST_FLAG(repeat) is negative, but this test will be quite
+  // complicated to write.  Since this flag is for interactive
+  // debugging only and doesn't affect the normal test result, such a
+  // test would be an overkill.
+
+  printf("PASS\n");
+  return 0;
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_shuffle_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_shuffle_test_.cc
index b50aa9de..53ecf777 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_shuffle_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_shuffle_test_.cc
@@ -1,104 +1,104 @@
-// 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: [email protected] (Zhanyong Wan)

-

-// Verifies that test shuffling works.

-

-#include <gtest/gtest.h>

-

-namespace {

-

-using ::testing::EmptyTestEventListener;

-using ::testing::InitGoogleTest;

-using ::testing::Message;

-using ::testing::Test;

-using ::testing::TestEventListeners;

-using ::testing::TestInfo;

-using ::testing::UnitTest;

-using ::testing::internal::String;

-using ::testing::internal::scoped_ptr;

-

-// The test methods are empty, as the sole purpose of this program is

-// to print the test names before/after shuffling.

-

-class A : public Test {};

-TEST_F(A, A) {}

-TEST_F(A, B) {}

-

-TEST(ADeathTest, A) {}

-TEST(ADeathTest, B) {}

-TEST(ADeathTest, C) {}

-

-TEST(B, A) {}

-TEST(B, B) {}

-TEST(B, C) {}

-TEST(B, DISABLED_D) {}

-TEST(B, DISABLED_E) {}

-

-TEST(BDeathTest, A) {}

-TEST(BDeathTest, B) {}

-

-TEST(C, A) {}

-TEST(C, B) {}

-TEST(C, C) {}

-TEST(C, DISABLED_D) {}

-

-TEST(CDeathTest, A) {}

-

-TEST(DISABLED_D, A) {}

-TEST(DISABLED_D, DISABLED_B) {}

-

-// This printer prints the full test names only, starting each test

-// iteration with a "----" marker.

-class TestNamePrinter : public EmptyTestEventListener {

- public:

-  virtual void OnTestIterationStart(const UnitTest& /* unit_test */,

-                                    int /* iteration */) {

-    printf("----\n");

-  }

-

-  virtual void OnTestStart(const TestInfo& test_info) {

-    printf("%s.%s\n", test_info.test_case_name(), test_info.name());

-  }

-};

-

-}  // namespace

-

-int main(int argc, char **argv) {

-  InitGoogleTest(&argc, argv);

-

-  // Replaces the default printer with TestNamePrinter, which prints

-  // the test name only.

-  TestEventListeners& listeners = UnitTest::GetInstance()->listeners();

-  delete listeners.Release(listeners.default_result_printer());

-  listeners.Append(new TestNamePrinter);

-

-  return RUN_ALL_TESTS();

-}

+// 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: [email protected] (Zhanyong Wan)
+
+// Verifies that test shuffling works.
+
+#include <gtest/gtest.h>
+
+namespace {
+
+using ::testing::EmptyTestEventListener;
+using ::testing::InitGoogleTest;
+using ::testing::Message;
+using ::testing::Test;
+using ::testing::TestEventListeners;
+using ::testing::TestInfo;
+using ::testing::UnitTest;
+using ::testing::internal::String;
+using ::testing::internal::scoped_ptr;
+
+// The test methods are empty, as the sole purpose of this program is
+// to print the test names before/after shuffling.
+
+class A : public Test {};
+TEST_F(A, A) {}
+TEST_F(A, B) {}
+
+TEST(ADeathTest, A) {}
+TEST(ADeathTest, B) {}
+TEST(ADeathTest, C) {}
+
+TEST(B, A) {}
+TEST(B, B) {}
+TEST(B, C) {}
+TEST(B, DISABLED_D) {}
+TEST(B, DISABLED_E) {}
+
+TEST(BDeathTest, A) {}
+TEST(BDeathTest, B) {}
+
+TEST(C, A) {}
+TEST(C, B) {}
+TEST(C, C) {}
+TEST(C, DISABLED_D) {}
+
+TEST(CDeathTest, A) {}
+
+TEST(DISABLED_D, A) {}
+TEST(DISABLED_D, DISABLED_B) {}
+
+// This printer prints the full test names only, starting each test
+// iteration with a "----" marker.
+class TestNamePrinter : public EmptyTestEventListener {
+ public:
+  virtual void OnTestIterationStart(const UnitTest& /* unit_test */,
+                                    int /* iteration */) {
+    printf("----\n");
+  }
+
+  virtual void OnTestStart(const TestInfo& test_info) {
+    printf("%s.%s\n", test_info.test_case_name(), test_info.name());
+  }
+};
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  InitGoogleTest(&argc, argv);
+
+  // Replaces the default printer with TestNamePrinter, which prints
+  // the test name only.
+  TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
+  delete listeners.Release(listeners.default_result_printer());
+  listeners.Append(new TestNamePrinter);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_sole_header_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_sole_header_test.cc
index 89edc6e8..de91e800 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_sole_header_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_sole_header_test.cc
@@ -1,57 +1,57 @@
-// Copyright 2008, 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: [email protected] (Markus Heule)

-//

-// This test verifies that it's possible to use Google Test by including

-// the gtest.h header file alone.

-

-#include <gtest/gtest.h>

-

-namespace {

-

-void Subroutine() {

-  EXPECT_EQ(42, 42);

-}

-

-TEST(NoFatalFailureTest, ExpectNoFatalFailure) {

-  EXPECT_NO_FATAL_FAILURE(;);

-  EXPECT_NO_FATAL_FAILURE(SUCCEED());

-  EXPECT_NO_FATAL_FAILURE(Subroutine());

-  EXPECT_NO_FATAL_FAILURE({ SUCCEED(); });

-}

-

-TEST(NoFatalFailureTest, AssertNoFatalFailure) {

-  ASSERT_NO_FATAL_FAILURE(;);

-  ASSERT_NO_FATAL_FAILURE(SUCCEED());

-  ASSERT_NO_FATAL_FAILURE(Subroutine());

-  ASSERT_NO_FATAL_FAILURE({ SUCCEED(); });

-}

-

-}  // namespace

+// Copyright 2008, 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: [email protected] (Markus Heule)
+//
+// This test verifies that it's possible to use Google Test by including
+// the gtest.h header file alone.
+
+#include <gtest/gtest.h>
+
+namespace {
+
+void Subroutine() {
+  EXPECT_EQ(42, 42);
+}
+
+TEST(NoFatalFailureTest, ExpectNoFatalFailure) {
+  EXPECT_NO_FATAL_FAILURE(;);
+  EXPECT_NO_FATAL_FAILURE(SUCCEED());
+  EXPECT_NO_FATAL_FAILURE(Subroutine());
+  EXPECT_NO_FATAL_FAILURE({ SUCCEED(); });
+}
+
+TEST(NoFatalFailureTest, AssertNoFatalFailure) {
+  ASSERT_NO_FATAL_FAILURE(;);
+  ASSERT_NO_FATAL_FAILURE(SUCCEED());
+  ASSERT_NO_FATAL_FAILURE(Subroutine());
+  ASSERT_NO_FATAL_FAILURE({ SUCCEED(); });
+}
+
+}  // namespace
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_stress_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_stress_test.cc
index 701711dc..0034bb84 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_stress_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_stress_test.cc
@@ -1,151 +1,151 @@
-// Copyright 2007, 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: [email protected] (Zhanyong Wan)

-

-// Tests that SCOPED_TRACE() and various Google Test assertions can be

-// used in a large number of threads concurrently.

-

-#include <iostream>

-#include <gtest/gtest.h>

-

-// 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_ 1

-#include "src/gtest-internal-inl.h"

-#undef GTEST_IMPLEMENTATION_

-

-namespace testing {

-namespace {

-

-using internal::String;

-using internal::TestPropertyKeyIs;

-using internal::Vector;

-

-// How many threads to create?

-const int kThreadCount = 50;

-

-String IdToKey(int id, const char* suffix) {

-  Message key;

-  key << "key_" << id << "_" << suffix;

-  return key.GetString();

-}

-

-String IdToString(int id) {

-  Message id_message;

-  id_message << id;

-  return id_message.GetString();

-}

-

-void ExpectKeyAndValueWereRecordedForId(const Vector<TestProperty>& properties,

-                                        int id,

-                                        const char* suffix) {

-  TestPropertyKeyIs matches_key(IdToKey(id, suffix).c_str());

-  const TestProperty* property = properties.FindIf(matches_key);

-  ASSERT_TRUE(property != NULL)

-      << "expecting " << suffix << " value for id " << id;

-  EXPECT_STREQ(IdToString(id).c_str(), property->value());

-}

-

-// Calls a large number of Google Test assertions, where exactly one of them

-// will fail.

-void ManyAsserts(int id) {

-  ::std::cout << "Thread #" << id << " running...\n";

-

-  SCOPED_TRACE(Message() << "Thread #" << id);

-

-  for (int i = 0; i < kThreadCount; i++) {

-    SCOPED_TRACE(Message() << "Iteration #" << i);

-

-    // A bunch of assertions that should succeed.

-    EXPECT_TRUE(true);

-    ASSERT_FALSE(false) << "This shouldn't fail.";

-    EXPECT_STREQ("a", "a");

-    ASSERT_LE(5, 6);

-    EXPECT_EQ(i, i) << "This shouldn't fail.";

-

-    // RecordProperty() should interact safely with other threads as well.

-    // The shared_key forces property updates.

-    Test::RecordProperty(IdToKey(id, "string").c_str(), IdToString(id).c_str());

-    Test::RecordProperty(IdToKey(id, "int").c_str(), id);

-    Test::RecordProperty("shared_key", IdToString(id).c_str());

-

-    // This assertion should fail kThreadCount times per thread.  It

-    // is for testing whether Google Test can handle failed assertions in a

-    // multi-threaded context.

-    EXPECT_LT(i, 0) << "This should always fail.";

-  }

-}

-

-// Tests using SCOPED_TRACE() and Google Test assertions in many threads

-// concurrently.

-TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {

-  // TODO(wan): when Google Test is made thread-safe, run

-  // ManyAsserts() in many threads here.

-}

-

-TEST(NoFatalFailureTest, ExpectNoFatalFailureIgnoresFailuresInOtherThreads) {

-  // TODO([email protected]): Test this works correctly when Google

-  // Test is made thread-safe.

-}

-

-TEST(NoFatalFailureTest, AssertNoFatalFailureIgnoresFailuresInOtherThreads) {

-  // TODO([email protected]): Test this works correctly when Google

-  // Test is made thread-safe.

-}

-

-TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {

-  // TODO([email protected]): Test this works correctly when Google

-  // Test is made thread-safe.

-}

-

-TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {

-  // TODO([email protected]): Test this works correctly when Google Test

-  // is made thread-safe.

-}

-

-TEST(NonFatalFailureTest, ExpectNonFatalFailureIgnoresFailuresInOtherThreads) {

-  // TODO([email protected]): Test this works correctly when Google

-  // Test is made thread-safe.

-}

-

-TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThreads) {

-  // TODO([email protected]): Test this works correctly when Google Test

-  // is made thread-safe.

-}

-

-}  // namespace

-}  // namespace testing

-

-int main(int argc, char **argv) {

-  testing::InitGoogleTest(&argc, argv);

-

-  return RUN_ALL_TESTS();

-}

+// Copyright 2007, 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: [email protected] (Zhanyong Wan)
+
+// Tests that SCOPED_TRACE() and various Google Test assertions can be
+// used in a large number of threads concurrently.
+
+#include <iostream>
+#include <gtest/gtest.h>
+
+// 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_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+namespace {
+
+using internal::String;
+using internal::TestPropertyKeyIs;
+using internal::Vector;
+
+// How many threads to create?
+const int kThreadCount = 50;
+
+String IdToKey(int id, const char* suffix) {
+  Message key;
+  key << "key_" << id << "_" << suffix;
+  return key.GetString();
+}
+
+String IdToString(int id) {
+  Message id_message;
+  id_message << id;
+  return id_message.GetString();
+}
+
+void ExpectKeyAndValueWereRecordedForId(const Vector<TestProperty>& properties,
+                                        int id,
+                                        const char* suffix) {
+  TestPropertyKeyIs matches_key(IdToKey(id, suffix).c_str());
+  const TestProperty* property = properties.FindIf(matches_key);
+  ASSERT_TRUE(property != NULL)
+      << "expecting " << suffix << " value for id " << id;
+  EXPECT_STREQ(IdToString(id).c_str(), property->value());
+}
+
+// Calls a large number of Google Test assertions, where exactly one of them
+// will fail.
+void ManyAsserts(int id) {
+  ::std::cout << "Thread #" << id << " running...\n";
+
+  SCOPED_TRACE(Message() << "Thread #" << id);
+
+  for (int i = 0; i < kThreadCount; i++) {
+    SCOPED_TRACE(Message() << "Iteration #" << i);
+
+    // A bunch of assertions that should succeed.
+    EXPECT_TRUE(true);
+    ASSERT_FALSE(false) << "This shouldn't fail.";
+    EXPECT_STREQ("a", "a");
+    ASSERT_LE(5, 6);
+    EXPECT_EQ(i, i) << "This shouldn't fail.";
+
+    // RecordProperty() should interact safely with other threads as well.
+    // The shared_key forces property updates.
+    Test::RecordProperty(IdToKey(id, "string").c_str(), IdToString(id).c_str());
+    Test::RecordProperty(IdToKey(id, "int").c_str(), id);
+    Test::RecordProperty("shared_key", IdToString(id).c_str());
+
+    // This assertion should fail kThreadCount times per thread.  It
+    // is for testing whether Google Test can handle failed assertions in a
+    // multi-threaded context.
+    EXPECT_LT(i, 0) << "This should always fail.";
+  }
+}
+
+// Tests using SCOPED_TRACE() and Google Test assertions in many threads
+// concurrently.
+TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
+  // TODO(wan): when Google Test is made thread-safe, run
+  // ManyAsserts() in many threads here.
+}
+
+TEST(NoFatalFailureTest, ExpectNoFatalFailureIgnoresFailuresInOtherThreads) {
+  // TODO([email protected]): Test this works correctly when Google
+  // Test is made thread-safe.
+}
+
+TEST(NoFatalFailureTest, AssertNoFatalFailureIgnoresFailuresInOtherThreads) {
+  // TODO([email protected]): Test this works correctly when Google
+  // Test is made thread-safe.
+}
+
+TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {
+  // TODO([email protected]): Test this works correctly when Google
+  // Test is made thread-safe.
+}
+
+TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {
+  // TODO([email protected]): Test this works correctly when Google Test
+  // is made thread-safe.
+}
+
+TEST(NonFatalFailureTest, ExpectNonFatalFailureIgnoresFailuresInOtherThreads) {
+  // TODO([email protected]): Test this works correctly when Google
+  // Test is made thread-safe.
+}
+
+TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThreads) {
+  // TODO([email protected]): Test this works correctly when Google Test
+  // is made thread-safe.
+}
+
+}  // namespace
+}  // namespace testing
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_throw_on_failure_ex_test.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_throw_on_failure_ex_test.cc
index 1e3d689e..8bf9dc90 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_throw_on_failure_ex_test.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_throw_on_failure_ex_test.cc
@@ -1,92 +1,92 @@
-// 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: [email protected] (Zhanyong Wan)

-

-// Tests Google Test's throw-on-failure mode with exceptions enabled.

-

-#include <gtest/gtest.h>

-

-#include <stdlib.h>

-#include <stdio.h>

-#include <string.h>

-#include <stdexcept>

-

-// Prints the given failure message and exits the program with

-// non-zero.  We use this instead of a Google Test assertion to

-// indicate a failure, as the latter is been tested and cannot be

-// relied on.

-void Fail(const char* msg) {

-  printf("FAILURE: %s\n", msg);

-  fflush(stdout);

-  exit(1);

-}

-

-// Tests that an assertion failure throws a subclass of

-// std::runtime_error.

-void TestFailureThrowsRuntimeError() {

-  testing::GTEST_FLAG(throw_on_failure) = true;

-

-  // A successful assertion shouldn't throw.

-  try {

-    EXPECT_EQ(3, 3);

-  } catch(...) {

-    Fail("A successful assertion wrongfully threw.");

-  }

-

-  // A failed assertion should throw a subclass of std::runtime_error.

-  try {

-    EXPECT_EQ(2, 3) << "Expected failure";

-  } catch(const std::runtime_error& e) {

-    if (strstr(e.what(), "Expected failure") != NULL)

-      return;

-

-    printf("%s",

-           "A failed assertion did throw an exception of the right type, "

-           "but the message is incorrect.  Instead of containing \"Expected "

-           "failure\", it is:\n");

-    Fail(e.what());

-  } catch(...) {

-    Fail("A failed assertion threw the wrong type of exception.");

-  }

-  Fail("A failed assertion should've thrown but didn't.");

-}

-

-int main(int argc, char** argv) {

-  testing::InitGoogleTest(&argc, argv);

-

-  // We want to ensure that people can use Google Test assertions in

-  // other testing frameworks, as long as they initialize Google Test

-  // properly and set the thrown-on-failure mode.  Therefore, we don't

-  // use Google Test's constructs for defining and running tests

-  // (e.g. TEST and RUN_ALL_TESTS) here.

-

-  TestFailureThrowsRuntimeError();

-  return 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: [email protected] (Zhanyong Wan)
+
+// Tests Google Test's throw-on-failure mode with exceptions enabled.
+
+#include <gtest/gtest.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdexcept>
+
+// Prints the given failure message and exits the program with
+// non-zero.  We use this instead of a Google Test assertion to
+// indicate a failure, as the latter is been tested and cannot be
+// relied on.
+void Fail(const char* msg) {
+  printf("FAILURE: %s\n", msg);
+  fflush(stdout);
+  exit(1);
+}
+
+// Tests that an assertion failure throws a subclass of
+// std::runtime_error.
+void TestFailureThrowsRuntimeError() {
+  testing::GTEST_FLAG(throw_on_failure) = true;
+
+  // A successful assertion shouldn't throw.
+  try {
+    EXPECT_EQ(3, 3);
+  } catch(...) {
+    Fail("A successful assertion wrongfully threw.");
+  }
+
+  // A failed assertion should throw a subclass of std::runtime_error.
+  try {
+    EXPECT_EQ(2, 3) << "Expected failure";
+  } catch(const std::runtime_error& e) {
+    if (strstr(e.what(), "Expected failure") != NULL)
+      return;
+
+    printf("%s",
+           "A failed assertion did throw an exception of the right type, "
+           "but the message is incorrect.  Instead of containing \"Expected "
+           "failure\", it is:\n");
+    Fail(e.what());
+  } catch(...) {
+    Fail("A failed assertion threw the wrong type of exception.");
+  }
+  Fail("A failed assertion should've thrown but didn't.");
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  // We want to ensure that people can use Google Test assertions in
+  // other testing frameworks, as long as they initialize Google Test
+  // properly and set the thrown-on-failure mode.  Therefore, we don't
+  // use Google Test's constructs for defining and running tests
+  // (e.g. TEST and RUN_ALL_TESTS) here.
+
+  TestFailureThrowsRuntimeError();
+  return 0;
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_throw_on_failure_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_throw_on_failure_test_.cc
index 873cadcf..88fbd5a7 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_throw_on_failure_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_throw_on_failure_test_.cc
@@ -1,56 +1,56 @@
-// 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: [email protected] (Zhanyong Wan)

-

-// Tests Google Test's throw-on-failure mode with exceptions disabled.

-//

-// This program must be compiled with exceptions disabled.  It will be

-// invoked by gtest_throw_on_failure_test.py, and is expected to exit

-// with non-zero in the throw-on-failure mode or 0 otherwise.

-

-#include <gtest/gtest.h>

-

-int main(int argc, char** argv) {

-  testing::InitGoogleTest(&argc, argv);

-

-  // We want to ensure that people can use Google Test assertions in

-  // other testing frameworks, as long as they initialize Google Test

-  // properly and set the thrown-on-failure mode.  Therefore, we don't

-  // use Google Test's constructs for defining and running tests

-  // (e.g. TEST and RUN_ALL_TESTS) here.

-

-  // In the throw-on-failure mode with exceptions disabled, this

-  // assertion will cause the program to exit with a non-zero code.

-  EXPECT_EQ(2, 3);

-

-  // When not in the throw-on-failure mode, the control will reach

-  // here.

-  return 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: [email protected] (Zhanyong Wan)
+
+// Tests Google Test's throw-on-failure mode with exceptions disabled.
+//
+// This program must be compiled with exceptions disabled.  It will be
+// invoked by gtest_throw_on_failure_test.py, and is expected to exit
+// with non-zero in the throw-on-failure mode or 0 otherwise.
+
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  // We want to ensure that people can use Google Test assertions in
+  // other testing frameworks, as long as they initialize Google Test
+  // properly and set the thrown-on-failure mode.  Therefore, we don't
+  // use Google Test's constructs for defining and running tests
+  // (e.g. TEST and RUN_ALL_TESTS) here.
+
+  // In the throw-on-failure mode with exceptions disabled, this
+  // assertion will cause the program to exit with a non-zero code.
+  EXPECT_EQ(2, 3);
+
+  // When not in the throw-on-failure mode, the control will reach
+  // here.
+  return 0;
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_uninitialized_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_uninitialized_test_.cc
index 8c2c7008..e8b2aa81 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_uninitialized_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_uninitialized_test_.cc
@@ -1,43 +1,43 @@
-// Copyright 2008, 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: [email protected] (Zhanyong Wan)

-

-#include <gtest/gtest.h>

-

-TEST(DummyTest, Dummy) {

-  // This test doesn't verify anything.  We just need it to create a

-  // realistic stage for testing the behavior of Google Test when

-  // RUN_ALL_TESTS() is called without testing::InitGoogleTest() being

-  // called first.

-}

-

-int main() {

-  return RUN_ALL_TESTS();

-}

+// Copyright 2008, 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: [email protected] (Zhanyong Wan)
+
+#include <gtest/gtest.h>
+
+TEST(DummyTest, Dummy) {
+  // This test doesn't verify anything.  We just need it to create a
+  // realistic stage for testing the behavior of Google Test when
+  // RUN_ALL_TESTS() is called without testing::InitGoogleTest() being
+  // called first.
+}
+
+int main() {
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_unittest.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_unittest.cc
index 24c4ac29..5c69b463 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_unittest.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_unittest.cc
@@ -1,6847 +1,6847 @@
-// Copyright 2005, 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: [email protected] (Zhanyong Wan)

-//

-// Tests for Google Test itself.  This verifies that the basic constructs of

-// Google Test work.

-

-#include <gtest/gtest.h>

-

-// Verifies that the command line flag variables can be accessed

-// in code once <gtest/gtest.h> has been #included.

-// Do not move it after other #includes.

-TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {

-  bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)

-      || testing::GTEST_FLAG(break_on_failure)

-      || testing::GTEST_FLAG(catch_exceptions)

-      || testing::GTEST_FLAG(color) != "unknown"

-      || testing::GTEST_FLAG(filter) != "unknown"

-      || testing::GTEST_FLAG(list_tests)

-      || testing::GTEST_FLAG(output) != "unknown"

-      || testing::GTEST_FLAG(print_time)

-      || testing::GTEST_FLAG(random_seed)

-      || testing::GTEST_FLAG(repeat) > 0

-      || testing::GTEST_FLAG(show_internal_stack_frames)

-      || testing::GTEST_FLAG(shuffle)

-      || testing::GTEST_FLAG(stack_trace_depth) > 0

-      || testing::GTEST_FLAG(throw_on_failure);

-  EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.

-}

-

-#include <gtest/gtest-spi.h>

-

-// 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_

-

-#include <limits.h>  // For INT_MAX.

-#include <stdlib.h>

-#include <time.h>

-

-#if GTEST_HAS_PTHREAD

-#include <pthread.h>

-#endif  // GTEST_HAS_PTHREAD

-

-#ifdef __BORLANDC__

-#include <map>

-#endif

-

-namespace testing {

-namespace internal {

-

-bool ShouldUseColor(bool stdout_is_tty);

-const char* FormatTimeInMillisAsSeconds(TimeInMillis ms);

-bool ParseInt32Flag(const char* str, const char* flag, Int32* value);

-

-// Provides access to otherwise private parts of the TestEventListeners class

-// that are needed to test it.

-class TestEventListenersAccessor {

- public:

-  static TestEventListener* GetRepeater(TestEventListeners* listeners) {

-    return listeners->repeater();

-  }

-

-  static void SetDefaultResultPrinter(TestEventListeners* listeners,

-                                      TestEventListener* listener) {

-    listeners->SetDefaultResultPrinter(listener);

-  }

-  static void SetDefaultXmlGenerator(TestEventListeners* listeners,

-                                     TestEventListener* listener) {

-    listeners->SetDefaultXmlGenerator(listener);

-  }

-

-  static bool EventForwardingEnabled(const TestEventListeners& listeners) {

-    return listeners.EventForwardingEnabled();

-  }

-

-  static void SuppressEventForwarding(TestEventListeners* listeners) {

-    listeners->SuppressEventForwarding();

-  }

-};

-

-}  // namespace internal

-}  // namespace testing

-

-using testing::AssertionFailure;

-using testing::AssertionResult;

-using testing::AssertionSuccess;

-using testing::DoubleLE;

-using testing::EmptyTestEventListener;

-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(death_test_use_fork);

-using testing::GTEST_FLAG(filter);

-using testing::GTEST_FLAG(list_tests);

-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(show_internal_stack_frames);

-using testing::GTEST_FLAG(shuffle);

-using testing::GTEST_FLAG(stack_trace_depth);

-using testing::GTEST_FLAG(throw_on_failure);

-using testing::IsNotSubstring;

-using testing::IsSubstring;

-using testing::Message;

-using testing::ScopedFakeTestPartResultReporter;

-using testing::StaticAssertTypeEq;

-using testing::Test;

-using testing::TestEventListeners;

-using testing::TestCase;

-using testing::TestPartResult;

-using testing::TestPartResultArray;

-using testing::TestProperty;

-using testing::TestResult;

-using testing::UnitTest;

-using testing::internal::AlwaysFalse;

-using testing::internal::AlwaysTrue;

-using testing::internal::AppendUserMessage;

-using testing::internal::CodePointToUtf8;

-using testing::internal::EqFailure;

-using testing::internal::FloatingPoint;

-using testing::internal::FormatTimeInMillisAsSeconds;

-using testing::internal::GTestFlagSaver;

-using testing::internal::GetCurrentOsStackTraceExceptTop;

-using testing::internal::GetNextRandomSeed;

-using testing::internal::GetRandomSeedFromFlag;

-using testing::internal::GetTestTypeId;

-using testing::internal::GetTypeId;

-using testing::internal::GetUnitTestImpl;

-using testing::internal::Int32;

-using testing::internal::Int32FromEnvOrDie;

-using testing::internal::ParseInt32Flag;

-using testing::internal::ShouldRunTestOnShard;

-using testing::internal::ShouldShard;

-using testing::internal::ShouldUseColor;

-using testing::internal::StreamableToString;

-using testing::internal::String;

-using testing::internal::TestEventListenersAccessor;

-using testing::internal::TestResultAccessor;

-using testing::internal::ThreadLocal;

-using testing::internal::UInt32;

-using testing::internal::Vector;

-using testing::internal::WideStringToUtf8;

-using testing::internal::kMaxRandomSeed;

-using testing::internal::kTestTypeIdInGoogleTest;

-using testing::internal::scoped_ptr;

-

-class TestingVector : public Vector<int> {

-};

-

-::std::ostream& operator<<(::std::ostream& os,

-                           const TestingVector& vector) {

-  os << "{ ";

-  for (int i = 0; i < vector.size(); i++) {

-    os << vector.GetElement(i) << " ";

-  }

-  os << "}";

-  return os;

-}

-

-// This line tests that we can define tests in an unnamed namespace.

-namespace {

-

-TEST(GetRandomSeedFromFlagTest, HandlesZero) {

-  const int seed = GetRandomSeedFromFlag(0);

-  EXPECT_LE(1, seed);

-  EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed));

-}

-

-TEST(GetRandomSeedFromFlagTest, PreservesValidSeed) {

-  EXPECT_EQ(1, GetRandomSeedFromFlag(1));

-  EXPECT_EQ(2, GetRandomSeedFromFlag(2));

-  EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1));

-  EXPECT_EQ(static_cast<int>(kMaxRandomSeed),

-            GetRandomSeedFromFlag(kMaxRandomSeed));

-}

-

-TEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) {

-  const int seed1 = GetRandomSeedFromFlag(-1);

-  EXPECT_LE(1, seed1);

-  EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed));

-

-  const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1);

-  EXPECT_LE(1, seed2);

-  EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed));

-}

-

-TEST(GetNextRandomSeedTest, WorksForValidInput) {

-  EXPECT_EQ(2, GetNextRandomSeed(1));

-  EXPECT_EQ(3, GetNextRandomSeed(2));

-  EXPECT_EQ(static_cast<int>(kMaxRandomSeed),

-            GetNextRandomSeed(kMaxRandomSeed - 1));

-  EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed));

-

-  // We deliberately don't test GetNextRandomSeed() with invalid

-  // inputs, as that requires death tests, which are expensive.  This

-  // is fine as GetNextRandomSeed() is internal and has a

-  // straightforward definition.

-}

-

-static void ClearCurrentTestPartResults() {

-  TestResultAccessor::ClearTestPartResults(

-      GetUnitTestImpl()->current_test_result());

-}

-

-// Tests GetTypeId.

-

-TEST(GetTypeIdTest, ReturnsSameValueForSameType) {

-  EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>());

-  EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>());

-}

-

-class SubClassOfTest : public Test {};

-class AnotherSubClassOfTest : public Test {};

-

-TEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) {

-  EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>());

-  EXPECT_NE(GetTypeId<int>(), GetTypeId<char>());

-  EXPECT_NE(GetTypeId<int>(), GetTestTypeId());

-  EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId());

-  EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId());

-  EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>());

-}

-

-// Verifies that GetTestTypeId() returns the same value, no matter it

-// is called from inside Google Test or outside of it.

-TEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) {

-  EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId());

-}

-

-// Tests FormatTimeInMillisAsSeconds().

-

-TEST(FormatTimeInMillisAsSecondsTest, FormatsZero) {

-  EXPECT_STREQ("0", FormatTimeInMillisAsSeconds(0));

-}

-

-TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {

-  EXPECT_STREQ("0.003", FormatTimeInMillisAsSeconds(3));

-  EXPECT_STREQ("0.01", FormatTimeInMillisAsSeconds(10));

-  EXPECT_STREQ("0.2", FormatTimeInMillisAsSeconds(200));

-  EXPECT_STREQ("1.2", FormatTimeInMillisAsSeconds(1200));

-  EXPECT_STREQ("3", FormatTimeInMillisAsSeconds(3000));

-}

-

-TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {

-  EXPECT_STREQ("-0.003", FormatTimeInMillisAsSeconds(-3));

-  EXPECT_STREQ("-0.01", FormatTimeInMillisAsSeconds(-10));

-  EXPECT_STREQ("-0.2", FormatTimeInMillisAsSeconds(-200));

-  EXPECT_STREQ("-1.2", FormatTimeInMillisAsSeconds(-1200));

-  EXPECT_STREQ("-3", FormatTimeInMillisAsSeconds(-3000));

-}

-

-#if !GTEST_OS_SYMBIAN

-// NULL testing does not work with Symbian compilers.

-

-#ifdef __BORLANDC__

-// Silences warnings: "Condition is always true", "Unreachable code"

-#pragma option push -w-ccc -w-rch

-#endif

-

-// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null

-// pointer literal.

-TEST(NullLiteralTest, IsTrueForNullLiterals) {

-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL));

-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0));

-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U));

-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L));

-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(false));

-#ifndef __BORLANDC__

-  // Some compilers may fail to detect some null pointer literals;

-  // as long as users of the framework don't use such literals, this

-  // is harmless.

-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(1 - 1));

-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(true && false));

-#endif

-}

-

-// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null

-// pointer literal.

-TEST(NullLiteralTest, IsFalseForNonNullLiterals) {

-  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1));

-  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0));

-  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a'));

-  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL)));

-}

-

-#ifdef __BORLANDC__

-// Restores warnings after previous "#pragma option push" supressed them

-#pragma option pop

-#endif

-

-#endif  // !GTEST_OS_SYMBIAN

-//

-// Tests CodePointToUtf8().

-

-// Tests that the NUL character L'\0' is encoded correctly.

-TEST(CodePointToUtf8Test, CanEncodeNul) {

-  char buffer[32];

-  EXPECT_STREQ("", CodePointToUtf8(L'\0', buffer));

-}

-

-// Tests that ASCII characters are encoded correctly.

-TEST(CodePointToUtf8Test, CanEncodeAscii) {

-  char buffer[32];

-  EXPECT_STREQ("a", CodePointToUtf8(L'a', buffer));

-  EXPECT_STREQ("Z", CodePointToUtf8(L'Z', buffer));

-  EXPECT_STREQ("&", CodePointToUtf8(L'&', buffer));

-  EXPECT_STREQ("\x7F", CodePointToUtf8(L'\x7F', buffer));

-}

-

-// Tests that Unicode code-points that have 8 to 11 bits are encoded

-// as 110xxxxx 10xxxxxx.

-TEST(CodePointToUtf8Test, CanEncode8To11Bits) {

-  char buffer[32];

-  // 000 1101 0011 => 110-00011 10-010011

-  EXPECT_STREQ("\xC3\x93", CodePointToUtf8(L'\xD3', buffer));

-

-  // 101 0111 0110 => 110-10101 10-110110

-  EXPECT_STREQ("\xD5\xB6", CodePointToUtf8(L'\x576', buffer));

-}

-

-// Tests that Unicode code-points that have 12 to 16 bits are encoded

-// as 1110xxxx 10xxxxxx 10xxxxxx.

-TEST(CodePointToUtf8Test, CanEncode12To16Bits) {

-  char buffer[32];

-  // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011

-  EXPECT_STREQ("\xE0\xA3\x93", CodePointToUtf8(L'\x8D3', buffer));

-

-  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101

-  EXPECT_STREQ("\xEC\x9D\x8D", CodePointToUtf8(L'\xC74D', buffer));

-}

-

-#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.

-

-// Tests that Unicode code-points that have 17 to 21 bits are encoded

-// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx.

-TEST(CodePointToUtf8Test, CanEncode17To21Bits) {

-  char buffer[32];

-  // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011

-  EXPECT_STREQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3', buffer));

-

-  // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000

-  EXPECT_STREQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400', buffer));

-

-  // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100

-  EXPECT_STREQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634', buffer));

-}

-

-// Tests that encoding an invalid code-point generates the expected result.

-TEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) {

-  char buffer[32];

-  EXPECT_STREQ("(Invalid Unicode 0x1234ABCD)",

-               CodePointToUtf8(L'\x1234ABCD', buffer));

-}

-

-#endif  // !GTEST_WIDE_STRING_USES_UTF16_

-

-// Tests WideStringToUtf8().

-

-// Tests that the NUL character L'\0' is encoded correctly.

-TEST(WideStringToUtf8Test, CanEncodeNul) {

-  EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str());

-  EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str());

-}

-

-// Tests that ASCII strings are encoded correctly.

-TEST(WideStringToUtf8Test, CanEncodeAscii) {

-  EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str());

-  EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str());

-  EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str());

-  EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str());

-}

-

-// Tests that Unicode code-points that have 8 to 11 bits are encoded

-// as 110xxxxx 10xxxxxx.

-TEST(WideStringToUtf8Test, CanEncode8To11Bits) {

-  // 000 1101 0011 => 110-00011 10-010011

-  EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str());

-  EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str());

-

-  // 101 0111 0110 => 110-10101 10-110110

-  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", 1).c_str());

-  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", -1).c_str());

-}

-

-// Tests that Unicode code-points that have 12 to 16 bits are encoded

-// as 1110xxxx 10xxxxxx 10xxxxxx.

-TEST(WideStringToUtf8Test, CanEncode12To16Bits) {

-  // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011

-  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", 1).c_str());

-  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", -1).c_str());

-

-  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101

-  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", 1).c_str());

-  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", -1).c_str());

-}

-

-// Tests that the conversion stops when the function encounters \0 character.

-TEST(WideStringToUtf8Test, StopsOnNulCharacter) {

-  EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str());

-}

-

-// Tests that the conversion stops when the function reaches the limit

-// specified by the 'length' parameter.

-TEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) {

-  EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str());

-}

-

-

-#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.

-TEST(WideStringToUtf8Test, CanEncode17To21Bits) {

-  // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011

-  EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str());

-  EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str());

-

-  // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100

-  EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str());

-  EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str());

-}

-

-// Tests that encoding an invalid code-point generates the expected result.

-TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {

-  EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",

-               WideStringToUtf8(L"\xABCDFF", -1).c_str());

-}

-#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) {

-  EXPECT_STREQ("\xF0\x90\x90\x80",

-               WideStringToUtf8(L"\xD801\xDC00", -1).c_str());

-}

-

-// Tests that encoding an invalid UTF-16 surrogate pair

-// generates the expected result.

-TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {

-  // Leading surrogate is at the end of the string.

-  EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(L"\xD800", -1).c_str());

-  // Leading surrogate is not followed by the trailing surrogate.

-  EXPECT_STREQ("\xED\xA0\x80$", WideStringToUtf8(L"\xD800$", -1).c_str());

-  // Trailing surrogate appearas without a leading surrogate.

-  EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(L"\xDC00PQR", -1).c_str());

-}

-#endif  // !GTEST_WIDE_STRING_USES_UTF16_

-

-// Tests that codepoint concatenation works correctly.

-#if !GTEST_WIDE_STRING_USES_UTF16_

-TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {

-  EXPECT_STREQ(

-      "\xF4\x88\x98\xB4"

-          "\xEC\x9D\x8D"

-          "\n"

-          "\xD5\xB6"

-          "\xE0\xA3\x93"

-          "\xF4\x88\x98\xB4",

-      WideStringToUtf8(L"\x108634\xC74D\n\x576\x8D3\x108634", -1).c_str());

-}

-#else

-TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {

-  EXPECT_STREQ(

-      "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",

-      WideStringToUtf8(L"\xC74D\n\x576\x8D3", -1).c_str());

-}

-#endif  // !GTEST_WIDE_STRING_USES_UTF16_

-

-// Tests the Random class.

-

-TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {

-  testing::internal::Random random(42);

-  EXPECT_DEATH_IF_SUPPORTED(

-      random.Generate(0),

-      "Cannot generate a number in the range \\[0, 0\\)");

-  EXPECT_DEATH_IF_SUPPORTED(

-      random.Generate(testing::internal::Random::kMaxRange + 1),

-      "Generation of a number in \\[0, 2147483649\\) was requested, "

-      "but this can only generate numbers in \\[0, 2147483648\\)");

-}

-

-TEST(RandomTest, GeneratesNumbersWithinRange) {

-  const UInt32 kRange = 10000;

-  testing::internal::Random random(12345);

-  for (int i = 0; i < 10; i++) {

-    EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i;

-  }

-

-  testing::internal::Random random2(testing::internal::Random::kMaxRange);

-  for (int i = 0; i < 10; i++) {

-    EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i;

-  }

-}

-

-TEST(RandomTest, RepeatsWhenReseeded) {

-  const int kSeed = 123;

-  const int kArraySize = 10;

-  const UInt32 kRange = 10000;

-  UInt32 values[kArraySize];

-

-  testing::internal::Random random(kSeed);

-  for (int i = 0; i < kArraySize; i++) {

-    values[i] = random.Generate(kRange);

-  }

-

-  random.Reseed(kSeed);

-  for (int i = 0; i < kArraySize; i++) {

-    EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i;

-  }

-}

-

-// Tests the Vector class template.

-

-// Tests Vector::Clear().

-TEST(VectorTest, Clear) {

-  Vector<int> a;

-  a.PushBack(1);

-  a.Clear();

-  EXPECT_EQ(0, a.size());

-

-  a.PushBack(2);

-  a.PushBack(3);

-  a.Clear();

-  EXPECT_EQ(0, a.size());

-}

-

-// Tests Vector::PushBack().

-TEST(VectorTest, PushBack) {

-  Vector<char> a;

-  a.PushBack('a');

-  ASSERT_EQ(1, a.size());

-  EXPECT_EQ('a', a.GetElement(0));

-

-  a.PushBack('b');

-  ASSERT_EQ(2, a.size());

-  EXPECT_EQ('a', a.GetElement(0));

-  EXPECT_EQ('b', a.GetElement(1));

-}

-

-// Tests Vector::PushFront().

-TEST(VectorTest, PushFront) {

-  Vector<int> a;

-  ASSERT_EQ(0, a.size());

-

-  // Calls PushFront() on an empty Vector.

-  a.PushFront(1);

-  ASSERT_EQ(1, a.size());

-  EXPECT_EQ(1, a.GetElement(0));

-

-  // Calls PushFront() on a singleton Vector.

-  a.PushFront(2);

-  ASSERT_EQ(2, a.size());

-  EXPECT_EQ(2, a.GetElement(0));

-  EXPECT_EQ(1, a.GetElement(1));

-

-  // Calls PushFront() on a Vector with more than one elements.

-  a.PushFront(3);

-  ASSERT_EQ(3, a.size());

-  EXPECT_EQ(3, a.GetElement(0));

-  EXPECT_EQ(2, a.GetElement(1));

-  EXPECT_EQ(1, a.GetElement(2));

-}

-

-// Tests Vector::PopFront().

-TEST(VectorTest, PopFront) {

-  Vector<int> a;

-

-  // Popping on an empty Vector should fail.

-  EXPECT_FALSE(a.PopFront(NULL));

-

-  // Popping again on an empty Vector should fail, and the result element

-  // shouldn't be overwritten.

-  int element = 1;

-  EXPECT_FALSE(a.PopFront(&element));

-  EXPECT_EQ(1, element);

-

-  a.PushFront(2);

-  a.PushFront(3);

-

-  // PopFront() should pop the element in the front of the Vector.

-  EXPECT_TRUE(a.PopFront(&element));

-  EXPECT_EQ(3, element);

-

-  // After popping the last element, the Vector should be empty.

-  EXPECT_TRUE(a.PopFront(NULL));

-  EXPECT_EQ(0, a.size());

-}

-

-// Tests inserting at the beginning using Vector::Insert().

-TEST(VectorTest, InsertAtBeginning) {

-  Vector<int> a;

-  ASSERT_EQ(0, a.size());

-

-  // Inserts into an empty Vector.

-  a.Insert(1, 0);

-  ASSERT_EQ(1, a.size());

-  EXPECT_EQ(1, a.GetElement(0));

-

-  // Inserts at the beginning of a singleton Vector.

-  a.Insert(2, 0);

-  ASSERT_EQ(2, a.size());

-  EXPECT_EQ(2, a.GetElement(0));

-  EXPECT_EQ(1, a.GetElement(1));

-

-  // Inserts at the beginning of a Vector with more than one elements.

-  a.Insert(3, 0);

-  ASSERT_EQ(3, a.size());

-  EXPECT_EQ(3, a.GetElement(0));

-  EXPECT_EQ(2, a.GetElement(1));

-  EXPECT_EQ(1, a.GetElement(2));

-}

-

-// Tests inserting at a location other than the beginning using

-// Vector::Insert().

-TEST(VectorTest, InsertNotAtBeginning) {

-  // Prepares a singleton Vector.

-  Vector<int> a;

-  a.PushBack(1);

-

-  // Inserts at the end of a singleton Vector.

-  a.Insert(2, a.size());

-  ASSERT_EQ(2, a.size());

-  EXPECT_EQ(1, a.GetElement(0));

-  EXPECT_EQ(2, a.GetElement(1));

-

-  // Inserts at the end of a Vector with more than one elements.

-  a.Insert(3, a.size());

-  ASSERT_EQ(3, a.size());

-  EXPECT_EQ(1, a.GetElement(0));

-  EXPECT_EQ(2, a.GetElement(1));

-  EXPECT_EQ(3, a.GetElement(2));

-

-  // Inserts in the middle of a Vector.

-  a.Insert(4, 1);

-  ASSERT_EQ(4, a.size());

-  EXPECT_EQ(1, a.GetElement(0));

-  EXPECT_EQ(4, a.GetElement(1));

-  EXPECT_EQ(2, a.GetElement(2));

-  EXPECT_EQ(3, a.GetElement(3));

-}

-

-// Tests Vector::GetElementOr().

-TEST(VectorTest, GetElementOr) {

-  Vector<char> a;

-  EXPECT_EQ('x', a.GetElementOr(0, 'x'));

-

-  a.PushBack('a');

-  a.PushBack('b');

-  EXPECT_EQ('a', a.GetElementOr(0, 'x'));

-  EXPECT_EQ('b', a.GetElementOr(1, 'x'));

-  EXPECT_EQ('x', a.GetElementOr(-2, 'x'));

-  EXPECT_EQ('x', a.GetElementOr(2, 'x'));

-}

-

-TEST(VectorTest, Swap) {

-  Vector<int> a;

-  a.PushBack(0);

-  a.PushBack(1);

-  a.PushBack(2);

-

-  // Swaps an element with itself.

-  a.Swap(0, 0);

-  ASSERT_EQ(0, a.GetElement(0));

-  ASSERT_EQ(1, a.GetElement(1));

-  ASSERT_EQ(2, a.GetElement(2));

-

-  // Swaps two different elements where the indices go up.

-  a.Swap(0, 1);

-  ASSERT_EQ(1, a.GetElement(0));

-  ASSERT_EQ(0, a.GetElement(1));

-  ASSERT_EQ(2, a.GetElement(2));

-

-  // Swaps two different elements where the indices go down.

-  a.Swap(2, 0);

-  ASSERT_EQ(2, a.GetElement(0));

-  ASSERT_EQ(0, a.GetElement(1));

-  ASSERT_EQ(1, a.GetElement(2));

-}

-

-TEST(VectorTest, Clone) {

-  // Clones an empty Vector.

-  Vector<int> a;

-  scoped_ptr<Vector<int> > empty(a.Clone());

-  EXPECT_EQ(0, empty->size());

-

-  // Clones a singleton.

-  a.PushBack(42);

-  scoped_ptr<Vector<int> > singleton(a.Clone());

-  ASSERT_EQ(1, singleton->size());

-  EXPECT_EQ(42, singleton->GetElement(0));

-

-  // Clones a Vector with more elements.

-  a.PushBack(43);

-  a.PushBack(44);

-  scoped_ptr<Vector<int> > big(a.Clone());

-  ASSERT_EQ(3, big->size());

-  EXPECT_EQ(42, big->GetElement(0));

-  EXPECT_EQ(43, big->GetElement(1));

-  EXPECT_EQ(44, big->GetElement(2));

-}

-

-// Tests Vector::Erase().

-TEST(VectorDeathTest, Erase) {

-  Vector<int> a;

-

-  // Tests erasing from an empty vector.

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.Erase(0),

-      "Invalid Vector index 0: must be in range \\[0, -1\\]\\.");

-

-  // Tests erasing from a singleton vector.

-  a.PushBack(0);

-

-  a.Erase(0);

-  EXPECT_EQ(0, a.size());

-

-  // Tests Erase parameters beyond the bounds of the vector.

-  Vector<int> a1;

-  a1.PushBack(0);

-  a1.PushBack(1);

-  a1.PushBack(2);

-

-  EXPECT_DEATH_IF_SUPPORTED(

-      a1.Erase(3),

-      "Invalid Vector index 3: must be in range \\[0, 2\\]\\.");

-  EXPECT_DEATH_IF_SUPPORTED(

-      a1.Erase(-1),

-      "Invalid Vector index -1: must be in range \\[0, 2\\]\\.");

-

-  // Tests erasing at the end of the vector.

-  Vector<int> a2;

-  a2.PushBack(0);

-  a2.PushBack(1);

-  a2.PushBack(2);

-

-  a2.Erase(2);

-  ASSERT_EQ(2, a2.size());

-  EXPECT_EQ(0, a2.GetElement(0));

-  EXPECT_EQ(1, a2.GetElement(1));

-

-  // Tests erasing in the middle of the vector.

-  Vector<int> a3;

-  a3.PushBack(0);

-  a3.PushBack(1);

-  a3.PushBack(2);

-

-  a3.Erase(1);

-  ASSERT_EQ(2, a3.size());

-  EXPECT_EQ(0, a3.GetElement(0));

-  EXPECT_EQ(2, a3.GetElement(1));

-

-  // Tests erasing at the beginning of the vector.

-  Vector<int> a4;

-  a4.PushBack(0);

-  a4.PushBack(1);

-  a4.PushBack(2);

-

-  a4.Erase(0);

-  ASSERT_EQ(2, a4.size());

-  EXPECT_EQ(1, a4.GetElement(0));

-  EXPECT_EQ(2, a4.GetElement(1));

-}

-

-// Tests the GetElement accessor.

-TEST(VectorDeathTest, GetElement) {

-  Vector<int> a;

-  a.PushBack(0);

-  a.PushBack(1);

-  a.PushBack(2);

-  const Vector<int>& b = a;

-

-  EXPECT_EQ(0, b.GetElement(0));

-  EXPECT_EQ(1, b.GetElement(1));

-  EXPECT_EQ(2, b.GetElement(2));

-  EXPECT_DEATH_IF_SUPPORTED(

-      b.GetElement(3),

-      "Invalid Vector index 3: must be in range \\[0, 2\\]\\.");

-  EXPECT_DEATH_IF_SUPPORTED(

-      b.GetElement(-1),

-      "Invalid Vector index -1: must be in range \\[0, 2\\]\\.");

-}

-

-// Tests the GetMutableElement accessor.

-TEST(VectorDeathTest, GetMutableElement) {

-  Vector<int> a;

-  a.PushBack(0);

-  a.PushBack(1);

-  a.PushBack(2);

-

-  EXPECT_EQ(0, a.GetMutableElement(0));

-  EXPECT_EQ(1, a.GetMutableElement(1));

-  EXPECT_EQ(2, a.GetMutableElement(2));

-

-  a.GetMutableElement(0) = 42;

-  EXPECT_EQ(42, a.GetMutableElement(0));

-  EXPECT_EQ(1, a.GetMutableElement(1));

-  EXPECT_EQ(2, a.GetMutableElement(2));

-

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.GetMutableElement(3),

-      "Invalid Vector index 3: must be in range \\[0, 2\\]\\.");

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.GetMutableElement(-1),

-      "Invalid Vector index -1: must be in range \\[0, 2\\]\\.");

-}

-

-TEST(VectorDeathTest, Swap) {

-  Vector<int> a;

-  a.PushBack(0);

-  a.PushBack(1);

-  a.PushBack(2);

-

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.Swap(-1, 1),

-      "Invalid first swap element -1: must be in range \\[0, 2\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.Swap(3, 1),

-      "Invalid first swap element 3: must be in range \\[0, 2\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.Swap(1, -1),

-      "Invalid second swap element -1: must be in range \\[0, 2\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.Swap(1, 3),

-      "Invalid second swap element 3: must be in range \\[0, 2\\]");

-}

-

-TEST(VectorDeathTest, ShuffleRange) {

-  Vector<int> a;

-  a.PushBack(0);

-  a.PushBack(1);

-  a.PushBack(2);

-  testing::internal::Random random(1);

-

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.ShuffleRange(&random, -1, 1),

-      "Invalid shuffle range start -1: must be in range \\[0, 3\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.ShuffleRange(&random, 4, 4),

-      "Invalid shuffle range start 4: must be in range \\[0, 3\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.ShuffleRange(&random, 3, 2),

-      "Invalid shuffle range finish 2: must be in range \\[3, 3\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      a.ShuffleRange(&random, 3, 4),

-      "Invalid shuffle range finish 4: must be in range \\[3, 3\\]");

-}

-

-class VectorShuffleTest : public Test {

- protected:

-  static const int kVectorSize = 20;

-

-  VectorShuffleTest() : random_(1) {

-    for (int i = 0; i < kVectorSize; i++) {

-      vector_.PushBack(i);

-    }

-  }

-

-  static bool VectorIsCorrupt(const TestingVector& vector) {

-    if (kVectorSize != vector.size()) {

-      return true;

-    }

-

-    bool found_in_vector[kVectorSize] = { false };

-    for (int i = 0; i < vector.size(); i++) {

-      const int e = vector.GetElement(i);

-      if (e < 0 || e >= kVectorSize || found_in_vector[e]) {

-        return true;

-      }

-      found_in_vector[e] = true;

-    }

-

-    // Vector size is correct, elements' range is correct, no

-    // duplicate elements.  Therefore no corruption has occurred.

-    return false;

-  }

-

-  static bool VectorIsNotCorrupt(const TestingVector& vector) {

-    return !VectorIsCorrupt(vector);

-  }

-

-  static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) {

-    for (int i = begin; i < end; i++) {

-      if (i != vector.GetElement(i)) {

-        return true;

-      }

-    }

-    return false;

-  }

-

-  static bool RangeIsUnshuffled(

-      const TestingVector& vector, int begin, int end) {

-    return !RangeIsShuffled(vector, begin, end);

-  }

-

-  static bool VectorIsShuffled(const TestingVector& vector) {

-    return RangeIsShuffled(vector, 0, vector.size());

-  }

-

-  static bool VectorIsUnshuffled(const TestingVector& vector) {

-    return !VectorIsShuffled(vector);

-  }

-

-  testing::internal::Random random_;

-  TestingVector vector_;

-};  // class VectorShuffleTest

-

-const int VectorShuffleTest::kVectorSize;

-

-TEST_F(VectorShuffleTest, HandlesEmptyRange) {

-  // Tests an empty range at the beginning...

-  vector_.ShuffleRange(&random_, 0, 0);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...in the middle...

-  vector_.ShuffleRange(&random_, kVectorSize/2, kVectorSize/2);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...at the end...

-  vector_.ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...and past the end.

-  vector_.ShuffleRange(&random_, kVectorSize, kVectorSize);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-}

-

-TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {

-  // Tests a size one range at the beginning...

-  vector_.ShuffleRange(&random_, 0, 1);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...in the middle...

-  vector_.ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...and at the end.

-  vector_.ShuffleRange(&random_, kVectorSize - 1, kVectorSize);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-}

-

-// Because we use our own random number generator and a fixed seed,

-// we can guarantee that the following "random" tests will succeed.

-

-TEST_F(VectorShuffleTest, ShufflesEntireVector) {

-  vector_.Shuffle(&random_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_;

-

-  // Tests the first and last elements in particular to ensure that

-  // there are no off-by-one problems in our shuffle algorithm.

-  EXPECT_NE(0, vector_.GetElement(0));

-  EXPECT_NE(kVectorSize - 1, vector_.GetElement(kVectorSize - 1));

-}

-

-TEST_F(VectorShuffleTest, ShufflesStartOfVector) {

-  const int kRangeSize = kVectorSize/2;

-

-  vector_.ShuffleRange(&random_, 0, kRangeSize);

-

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize);

-  EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize);

-}

-

-TEST_F(VectorShuffleTest, ShufflesEndOfVector) {

-  const int kRangeSize = kVectorSize / 2;

-  vector_.ShuffleRange(&random_, kRangeSize, kVectorSize);

-

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);

-  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize);

-}

-

-TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {

-  int kRangeSize = kVectorSize/3;

-  vector_.ShuffleRange(&random_, kRangeSize, 2*kRangeSize);

-

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);

-  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize);

-  EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize);

-}

-

-TEST_F(VectorShuffleTest, ShufflesRepeatably) {

-  TestingVector vector2;

-  for (int i = 0; i < kVectorSize; i++) {

-    vector2.PushBack(i);

-  }

-

-  random_.Reseed(1234);

-  vector_.Shuffle(&random_);

-  random_.Reseed(1234);

-  vector2.Shuffle(&random_);

-

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector2);

-

-  for (int i = 0; i < kVectorSize; i++) {

-    EXPECT_EQ(vector_.GetElement(i), vector2.GetElement(i))

-        << " where i is " << i;

-  }

-}

-

-// Tests the size of the AssertHelper class.

-

-TEST(AssertHelperTest, AssertHelperIsSmall) {

-  // To avoid breaking clients that use lots of assertions in one

-  // function, we cannot grow the size of AssertHelper.

-  EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*));

-}

-

-// Tests the String class.

-

-// Tests String's constructors.

-TEST(StringTest, Constructors) {

-  // Default ctor.

-  String s1;

-  // We aren't using EXPECT_EQ(NULL, s1.c_str()) because comparing

-  // pointers with NULL isn't supported on all platforms.

-  EXPECT_EQ(0U, s1.length());

-  EXPECT_TRUE(NULL == s1.c_str());

-

-  // Implicitly constructs from a C-string.

-  String s2 = "Hi";

-  EXPECT_EQ(2U, s2.length());

-  EXPECT_STREQ("Hi", s2.c_str());

-

-  // Constructs from a C-string and a length.

-  String s3("hello", 3);

-  EXPECT_EQ(3U, s3.length());

-  EXPECT_STREQ("hel", s3.c_str());

-

-  // The empty String should be created when String is constructed with

-  // a NULL pointer and length 0.

-  EXPECT_EQ(0U, String(NULL, 0).length());

-  EXPECT_FALSE(String(NULL, 0).c_str() == NULL);

-

-  // Constructs a String that contains '\0'.

-  String s4("a\0bcd", 4);

-  EXPECT_EQ(4U, s4.length());

-  EXPECT_EQ('a', s4.c_str()[0]);

-  EXPECT_EQ('\0', s4.c_str()[1]);

-  EXPECT_EQ('b', s4.c_str()[2]);

-  EXPECT_EQ('c', s4.c_str()[3]);

-

-  // Copy ctor where the source is NULL.

-  const String null_str;

-  String s5 = null_str;

-  EXPECT_TRUE(s5.c_str() == NULL);

-

-  // Copy ctor where the source isn't NULL.

-  String s6 = s3;

-  EXPECT_EQ(3U, s6.length());

-  EXPECT_STREQ("hel", s6.c_str());

-

-  // Copy ctor where the source contains '\0'.

-  String s7 = s4;

-  EXPECT_EQ(4U, s7.length());

-  EXPECT_EQ('a', s7.c_str()[0]);

-  EXPECT_EQ('\0', s7.c_str()[1]);

-  EXPECT_EQ('b', s7.c_str()[2]);

-  EXPECT_EQ('c', s7.c_str()[3]);

-}

-

-#if GTEST_HAS_STD_STRING

-

-TEST(StringTest, ConvertsFromStdString) {

-  // An empty std::string.

-  const std::string src1("");

-  const String dest1 = src1;

-  EXPECT_EQ(0U, dest1.length());

-  EXPECT_STREQ("", dest1.c_str());

-

-  // A normal std::string.

-  const std::string src2("Hi");

-  const String dest2 = src2;

-  EXPECT_EQ(2U, dest2.length());

-  EXPECT_STREQ("Hi", dest2.c_str());

-

-  // An std::string with an embedded NUL character.

-  const char src3[] = "a\0b";

-  const String dest3 = std::string(src3, sizeof(src3));

-  EXPECT_EQ(sizeof(src3), dest3.length());

-  EXPECT_EQ('a', dest3.c_str()[0]);

-  EXPECT_EQ('\0', dest3.c_str()[1]);

-  EXPECT_EQ('b', dest3.c_str()[2]);

-}

-

-TEST(StringTest, ConvertsToStdString) {

-  // An empty String.

-  const String src1("");

-  const std::string dest1 = src1;

-  EXPECT_EQ("", dest1);

-

-  // A normal String.

-  const String src2("Hi");

-  const std::string dest2 = src2;

-  EXPECT_EQ("Hi", dest2);

-

-  // A String containing a '\0'.

-  const String src3("x\0y", 3);

-  const std::string dest3 = src3;

-  EXPECT_EQ(std::string("x\0y", 3), dest3);

-}

-

-#endif  // GTEST_HAS_STD_STRING

-

-#if GTEST_HAS_GLOBAL_STRING

-

-TEST(StringTest, ConvertsFromGlobalString) {

-  // An empty ::string.

-  const ::string src1("");

-  const String dest1 = src1;

-  EXPECT_EQ(0U, dest1.length());

-  EXPECT_STREQ("", dest1.c_str());

-

-  // A normal ::string.

-  const ::string src2("Hi");

-  const String dest2 = src2;

-  EXPECT_EQ(2U, dest2.length());

-  EXPECT_STREQ("Hi", dest2.c_str());

-

-  // An ::string with an embedded NUL character.

-  const char src3[] = "x\0y";

-  const String dest3 = ::string(src3, sizeof(src3));

-  EXPECT_EQ(sizeof(src3), dest3.length());

-  EXPECT_EQ('x', dest3.c_str()[0]);

-  EXPECT_EQ('\0', dest3.c_str()[1]);

-  EXPECT_EQ('y', dest3.c_str()[2]);

-}

-

-TEST(StringTest, ConvertsToGlobalString) {

-  // An empty String.

-  const String src1("");

-  const ::string dest1 = src1;

-  EXPECT_EQ("", dest1);

-

-  // A normal String.

-  const String src2("Hi");

-  const ::string dest2 = src2;

-  EXPECT_EQ("Hi", dest2);

-

-  const String src3("x\0y", 3);

-  const ::string dest3 = src3;

-  EXPECT_EQ(::string("x\0y", 3), dest3);

-}

-

-#endif  // GTEST_HAS_GLOBAL_STRING

-

-// Tests String::ShowCStringQuoted().

-TEST(StringTest, ShowCStringQuoted) {

-  EXPECT_STREQ("(null)",

-               String::ShowCStringQuoted(NULL).c_str());

-  EXPECT_STREQ("\"\"",

-               String::ShowCStringQuoted("").c_str());

-  EXPECT_STREQ("\"foo\"",

-               String::ShowCStringQuoted("foo").c_str());

-}

-

-// Tests String::empty().

-TEST(StringTest, Empty) {

-  EXPECT_TRUE(String("").empty());

-  EXPECT_FALSE(String().empty());

-  EXPECT_FALSE(String(NULL).empty());

-  EXPECT_FALSE(String("a").empty());

-  EXPECT_FALSE(String("\0", 1).empty());

-}

-

-// Tests String::Compare().

-TEST(StringTest, Compare) {

-  // NULL vs NULL.

-  EXPECT_EQ(0, String().Compare(String()));

-

-  // NULL vs non-NULL.

-  EXPECT_EQ(-1, String().Compare(String("")));

-

-  // Non-NULL vs NULL.

-  EXPECT_EQ(1, String("").Compare(String()));

-

-  // The following covers non-NULL vs non-NULL.

-

-  // "" vs "".

-  EXPECT_EQ(0, String("").Compare(String("")));

-

-  // "" vs non-"".

-  EXPECT_EQ(-1, String("").Compare(String("\0", 1)));

-  EXPECT_EQ(-1, String("").Compare(" "));

-

-  // Non-"" vs "".

-  EXPECT_EQ(1, String("a").Compare(String("")));

-

-  // The following covers non-"" vs non-"".

-

-  // Same length and equal.

-  EXPECT_EQ(0, String("a").Compare(String("a")));

-

-  // Same length and different.

-  EXPECT_EQ(-1, String("a\0b", 3).Compare(String("a\0c", 3)));

-  EXPECT_EQ(1, String("b").Compare(String("a")));

-

-  // Different lengths.

-  EXPECT_EQ(-1, String("a").Compare(String("ab")));

-  EXPECT_EQ(-1, String("a").Compare(String("a\0", 2)));

-  EXPECT_EQ(1, String("abc").Compare(String("aacd")));

-}

-

-// Tests String::operator==().

-TEST(StringTest, Equals) {

-  const String null(NULL);

-  EXPECT_TRUE(null == NULL);  // NOLINT

-  EXPECT_FALSE(null == "");  // NOLINT

-  EXPECT_FALSE(null == "bar");  // NOLINT

-

-  const String empty("");

-  EXPECT_FALSE(empty == NULL);  // NOLINT

-  EXPECT_TRUE(empty == "");  // NOLINT

-  EXPECT_FALSE(empty == "bar");  // NOLINT

-

-  const String foo("foo");

-  EXPECT_FALSE(foo == NULL);  // NOLINT

-  EXPECT_FALSE(foo == "");  // NOLINT

-  EXPECT_FALSE(foo == "bar");  // NOLINT

-  EXPECT_TRUE(foo == "foo");  // NOLINT

-

-  const String bar("x\0y", 3);

-  EXPECT_FALSE(bar == "x");

-}

-

-// Tests String::operator!=().

-TEST(StringTest, NotEquals) {

-  const String null(NULL);

-  EXPECT_FALSE(null != NULL);  // NOLINT

-  EXPECT_TRUE(null != "");  // NOLINT

-  EXPECT_TRUE(null != "bar");  // NOLINT

-

-  const String empty("");

-  EXPECT_TRUE(empty != NULL);  // NOLINT

-  EXPECT_FALSE(empty != "");  // NOLINT

-  EXPECT_TRUE(empty != "bar");  // NOLINT

-

-  const String foo("foo");

-  EXPECT_TRUE(foo != NULL);  // NOLINT

-  EXPECT_TRUE(foo != "");  // NOLINT

-  EXPECT_TRUE(foo != "bar");  // NOLINT

-  EXPECT_FALSE(foo != "foo");  // NOLINT

-

-  const String bar("x\0y", 3);

-  EXPECT_TRUE(bar != "x");

-}

-

-// Tests String::length().

-TEST(StringTest, Length) {

-  EXPECT_EQ(0U, String().length());

-  EXPECT_EQ(0U, String("").length());

-  EXPECT_EQ(2U, String("ab").length());

-  EXPECT_EQ(3U, String("a\0b", 3).length());

-}

-

-// Tests String::EndsWith().

-TEST(StringTest, EndsWith) {

-  EXPECT_TRUE(String("foobar").EndsWith("bar"));

-  EXPECT_TRUE(String("foobar").EndsWith(""));

-  EXPECT_TRUE(String("").EndsWith(""));

-

-  EXPECT_FALSE(String("foobar").EndsWith("foo"));

-  EXPECT_FALSE(String("").EndsWith("foo"));

-}

-

-// Tests String::EndsWithCaseInsensitive().

-TEST(StringTest, EndsWithCaseInsensitive) {

-  EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("BAR"));

-  EXPECT_TRUE(String("foobaR").EndsWithCaseInsensitive("bar"));

-  EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive(""));

-  EXPECT_TRUE(String("").EndsWithCaseInsensitive(""));

-

-  EXPECT_FALSE(String("Foobar").EndsWithCaseInsensitive("foo"));

-  EXPECT_FALSE(String("foobar").EndsWithCaseInsensitive("Foo"));

-  EXPECT_FALSE(String("").EndsWithCaseInsensitive("foo"));

-}

-

-// C++Builder's preprocessor is buggy; it fails to expand macros that

-// appear in macro parameters after wide char literals.  Provide an alias

-// for NULL as a workaround.

-static const wchar_t* const kNull = NULL;

-

-// Tests String::CaseInsensitiveWideCStringEquals

-TEST(StringTest, CaseInsensitiveWideCStringEquals) {

-  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL));

-  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L""));

-  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull));

-  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar"));

-  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull));

-  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar"));

-  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR"));

-  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar"));

-}

-

-// Tests that NULL can be assigned to a String.

-TEST(StringTest, CanBeAssignedNULL) {

-  const String src(NULL);

-  String dest;

-

-  dest = src;

-  EXPECT_STREQ(NULL, dest.c_str());

-}

-

-// Tests that the empty string "" can be assigned to a String.

-TEST(StringTest, CanBeAssignedEmpty) {

-  const String src("");

-  String dest;

-

-  dest = src;

-  EXPECT_STREQ("", dest.c_str());

-}

-

-// Tests that a non-empty string can be assigned to a String.

-TEST(StringTest, CanBeAssignedNonEmpty) {

-  const String src("hello");

-  String dest;

-  dest = src;

-  EXPECT_EQ(5U, dest.length());

-  EXPECT_STREQ("hello", dest.c_str());

-

-  const String src2("x\0y", 3);

-  String dest2;

-  dest2 = src2;

-  EXPECT_EQ(3U, dest2.length());

-  EXPECT_EQ('x', dest2.c_str()[0]);

-  EXPECT_EQ('\0', dest2.c_str()[1]);

-  EXPECT_EQ('y', dest2.c_str()[2]);

-}

-

-// Tests that a String can be assigned to itself.

-TEST(StringTest, CanBeAssignedSelf) {

-  String dest("hello");

-

-  dest = dest;

-  EXPECT_STREQ("hello", dest.c_str());

-}

-

-// Tests streaming a String.

-TEST(StringTest, Streams) {

-  EXPECT_EQ(StreamableToString(String()), "(null)");

-  EXPECT_EQ(StreamableToString(String("")), "");

-  EXPECT_EQ(StreamableToString(String("a\0b", 3)), "a\\0b");

-}

-

-// Tests that String::Format() works.

-TEST(StringTest, FormatWorks) {

-  // Normal case: the format spec is valid, the arguments match the

-  // spec, and the result is < 4095 characters.

-  EXPECT_STREQ("Hello, 42", String::Format("%s, %d", "Hello", 42).c_str());

-

-  // Edge case: the result is 4095 characters.

-  char buffer[4096];

-  const size_t kSize = sizeof(buffer);

-  memset(buffer, 'a', kSize - 1);

-  buffer[kSize - 1] = '\0';

-  EXPECT_STREQ(buffer, String::Format("%s", buffer).c_str());

-

-  // The result needs to be 4096 characters, exceeding Format()'s limit.

-  EXPECT_STREQ("<formatting error or buffer exceeded>",

-               String::Format("x%s", buffer).c_str());

-

-#if GTEST_OS_LINUX

-  // On Linux, invalid format spec should lead to an error message.

-  // In other environment (e.g. MSVC on Windows), String::Format() may

-  // simply ignore a bad format spec, so this assertion is run on

-  // Linux only.

-  EXPECT_STREQ("<formatting error or buffer exceeded>",

-               String::Format("%").c_str());

-#endif

-}

-

-#if GTEST_OS_WINDOWS

-

-// Tests String::ShowWideCString().

-TEST(StringTest, ShowWideCString) {

-  EXPECT_STREQ("(null)",

-               String::ShowWideCString(NULL).c_str());

-  EXPECT_STREQ("", String::ShowWideCString(L"").c_str());

-  EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());

-}

-

-// Tests String::ShowWideCStringQuoted().

-TEST(StringTest, ShowWideCStringQuoted) {

-  EXPECT_STREQ("(null)",

-               String::ShowWideCStringQuoted(NULL).c_str());

-  EXPECT_STREQ("L\"\"",

-               String::ShowWideCStringQuoted(L"").c_str());

-  EXPECT_STREQ("L\"foo\"",

-               String::ShowWideCStringQuoted(L"foo").c_str());

-}

-

-#if GTEST_OS_WINDOWS_MOBILE

-TEST(StringTest, AnsiAndUtf16Null) {

-  EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));

-  EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));

-}

-

-TEST(StringTest, AnsiAndUtf16ConvertBasic) {

-  const char* ansi = String::Utf16ToAnsi(L"str");

-  EXPECT_STREQ("str", ansi);

-  delete [] ansi;

-  const WCHAR* utf16 = String::AnsiToUtf16("str");

-  EXPECT_EQ(0, wcsncmp(L"str", utf16, 3));

-  delete [] utf16;

-}

-

-TEST(StringTest, AnsiAndUtf16ConvertPathChars) {

-  const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?");

-  EXPECT_STREQ(".:\\ \"*?", ansi);

-  delete [] ansi;

-  const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?");

-  EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3));

-  delete [] utf16;

-}

-#endif  // GTEST_OS_WINDOWS_MOBILE

-

-#endif  // GTEST_OS_WINDOWS

-

-// Tests TestProperty construction.

-TEST(TestPropertyTest, StringValue) {

-  TestProperty property("key", "1");

-  EXPECT_STREQ("key", property.key());

-  EXPECT_STREQ("1", property.value());

-}

-

-// Tests TestProperty replacing a value.

-TEST(TestPropertyTest, ReplaceStringValue) {

-  TestProperty property("key", "1");

-  EXPECT_STREQ("1", property.value());

-  property.SetValue("2");

-  EXPECT_STREQ("2", property.value());

-}

-

-// AddFatalFailure() and AddNonfatalFailure() must be stand-alone

-// functions (i.e. their definitions cannot be inlined at the call

-// sites), or C++Builder won't compile the code.

-static void AddFatalFailure() {

-  FAIL() << "Expected fatal failure.";

-}

-

-static void AddNonfatalFailure() {

-  ADD_FAILURE() << "Expected non-fatal failure.";

-}

-

-class ScopedFakeTestPartResultReporterTest : public Test {

- public:  // Must be public and not protected due to a bug in g++ 3.4.2.

-  enum FailureMode {

-    FATAL_FAILURE,

-    NONFATAL_FAILURE

-  };

-  static void AddFailure(FailureMode failure) {

-    if (failure == FATAL_FAILURE) {

-      AddFatalFailure();

-    } else {

-      AddNonfatalFailure();

-    }

-  }

-};

-

-// Tests that ScopedFakeTestPartResultReporter intercepts test

-// failures.

-TEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) {

-  TestPartResultArray results;

-  {

-    ScopedFakeTestPartResultReporter reporter(

-        ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,

-        &results);

-    AddFailure(NONFATAL_FAILURE);

-    AddFailure(FATAL_FAILURE);

-  }

-

-  EXPECT_EQ(2, results.size());

-  EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());

-  EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());

-}

-

-TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {

-  TestPartResultArray results;

-  {

-    // Tests, that the deprecated constructor still works.

-    ScopedFakeTestPartResultReporter reporter(&results);

-    AddFailure(NONFATAL_FAILURE);

-  }

-  EXPECT_EQ(1, results.size());

-}

-

-#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD

-

-class ScopedFakeTestPartResultReporterWithThreadsTest

-  : public ScopedFakeTestPartResultReporterTest {

- protected:

-  static void AddFailureInOtherThread(FailureMode failure) {

-    pthread_t tid;

-    pthread_create(&tid,

-                   NULL,

-                   ScopedFakeTestPartResultReporterWithThreadsTest::

-                       FailureThread,

-                   &failure);

-    pthread_join(tid, NULL);

-  }

- private:

-  static void* FailureThread(void* attr) {

-    FailureMode* failure = static_cast<FailureMode*>(attr);

-    AddFailure(*failure);

-    return NULL;

-  }

-};

-

-TEST_F(ScopedFakeTestPartResultReporterWithThreadsTest,

-       InterceptsTestFailuresInAllThreads) {

-  TestPartResultArray results;

-  {

-    ScopedFakeTestPartResultReporter reporter(

-        ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results);

-    AddFailure(NONFATAL_FAILURE);

-    AddFailure(FATAL_FAILURE);

-    AddFailureInOtherThread(NONFATAL_FAILURE);

-    AddFailureInOtherThread(FATAL_FAILURE);

-  }

-

-  EXPECT_EQ(4, results.size());

-  EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());

-  EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());

-  EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed());

-  EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed());

-}

-

-#endif  // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD

-

-// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}.  Makes sure that they

-// work even if the failure is generated in a called function rather than

-// the current context.

-

-typedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest;

-

-TEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) {

-  EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure.");

-}

-

-TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {

-  // We have another test below to verify that the macro catches fatal

-  // failures generated on another thread.

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(),

-                                      "Expected fatal failure.");

-}

-

-#ifdef __BORLANDC__

-// Silences warnings: "Condition is always true"

-#pragma option push -w-ccc

-#endif

-

-// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void

-// function even when the statement in it contains ASSERT_*.

-

-int NonVoidFunction() {

-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");

-  return 0;

-}

-

-TEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) {

-  NonVoidFunction();

-}

-

-// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the

-// current function even though 'statement' generates a fatal failure.

-

-void DoesNotAbortHelper(bool* aborted) {

-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");

-

-  *aborted = false;

-}

-

-#ifdef __BORLANDC__

-// Restores warnings after previous "#pragma option push" supressed them

-#pragma option pop

-#endif

-

-TEST_F(ExpectFatalFailureTest, DoesNotAbort) {

-  bool aborted = true;

-  DoesNotAbortHelper(&aborted);

-  EXPECT_FALSE(aborted);

-}

-

-// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a

-// statement that contains a macro which expands to code containing an

-// unprotected comma.

-

-static int global_var = 0;

-#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++

-

-TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {

-#ifndef __BORLANDC__

-  // ICE's in C++Builder 2007.

-  EXPECT_FATAL_FAILURE({

-    GTEST_USE_UNPROTECTED_COMMA_;

-    AddFatalFailure();

-  }, "");

-#endif

-

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS({

-    GTEST_USE_UNPROTECTED_COMMA_;

-    AddFatalFailure();

-  }, "");

-}

-

-// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}.

-

-typedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest;

-

-TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {

-  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),

-                          "Expected non-fatal failure.");

-}

-

-TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {

-  // We have another test below to verify that the macro catches

-  // non-fatal failures generated on another thread.

-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(),

-                                         "Expected non-fatal failure.");

-}

-

-// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a

-// statement that contains a macro which expands to code containing an

-// unprotected comma.

-TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {

-  EXPECT_NONFATAL_FAILURE({

-    GTEST_USE_UNPROTECTED_COMMA_;

-    AddNonfatalFailure();

-  }, "");

-

-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({

-    GTEST_USE_UNPROTECTED_COMMA_;

-    AddNonfatalFailure();

-  }, "");

-}

-

-#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD

-

-typedef ScopedFakeTestPartResultReporterWithThreadsTest

-    ExpectFailureWithThreadsTest;

-

-TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) {

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE),

-                                      "Expected fatal failure.");

-}

-

-TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) {

-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(

-      AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure.");

-}

-

-#endif  // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD

-

-// Tests the TestProperty class.

-

-TEST(TestPropertyTest, ConstructorWorks) {

-  const TestProperty property("key", "value");

-  EXPECT_STREQ("key", property.key());

-  EXPECT_STREQ("value", property.value());

-}

-

-TEST(TestPropertyTest, SetValue) {

-  TestProperty property("key", "value_1");

-  EXPECT_STREQ("key", property.key());

-  property.SetValue("value_2");

-  EXPECT_STREQ("key", property.key());

-  EXPECT_STREQ("value_2", property.value());

-}

-

-// Tests the TestPartResult class.

-

-TEST(TestPartResultTest, ConstructorWorks) {

-  Message message;

-  message << "something is terribly wrong";

-  message << static_cast<const char*>(testing::internal::kStackTraceMarker);

-  message << "some unimportant stack trace";

-

-  const TestPartResult result(TestPartResult::kNonFatalFailure,

-                              "some_file.cc",

-                              42,

-                              message.GetString().c_str());

-

-  EXPECT_EQ(TestPartResult::kNonFatalFailure, result.type());

-  EXPECT_STREQ("some_file.cc", result.file_name());

-  EXPECT_EQ(42, result.line_number());

-  EXPECT_STREQ(message.GetString().c_str(), result.message());

-  EXPECT_STREQ("something is terribly wrong", result.summary());

-}

-

-TEST(TestPartResultTest, ResultAccessorsWork) {

-  const TestPartResult success(TestPartResult::kSuccess,

-                               "file.cc",

-                               42,

-                               "message");

-  EXPECT_TRUE(success.passed());

-  EXPECT_FALSE(success.failed());

-  EXPECT_FALSE(success.nonfatally_failed());

-  EXPECT_FALSE(success.fatally_failed());

-

-  const TestPartResult nonfatal_failure(TestPartResult::kNonFatalFailure,

-                                        "file.cc",

-                                        42,

-                                        "message");

-  EXPECT_FALSE(nonfatal_failure.passed());

-  EXPECT_TRUE(nonfatal_failure.failed());

-  EXPECT_TRUE(nonfatal_failure.nonfatally_failed());

-  EXPECT_FALSE(nonfatal_failure.fatally_failed());

-

-  const TestPartResult fatal_failure(TestPartResult::kFatalFailure,

-                                     "file.cc",

-                                     42,

-                                     "message");

-  EXPECT_FALSE(fatal_failure.passed());

-  EXPECT_TRUE(fatal_failure.failed());

-  EXPECT_FALSE(fatal_failure.nonfatally_failed());

-  EXPECT_TRUE(fatal_failure.fatally_failed());

-}

-

-// Tests the TestResult class

-

-// The test fixture for testing TestResult.

-class TestResultTest : public Test {

- protected:

-  typedef Vector<TestPartResult> TPRVector;

-

-  // We make use of 2 TestPartResult objects,

-  TestPartResult * pr1, * pr2;

-

-  // ... and 3 TestResult objects.

-  TestResult * r0, * r1, * r2;

-

-  virtual void SetUp() {

-    // pr1 is for success.

-    pr1 = new TestPartResult(TestPartResult::kSuccess,

-                             "foo/bar.cc",

-                             10,

-                             "Success!");

-

-    // pr2 is for fatal failure.

-    pr2 = new TestPartResult(TestPartResult::kFatalFailure,

-                             "foo/bar.cc",

-                             -1,  // This line number means "unknown"

-                             "Failure!");

-

-    // Creates the TestResult objects.

-    r0 = new TestResult();

-    r1 = new TestResult();

-    r2 = new TestResult();

-

-    // In order to test TestResult, we need to modify its internal

-    // state, in particular the TestPartResult Vector it holds.

-    // test_part_results() returns a const reference to this Vector.

-    // We cast it to a non-const object s.t. it can be modified (yes,

-    // this is a hack).

-    TPRVector* results1 = const_cast<Vector<TestPartResult> *>(

-        &TestResultAccessor::test_part_results(*r1));

-    TPRVector* results2 = const_cast<Vector<TestPartResult> *>(

-        &TestResultAccessor::test_part_results(*r2));

-

-    // r0 is an empty TestResult.

-

-    // r1 contains a single SUCCESS TestPartResult.

-    results1->PushBack(*pr1);

-

-    // r2 contains a SUCCESS, and a FAILURE.

-    results2->PushBack(*pr1);

-    results2->PushBack(*pr2);

-  }

-

-  virtual void TearDown() {

-    delete pr1;

-    delete pr2;

-

-    delete r0;

-    delete r1;

-    delete r2;

-  }

-

-  // Helper that compares two two TestPartResults.

-  static void CompareTestPartResult(const TestPartResult& expected,

-                                    const TestPartResult& actual) {

-    EXPECT_EQ(expected.type(), actual.type());

-    EXPECT_STREQ(expected.file_name(), actual.file_name());

-    EXPECT_EQ(expected.line_number(), actual.line_number());

-    EXPECT_STREQ(expected.summary(), actual.summary());

-    EXPECT_STREQ(expected.message(), actual.message());

-    EXPECT_EQ(expected.passed(), actual.passed());

-    EXPECT_EQ(expected.failed(), actual.failed());

-    EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed());

-    EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed());

-  }

-};

-

-// Tests TestResult::total_part_count().

-TEST_F(TestResultTest, total_part_count) {

-  ASSERT_EQ(0, r0->total_part_count());

-  ASSERT_EQ(1, r1->total_part_count());

-  ASSERT_EQ(2, r2->total_part_count());

-}

-

-// Tests TestResult::Passed().

-TEST_F(TestResultTest, Passed) {

-  ASSERT_TRUE(r0->Passed());

-  ASSERT_TRUE(r1->Passed());

-  ASSERT_FALSE(r2->Passed());

-}

-

-// Tests TestResult::Failed().

-TEST_F(TestResultTest, Failed) {

-  ASSERT_FALSE(r0->Failed());

-  ASSERT_FALSE(r1->Failed());

-  ASSERT_TRUE(r2->Failed());

-}

-

-// Tests TestResult::GetTestPartResult().

-

-typedef TestResultTest TestResultDeathTest;

-

-TEST_F(TestResultDeathTest, GetTestPartResult) {

-  CompareTestPartResult(*pr1, r2->GetTestPartResult(0));

-  CompareTestPartResult(*pr2, r2->GetTestPartResult(1));

-  EXPECT_DEATH_IF_SUPPORTED(

-      r2->GetTestPartResult(2),

-      "Invalid Vector index 2: must be in range \\[0, 1\\]\\.");

-  EXPECT_DEATH_IF_SUPPORTED(

-      r2->GetTestPartResult(-1),

-      "Invalid Vector index -1: must be in range \\[0, 1\\]\\.");

-}

-

-// Tests TestResult has no properties when none are added.

-TEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) {

-  TestResult test_result;

-  ASSERT_EQ(0, test_result.test_property_count());

-}

-

-// Tests TestResult has the expected property when added.

-TEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) {

-  TestResult test_result;

-  TestProperty property("key_1", "1");

-  TestResultAccessor::RecordProperty(&test_result, property);

-  ASSERT_EQ(1, test_result.test_property_count());

-  const TestProperty& actual_property = test_result.GetTestProperty(0);

-  EXPECT_STREQ("key_1", actual_property.key());

-  EXPECT_STREQ("1", actual_property.value());

-}

-

-// Tests TestResult has multiple properties when added.

-TEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) {

-  TestResult test_result;

-  TestProperty property_1("key_1", "1");

-  TestProperty property_2("key_2", "2");

-  TestResultAccessor::RecordProperty(&test_result, property_1);

-  TestResultAccessor::RecordProperty(&test_result, property_2);

-  ASSERT_EQ(2, test_result.test_property_count());

-  const TestProperty& actual_property_1 = test_result.GetTestProperty(0);

-  EXPECT_STREQ("key_1", actual_property_1.key());

-  EXPECT_STREQ("1", actual_property_1.value());

-

-  const TestProperty& actual_property_2 = test_result.GetTestProperty(1);

-  EXPECT_STREQ("key_2", actual_property_2.key());

-  EXPECT_STREQ("2", actual_property_2.value());

-}

-

-// Tests TestResult::RecordProperty() overrides values for duplicate keys.

-TEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) {

-  TestResult test_result;

-  TestProperty property_1_1("key_1", "1");

-  TestProperty property_2_1("key_2", "2");

-  TestProperty property_1_2("key_1", "12");

-  TestProperty property_2_2("key_2", "22");

-  TestResultAccessor::RecordProperty(&test_result, property_1_1);

-  TestResultAccessor::RecordProperty(&test_result, property_2_1);

-  TestResultAccessor::RecordProperty(&test_result, property_1_2);

-  TestResultAccessor::RecordProperty(&test_result, property_2_2);

-

-  ASSERT_EQ(2, test_result.test_property_count());

-  const TestProperty& actual_property_1 = test_result.GetTestProperty(0);

-  EXPECT_STREQ("key_1", actual_property_1.key());

-  EXPECT_STREQ("12", actual_property_1.value());

-

-  const TestProperty& actual_property_2 = test_result.GetTestProperty(1);

-  EXPECT_STREQ("key_2", actual_property_2.key());

-  EXPECT_STREQ("22", actual_property_2.value());

-}

-

-// Tests TestResult::GetTestProperty().

-TEST(TestResultPropertyDeathTest, GetTestProperty) {

-  TestResult test_result;

-  TestProperty property_1("key_1", "1");

-  TestProperty property_2("key_2", "2");

-  TestProperty property_3("key_3", "3");

-  TestResultAccessor::RecordProperty(&test_result, property_1);

-  TestResultAccessor::RecordProperty(&test_result, property_2);

-  TestResultAccessor::RecordProperty(&test_result, property_3);

-

-  const TestProperty& fetched_property_1 = test_result.GetTestProperty(0);

-  const TestProperty& fetched_property_2 = test_result.GetTestProperty(1);

-  const TestProperty& fetched_property_3 = test_result.GetTestProperty(2);

-

-  EXPECT_STREQ("key_1", fetched_property_1.key());

-  EXPECT_STREQ("1", fetched_property_1.value());

-

-  EXPECT_STREQ("key_2", fetched_property_2.key());

-  EXPECT_STREQ("2", fetched_property_2.value());

-

-  EXPECT_STREQ("key_3", fetched_property_3.key());

-  EXPECT_STREQ("3", fetched_property_3.value());

-

-  EXPECT_DEATH_IF_SUPPORTED(

-      test_result.GetTestProperty(3),

-      "Invalid Vector index 3: must be in range \\[0, 2\\]\\.");

-  EXPECT_DEATH_IF_SUPPORTED(

-      test_result.GetTestProperty(-1),

-      "Invalid Vector index -1: must be in range \\[0, 2\\]\\.");

-}

-

-// When a property using a reserved key is supplied to this function, it tests

-// that a non-fatal failure is added, a fatal failure is not added, and that the

-// property is not recorded.

-void ExpectNonFatalFailureRecordingPropertyWithReservedKey(const char* key) {

-  TestResult test_result;

-  TestProperty property(key, "1");

-  EXPECT_NONFATAL_FAILURE(

-      TestResultAccessor::RecordProperty(&test_result, property),

-      "Reserved key");

-  ASSERT_EQ(0, test_result.test_property_count()) << "Not recorded";

-}

-

-// Attempting to recording a property with the Reserved literal "name"

-// should add a non-fatal failure and the property should not be recorded.

-TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledName) {

-  ExpectNonFatalFailureRecordingPropertyWithReservedKey("name");

-}

-

-// Attempting to recording a property with the Reserved literal "status"

-// should add a non-fatal failure and the property should not be recorded.

-TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledStatus) {

-  ExpectNonFatalFailureRecordingPropertyWithReservedKey("status");

-}

-

-// Attempting to recording a property with the Reserved literal "time"

-// should add a non-fatal failure and the property should not be recorded.

-TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledTime) {

-  ExpectNonFatalFailureRecordingPropertyWithReservedKey("time");

-}

-

-// Attempting to recording a property with the Reserved literal "classname"

-// should add a non-fatal failure and the property should not be recorded.

-TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledClassname) {

-  ExpectNonFatalFailureRecordingPropertyWithReservedKey("classname");

-}

-

-// Tests that GTestFlagSaver works on Windows and Mac.

-

-class GTestFlagSaverTest : public Test {

- protected:

-  // Saves the Google Test flags such that we can restore them later, and

-  // then sets them to their default values.  This will be called

-  // before the first test in this test case is run.

-  static void SetUpTestCase() {

-    saver_ = new GTestFlagSaver;

-

-    GTEST_FLAG(also_run_disabled_tests) = false;

-    GTEST_FLAG(break_on_failure) = false;

-    GTEST_FLAG(catch_exceptions) = false;

-    GTEST_FLAG(death_test_use_fork) = false;

-    GTEST_FLAG(color) = "auto";

-    GTEST_FLAG(filter) = "";

-    GTEST_FLAG(list_tests) = false;

-    GTEST_FLAG(output) = "";

-    GTEST_FLAG(print_time) = true;

-    GTEST_FLAG(random_seed) = 0;

-    GTEST_FLAG(repeat) = 1;

-    GTEST_FLAG(shuffle) = false;

-    GTEST_FLAG(throw_on_failure) = false;

-  }

-

-  // Restores the Google Test flags that the tests have modified.  This will

-  // be called after the last test in this test case is run.

-  static void TearDownTestCase() {

-    delete saver_;

-    saver_ = NULL;

-  }

-

-  // Verifies that the Google Test flags have their default values, and then

-  // modifies each of them.

-  void VerifyAndModifyFlags() {

-    EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests));

-    EXPECT_FALSE(GTEST_FLAG(break_on_failure));

-    EXPECT_FALSE(GTEST_FLAG(catch_exceptions));

-    EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());

-    EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));

-    EXPECT_STREQ("", GTEST_FLAG(filter).c_str());

-    EXPECT_FALSE(GTEST_FLAG(list_tests));

-    EXPECT_STREQ("", GTEST_FLAG(output).c_str());

-    EXPECT_TRUE(GTEST_FLAG(print_time));

-    EXPECT_EQ(0, GTEST_FLAG(random_seed));

-    EXPECT_EQ(1, GTEST_FLAG(repeat));

-    EXPECT_FALSE(GTEST_FLAG(shuffle));

-    EXPECT_FALSE(GTEST_FLAG(throw_on_failure));

-

-    GTEST_FLAG(also_run_disabled_tests) = true;

-    GTEST_FLAG(break_on_failure) = true;

-    GTEST_FLAG(catch_exceptions) = true;

-    GTEST_FLAG(color) = "no";

-    GTEST_FLAG(death_test_use_fork) = true;

-    GTEST_FLAG(filter) = "abc";

-    GTEST_FLAG(list_tests) = true;

-    GTEST_FLAG(output) = "xml:foo.xml";

-    GTEST_FLAG(print_time) = false;

-    GTEST_FLAG(random_seed) = 1;

-    GTEST_FLAG(repeat) = 100;

-    GTEST_FLAG(shuffle) = true;

-    GTEST_FLAG(throw_on_failure) = true;

-  }

- private:

-  // For saving Google Test flags during this test case.

-  static GTestFlagSaver* saver_;

-};

-

-GTestFlagSaver* GTestFlagSaverTest::saver_ = NULL;

-

-// Google Test doesn't guarantee the order of tests.  The following two

-// tests are designed to work regardless of their order.

-

-// Modifies the Google Test flags in the test body.

-TEST_F(GTestFlagSaverTest, ModifyGTestFlags) {

-  VerifyAndModifyFlags();

-}

-

-// Verifies that the Google Test flags in the body of the previous test were

-// restored to their original values.

-TEST_F(GTestFlagSaverTest, VerifyGTestFlags) {

-  VerifyAndModifyFlags();

-}

-

-// Sets an environment variable with the given name to the given

-// value.  If the value argument is "", unsets the environment

-// variable.  The caller must ensure that both arguments are not NULL.

-static void SetEnv(const char* name, const char* value) {

-#if GTEST_OS_WINDOWS_MOBILE

-  // Environment variables are not supported on Windows CE.

-  return;

-#elif defined(__BORLANDC__)

-  // C++Builder's putenv only stores a pointer to its parameter; we have to

-  // ensure that the string remains valid as long as it might be needed.

-  // We use an std::map to do so.

-  static std::map<String, String*> added_env;

-

-  // Because putenv stores a pointer to the string buffer, we can't delete the

-  // previous string (if present) until after it's replaced.

-  String *prev_env = NULL;

-  if (added_env.find(name) != added_env.end()) {

-    prev_env = added_env[name];

-  }

-  added_env[name] = new String((Message() << name << "=" << value).GetString());

-  putenv(added_env[name]->c_str());

-  delete prev_env;

-#elif GTEST_OS_WINDOWS  // If we are on Windows proper.

-  _putenv((Message() << name << "=" << value).GetString().c_str());

-#else

-  if (*value == '\0') {

-    unsetenv(name);

-  } else {

-    setenv(name, value, 1);

-  }

-#endif  // GTEST_OS_WINDOWS_MOBILE

-}

-

-#if !GTEST_OS_WINDOWS_MOBILE

-// Environment variables are not supported on Windows CE.

-

-using testing::internal::Int32FromGTestEnv;

-

-// Tests Int32FromGTestEnv().

-

-// Tests that Int32FromGTestEnv() returns the default value when the

-// environment variable is not set.

-TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {

-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "");

-  EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));

-}

-

-// Tests that Int32FromGTestEnv() returns the default value when the

-// environment variable overflows as an Int32.

-TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {

-  printf("(expecting 2 warnings)\n");

-

-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321");

-  EXPECT_EQ(20, Int32FromGTestEnv("temp", 20));

-

-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321");

-  EXPECT_EQ(30, Int32FromGTestEnv("temp", 30));

-}

-

-// Tests that Int32FromGTestEnv() returns the default value when the

-// environment variable does not represent a valid decimal integer.

-TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {

-  printf("(expecting 2 warnings)\n");

-

-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1");

-  EXPECT_EQ(40, Int32FromGTestEnv("temp", 40));

-

-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X");

-  EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));

-}

-

-// Tests that Int32FromGTestEnv() parses and returns the value of the

-// 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");

-  EXPECT_EQ(123, Int32FromGTestEnv("temp", 0));

-

-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321");

-  EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0));

-}

-#endif  // !GTEST_OS_WINDOWS_MOBILE

-

-// Tests ParseInt32Flag().

-

-// Tests that ParseInt32Flag() returns false and doesn't change the

-// output value when the flag has wrong format

-TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {

-  Int32 value = 123;

-  EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value));

-  EXPECT_EQ(123, value);

-

-  EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value));

-  EXPECT_EQ(123, value);

-}

-

-// Tests that ParseInt32Flag() returns false and doesn't change the

-// output value when the flag overflows as an Int32.

-TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {

-  printf("(expecting 2 warnings)\n");

-

-  Int32 value = 123;

-  EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value));

-  EXPECT_EQ(123, value);

-

-  EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value));

-  EXPECT_EQ(123, value);

-}

-

-// Tests that ParseInt32Flag() returns false and doesn't change the

-// output value when the flag does not represent a valid decimal

-// integer.

-TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {

-  printf("(expecting 2 warnings)\n");

-

-  Int32 value = 123;

-  EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value));

-  EXPECT_EQ(123, value);

-

-  EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value));

-  EXPECT_EQ(123, value);

-}

-

-// Tests that ParseInt32Flag() parses the value of the flag and

-// returns true when the flag represents a valid decimal integer in

-// the range of an Int32.

-TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {

-  Int32 value = 123;

-  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_EQ(-789, value);

-}

-

-// Tests that Int32FromEnvOrDie() parses the value of the var or

-// returns the correct default.

-// Environment variables are not supported on Windows CE.

-#if !GTEST_OS_WINDOWS_MOBILE

-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));

-}

-#endif  // !GTEST_OS_WINDOWS_MOBILE

-

-// 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_IF_SUPPORTED(

-      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_IF_SUPPORTED(

-      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),

-      ".*");

-}

-

-// Tests that ShouldRunTestOnShard() selects all tests

-// where there is 1 shard.

-TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) {

-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0));

-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1));

-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2));

-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3));

-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4));

-}

-

-class ShouldShardTest : public testing::Test {

- protected:

-  virtual void SetUp() {

-    index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX";

-    total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL";

-  }

-

-  virtual void TearDown() {

-    SetEnv(index_var_, "");

-    SetEnv(total_var_, "");

-  }

-

-  const char* index_var_;

-  const char* total_var_;

-};

-

-// Tests that sharding is disabled if neither of the environment variables

-// are set.

-TEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) {

-  SetEnv(index_var_, "");

-  SetEnv(total_var_, "");

-

-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));

-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));

-}

-

-// Tests that sharding is not enabled if total_shards  == 1.

-TEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) {

-  SetEnv(index_var_, "0");

-  SetEnv(total_var_, "1");

-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));

-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));

-}

-

-// Tests that sharding is enabled if total_shards > 1 and

-// we are not in a death test subprocess.

-// Environment variables are not supported on Windows CE.

-#if !GTEST_OS_WINDOWS_MOBILE

-TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {

-  SetEnv(index_var_, "4");

-  SetEnv(total_var_, "22");

-  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));

-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));

-

-  SetEnv(index_var_, "8");

-  SetEnv(total_var_, "9");

-  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));

-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));

-

-  SetEnv(index_var_, "0");

-  SetEnv(total_var_, "9");

-  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));

-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));

-}

-#endif  // !GTEST_OS_WINDOWS_MOBILE

-

-// Tests that we exit in error if the sharding values are not valid.

-

-typedef ShouldShardTest ShouldShardDeathTest;

-

-TEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) {

-  SetEnv(index_var_, "4");

-  SetEnv(total_var_, "4");

-  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");

-

-  SetEnv(index_var_, "4");

-  SetEnv(total_var_, "-2");

-  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");

-

-  SetEnv(index_var_, "5");

-  SetEnv(total_var_, "");

-  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");

-

-  SetEnv(index_var_, "");

-  SetEnv(total_var_, "5");

-  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");

-}

-

-// Tests that ShouldRunTestOnShard is a partition when 5

-// shards are used.

-TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {

-  // Choose an arbitrary number of tests and shards.

-  const int num_tests = 17;

-  const int num_shards = 5;

-

-  // Check partitioning: each test should be on exactly 1 shard.

-  for (int test_id = 0; test_id < num_tests; test_id++) {

-    int prev_selected_shard_index = -1;

-    for (int shard_index = 0; shard_index < num_shards; shard_index++) {

-      if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) {

-        if (prev_selected_shard_index < 0) {

-          prev_selected_shard_index = shard_index;

-        } else {

-          ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and "

-            << shard_index << " are both selected to run test " << test_id;

-        }

-      }

-    }

-  }

-

-  // Check balance: This is not required by the sharding protocol, but is a

-  // desirable property for performance.

-  for (int shard_index = 0; shard_index < num_shards; shard_index++) {

-    int num_tests_on_shard = 0;

-    for (int test_id = 0; test_id < num_tests; test_id++) {

-      num_tests_on_shard +=

-        ShouldRunTestOnShard(num_shards, shard_index, test_id);

-    }

-    EXPECT_GE(num_tests_on_shard, num_tests / num_shards);

-  }

-}

-

-// For the same reason we are not explicitly testing everything in the

-// Test class, there are no separate tests for the following classes

-// (except for some trivial cases):

-//

-//   TestCase, UnitTest, UnitTestResultPrinter.

-//

-// Similarly, there are no separate tests for the following macros:

-//

-//   TEST, TEST_F, RUN_ALL_TESTS

-

-TEST(UnitTestTest, CanGetOriginalWorkingDir) {

-  ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL);

-  EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), "");

-}

-

-// This group of tests is for predicate assertions (ASSERT_PRED*, etc)

-// of various arities.  They do not attempt to be exhaustive.  Rather,

-// view them as smoke tests that can be easily reviewed and verified.

-// A more complete set of tests for predicate assertions can be found

-// in gtest_pred_impl_unittest.cc.

-

-// First, some predicates and predicate-formatters needed by the tests.

-

-// Returns true iff the argument is an even number.

-bool IsEven(int n) {

-  return (n % 2) == 0;

-}

-

-// A functor that returns true iff the argument is an even number.

-struct IsEvenFunctor {

-  bool operator()(int n) { return IsEven(n); }

-};

-

-// A predicate-formatter function that asserts the argument is an even

-// number.

-AssertionResult AssertIsEven(const char* expr, int n) {

-  if (IsEven(n)) {

-    return AssertionSuccess();

-  }

-

-  Message msg;

-  msg << expr << " evaluates to " << n << ", which is not even.";

-  return AssertionFailure(msg);

-}

-

-// A predicate-formatter functor that asserts the argument is an even

-// number.

-struct AssertIsEvenFunctor {

-  AssertionResult operator()(const char* expr, int n) {

-    return AssertIsEven(expr, n);

-  }

-};

-

-// Returns true iff the sum of the arguments is an even number.

-bool SumIsEven2(int n1, int n2) {

-  return IsEven(n1 + n2);

-}

-

-// A functor that returns true iff the sum of the arguments is an even

-// number.

-struct SumIsEven3Functor {

-  bool operator()(int n1, int n2, int n3) {

-    return IsEven(n1 + n2 + n3);

-  }

-};

-

-// A predicate-formatter function that asserts the sum of the

-// arguments is an even number.

-AssertionResult AssertSumIsEven4(

-    const char* e1, const char* e2, const char* e3, const char* e4,

-    int n1, int n2, int n3, int n4) {

-  const int sum = n1 + n2 + n3 + n4;

-  if (IsEven(sum)) {

-    return AssertionSuccess();

-  }

-

-  Message msg;

-  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4

-      << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4

-      << ") evaluates to " << sum << ", which is not even.";

-  return AssertionFailure(msg);

-}

-

-// A predicate-formatter functor that asserts the sum of the arguments

-// is an even number.

-struct AssertSumIsEven5Functor {

-  AssertionResult operator()(

-      const char* e1, const char* e2, const char* e3, const char* e4,

-      const char* e5, int n1, int n2, int n3, int n4, int n5) {

-    const int sum = n1 + n2 + n3 + n4 + n5;

-    if (IsEven(sum)) {

-      return AssertionSuccess();

-    }

-

-    Message msg;

-    msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5

-        << " ("

-        << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5

-        << ") evaluates to " << sum << ", which is not even.";

-    return AssertionFailure(msg);

-  }

-};

-

-

-// Tests unary predicate assertions.

-

-// Tests unary predicate assertions that don't use a custom formatter.

-TEST(Pred1Test, WithoutFormat) {

-  // Success cases.

-  EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!";

-  ASSERT_PRED1(IsEven, 4);

-

-  // Failure cases.

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED1(IsEven, 5) << "This failure is expected.";

-  }, "This failure is expected.");

-  EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5),

-                       "evaluates to false");

-}

-

-// Tests unary predicate assertions that use a custom formatter.

-TEST(Pred1Test, WithFormat) {

-  // Success cases.

-  EXPECT_PRED_FORMAT1(AssertIsEven, 2);

-  ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4)

-    << "This failure is UNEXPECTED!";

-

-  // Failure cases.

-  const int n = 5;

-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n),

-                          "n evaluates to 5, which is not even.");

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";

-  }, "This failure is expected.");

-}

-

-// Tests that unary predicate assertions evaluates their arguments

-// exactly once.

-TEST(Pred1Test, SingleEvaluationOnFailure) {

-  // A success case.

-  static int n = 0;

-  EXPECT_PRED1(IsEven, n++);

-  EXPECT_EQ(1, n) << "The argument is not evaluated exactly once.";

-

-  // A failure case.

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)

-        << "This failure is expected.";

-  }, "This failure is expected.");

-  EXPECT_EQ(2, n) << "The argument is not evaluated exactly once.";

-}

-

-

-// Tests predicate assertions whose arity is >= 2.

-

-// Tests predicate assertions that don't use a custom formatter.

-TEST(PredTest, WithoutFormat) {

-  // Success cases.

-  ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!";

-  EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8);

-

-  // Failure cases.

-  const int n1 = 1;

-  const int n2 = 2;

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";

-  }, "This failure is expected.");

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);

-  }, "evaluates to false");

-}

-

-// Tests predicate assertions that use a custom formatter.

-TEST(PredTest, WithFormat) {

-  // Success cases.

-  ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) <<

-    "This failure is UNEXPECTED!";

-  EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10);

-

-  // Failure cases.

-  const int n1 = 1;

-  const int n2 = 2;

-  const int n3 = 4;

-  const int n4 = 6;

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);

-  }, "evaluates to 13, which is not even.");

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)

-        << "This failure is expected.";

-  }, "This failure is expected.");

-}

-

-// Tests that predicate assertions evaluates their arguments

-// exactly once.

-TEST(PredTest, SingleEvaluationOnFailure) {

-  // A success case.

-  int n1 = 0;

-  int n2 = 0;

-  EXPECT_PRED2(SumIsEven2, n1++, n2++);

-  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";

-  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";

-

-  // Another success case.

-  n1 = n2 = 0;

-  int n3 = 0;

-  int n4 = 0;

-  int n5 = 0;

-  ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(),

-                      n1++, n2++, n3++, n4++, n5++)

-                        << "This failure is UNEXPECTED!";

-  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";

-  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";

-  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";

-  EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";

-  EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once.";

-

-  // A failure case.

-  n1 = n2 = n3 = 0;

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)

-        << "This failure is expected.";

-  }, "This failure is expected.");

-  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";

-  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";

-  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";

-

-  // Another failure case.

-  n1 = n2 = n3 = n4 = 0;

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);

-  }, "evaluates to 1, which is not even.");

-  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";

-  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";

-  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";

-  EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";

-}

-

-

-// Some helper functions for testing using overloaded/template

-// functions with ASSERT_PREDn and EXPECT_PREDn.

-

-bool IsPositive(int n) {

-  return n > 0;

-}

-

-bool IsPositive(double x) {

-  return x > 0;

-}

-

-template <typename T>

-bool IsNegative(T x) {

-  return x < 0;

-}

-

-template <typename T1, typename T2>

-bool GreaterThan(T1 x1, T2 x2) {

-  return x1 > x2;

-}

-

-// Tests that overloaded functions can be used in *_PRED* as long as

-// their types are explicitly specified.

-TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {

-  // C++Builder requires C-style casts rather than static_cast.

-  EXPECT_PRED1((bool (*)(int))(IsPositive), 5);  // NOLINT

-  ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0);  // NOLINT

-}

-

-// Tests that template functions can be used in *_PRED* as long as

-// their types are explicitly specified.

-TEST(PredicateAssertionTest, AcceptsTemplateFunction) {

-  EXPECT_PRED1(IsNegative<int>, -5);

-  // Makes sure that we can handle templates with more than one

-  // parameter.

-  ASSERT_PRED2((GreaterThan<int, int>), 5, 0);

-}

-

-

-// Some helper functions for testing using overloaded/template

-// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn.

-

-AssertionResult IsPositiveFormat(const char* /* expr */, int n) {

-  return n > 0 ? AssertionSuccess() :

-      AssertionFailure(Message() << "Failure");

-}

-

-AssertionResult IsPositiveFormat(const char* /* expr */, double x) {

-  return x > 0 ? AssertionSuccess() :

-      AssertionFailure(Message() << "Failure");

-}

-

-template <typename T>

-AssertionResult IsNegativeFormat(const char* /* expr */, T x) {

-  return x < 0 ? AssertionSuccess() :

-      AssertionFailure(Message() << "Failure");

-}

-

-template <typename T1, typename T2>

-AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */,

-                             const T1& x1, const T2& x2) {

-  return x1 == x2 ? AssertionSuccess() :

-      AssertionFailure(Message() << "Failure");

-}

-

-// Tests that overloaded functions can be used in *_PRED_FORMAT*

-// without explicitly specifying their types.

-TEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) {

-  EXPECT_PRED_FORMAT1(IsPositiveFormat, 5);

-  ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0);

-}

-

-// Tests that template functions can be used in *_PRED_FORMAT* without

-// explicitly specifying their types.

-TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {

-  EXPECT_PRED_FORMAT1(IsNegativeFormat, -5);

-  ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3);

-}

-

-

-// Tests string assertions.

-

-// Tests ASSERT_STREQ with non-NULL arguments.

-TEST(StringAssertionTest, ASSERT_STREQ) {

-  const char * const p1 = "good";

-  ASSERT_STREQ(p1, p1);

-

-  // Let p2 have the same content as p1, but be at a different address.

-  const char p2[] = "good";

-  ASSERT_STREQ(p1, p2);

-

-  EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),

-                       "Expected: \"bad\"");

-}

-

-// Tests ASSERT_STREQ with NULL arguments.

-TEST(StringAssertionTest, ASSERT_STREQ_Null) {

-  ASSERT_STREQ(static_cast<const char *>(NULL), NULL);

-  EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"),

-                       "non-null");

-}

-

-// Tests ASSERT_STREQ with NULL arguments.

-TEST(StringAssertionTest, ASSERT_STREQ_Null2) {

-  EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL),

-                       "non-null");

-}

-

-// Tests ASSERT_STRNE.

-TEST(StringAssertionTest, ASSERT_STRNE) {

-  ASSERT_STRNE("hi", "Hi");

-  ASSERT_STRNE("Hi", NULL);

-  ASSERT_STRNE(NULL, "Hi");

-  ASSERT_STRNE("", NULL);

-  ASSERT_STRNE(NULL, "");

-  ASSERT_STRNE("", "Hi");

-  ASSERT_STRNE("Hi", "");

-  EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"),

-                       "\"Hi\" vs \"Hi\"");

-}

-

-// Tests ASSERT_STRCASEEQ.

-TEST(StringAssertionTest, ASSERT_STRCASEEQ) {

-  ASSERT_STRCASEEQ("hi", "Hi");

-  ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL);

-

-  ASSERT_STRCASEEQ("", "");

-  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"),

-                       "(ignoring case)");

-}

-

-// Tests ASSERT_STRCASENE.

-TEST(StringAssertionTest, ASSERT_STRCASENE) {

-  ASSERT_STRCASENE("hi1", "Hi2");

-  ASSERT_STRCASENE("Hi", NULL);

-  ASSERT_STRCASENE(NULL, "Hi");

-  ASSERT_STRCASENE("", NULL);

-  ASSERT_STRCASENE(NULL, "");

-  ASSERT_STRCASENE("", "Hi");

-  ASSERT_STRCASENE("Hi", "");

-  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"),

-                       "(ignoring case)");

-}

-

-// Tests *_STREQ on wide strings.

-TEST(StringAssertionTest, STREQ_Wide) {

-  // NULL strings.

-  ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL);

-

-  // Empty strings.

-  ASSERT_STREQ(L"", L"");

-

-  // Non-null vs NULL.

-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL),

-                          "non-null");

-

-  // Equal strings.

-  EXPECT_STREQ(L"Hi", L"Hi");

-

-  // Unequal strings.

-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"),

-                          "Abc");

-

-  // Strings containing wide characters.

-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"),

-                          "abc");

-}

-

-// Tests *_STRNE on wide strings.

-TEST(StringAssertionTest, STRNE_Wide) {

-  // NULL strings.

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL);

-  }, "");

-

-  // Empty strings.

-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""),

-                          "L\"\"");

-

-  // Non-null vs NULL.

-  ASSERT_STRNE(L"non-null", NULL);

-

-  // Equal strings.

-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"),

-                          "L\"Hi\"");

-

-  // Unequal strings.

-  EXPECT_STRNE(L"abc", L"Abc");

-

-  // Strings containing wide characters.

-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"),

-                          "abc");

-}

-

-// Tests for ::testing::IsSubstring().

-

-// Tests that IsSubstring() returns the correct result when the input

-// argument type is const char*.

-TEST(IsSubstringTest, ReturnsCorrectResultForCString) {

-  EXPECT_FALSE(IsSubstring("", "", NULL, "a"));

-  EXPECT_FALSE(IsSubstring("", "", "b", NULL));

-  EXPECT_FALSE(IsSubstring("", "", "needle", "haystack"));

-

-  EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL));

-  EXPECT_TRUE(IsSubstring("", "", "needle", "two needles"));

-}

-

-// Tests that IsSubstring() returns the correct result when the input

-// argument type is const wchar_t*.

-TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {

-  EXPECT_FALSE(IsSubstring("", "", kNull, L"a"));

-  EXPECT_FALSE(IsSubstring("", "", L"b", kNull));

-  EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack"));

-

-  EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL));

-  EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles"));

-}

-

-// Tests that IsSubstring() generates the correct message when the input

-// argument type is const char*.

-TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {

-  EXPECT_STREQ("Value of: needle_expr\n"

-               "  Actual: \"needle\"\n"

-               "Expected: a substring of haystack_expr\n"

-               "Which is: \"haystack\"",

-               IsSubstring("needle_expr", "haystack_expr",

-                           "needle", "haystack").failure_message());

-}

-

-#if GTEST_HAS_STD_STRING

-

-// Tests that IsSubstring returns the correct result when the input

-// argument type is ::std::string.

-TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) {

-  EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob"));

-  EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world")));

-}

-

-#endif  // GTEST_HAS_STD_STRING

-

-#if GTEST_HAS_STD_WSTRING

-// Tests that IsSubstring returns the correct result when the input

-// argument type is ::std::wstring.

-TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {

-  EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles"));

-  EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack")));

-}

-

-// Tests that IsSubstring() generates the correct message when the input

-// argument type is ::std::wstring.

-TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {

-  EXPECT_STREQ("Value of: needle_expr\n"

-               "  Actual: L\"needle\"\n"

-               "Expected: a substring of haystack_expr\n"

-               "Which is: L\"haystack\"",

-               IsSubstring(

-                   "needle_expr", "haystack_expr",

-                   ::std::wstring(L"needle"), L"haystack").failure_message());

-}

-

-#endif  // GTEST_HAS_STD_WSTRING

-

-// Tests for ::testing::IsNotSubstring().

-

-// Tests that IsNotSubstring() returns the correct result when the input

-// argument type is const char*.

-TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) {

-  EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack"));

-  EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles"));

-}

-

-// Tests that IsNotSubstring() returns the correct result when the input

-// argument type is const wchar_t*.

-TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {

-  EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack"));

-  EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles"));

-}

-

-// Tests that IsNotSubstring() generates the correct message when the input

-// argument type is const wchar_t*.

-TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {

-  EXPECT_STREQ("Value of: needle_expr\n"

-               "  Actual: L\"needle\"\n"

-               "Expected: not a substring of haystack_expr\n"

-               "Which is: L\"two needles\"",

-               IsNotSubstring(

-                   "needle_expr", "haystack_expr",

-                   L"needle", L"two needles").failure_message());

-}

-

-#if GTEST_HAS_STD_STRING

-

-// Tests that IsNotSubstring returns the correct result when the input

-// argument type is ::std::string.

-TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {

-  EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob"));

-  EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world")));

-}

-

-// Tests that IsNotSubstring() generates the correct message when the input

-// argument type is ::std::string.

-TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {

-  EXPECT_STREQ("Value of: needle_expr\n"

-               "  Actual: \"needle\"\n"

-               "Expected: not a substring of haystack_expr\n"

-               "Which is: \"two needles\"",

-               IsNotSubstring(

-                   "needle_expr", "haystack_expr",

-                   ::std::string("needle"), "two needles").failure_message());

-}

-

-#endif  // GTEST_HAS_STD_STRING

-

-#if GTEST_HAS_STD_WSTRING

-

-// Tests that IsNotSubstring returns the correct result when the input

-// argument type is ::std::wstring.

-TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) {

-  EXPECT_FALSE(

-      IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles"));

-  EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack")));

-}

-

-#endif  // GTEST_HAS_STD_WSTRING

-

-// Tests floating-point assertions.

-

-template <typename RawType>

-class FloatingPointTest : public Test {

- protected:

-

-  // Pre-calculated numbers to be used by the tests.

-  struct TestValues {

-    RawType close_to_positive_zero;

-    RawType close_to_negative_zero;

-    RawType further_from_negative_zero;

-

-    RawType close_to_one;

-    RawType further_from_one;

-

-    RawType infinity;

-    RawType close_to_infinity;

-    RawType further_from_infinity;

-

-    RawType nan1;

-    RawType nan2;

-  };

-

-  typedef typename testing::internal::FloatingPoint<RawType> Floating;

-  typedef typename Floating::Bits Bits;

-

-  virtual void SetUp() {

-    const size_t max_ulps = Floating::kMaxUlps;

-

-    // The bits that represent 0.0.

-    const Bits zero_bits = Floating(0).bits();

-

-    // Makes some numbers close to 0.0.

-    values_.close_to_positive_zero = Floating::ReinterpretBits(

-        zero_bits + max_ulps/2);

-    values_.close_to_negative_zero = -Floating::ReinterpretBits(

-        zero_bits + max_ulps - max_ulps/2);

-    values_.further_from_negative_zero = -Floating::ReinterpretBits(

-        zero_bits + max_ulps + 1 - max_ulps/2);

-

-    // The bits that represent 1.0.

-    const Bits one_bits = Floating(1).bits();

-

-    // Makes some numbers close to 1.0.

-    values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps);

-    values_.further_from_one = Floating::ReinterpretBits(

-        one_bits + max_ulps + 1);

-

-    // +infinity.

-    values_.infinity = Floating::Infinity();

-

-    // The bits that represent +infinity.

-    const Bits infinity_bits = Floating(values_.infinity).bits();

-

-    // Makes some numbers close to infinity.

-    values_.close_to_infinity = Floating::ReinterpretBits(

-        infinity_bits - max_ulps);

-    values_.further_from_infinity = Floating::ReinterpretBits(

-        infinity_bits - max_ulps - 1);

-

-    // Makes some NAN's.  Sets the most significant bit of the fraction so that

-    // our NaN's are quiet; trying to process a signaling NaN would raise an

-    // exception if our environment enables floating point exceptions.

-    values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask

-        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);

-    values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask

-        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);

-  }

-

-  void TestSize() {

-    EXPECT_EQ(sizeof(RawType), sizeof(Bits));

-  }

-

-  static TestValues values_;

-};

-

-template <typename RawType>

-typename FloatingPointTest<RawType>::TestValues

-    FloatingPointTest<RawType>::values_;

-

-// Instantiates FloatingPointTest for testing *_FLOAT_EQ.

-typedef FloatingPointTest<float> FloatTest;

-

-// Tests that the size of Float::Bits matches the size of float.

-TEST_F(FloatTest, Size) {

-  TestSize();

-}

-

-// Tests comparing with +0 and -0.

-TEST_F(FloatTest, Zeros) {

-  EXPECT_FLOAT_EQ(0.0, -0.0);

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0),

-                          "1.0");

-  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5),

-                       "1.5");

-}

-

-// Tests comparing numbers close to 0.

-//

-// This ensures that *_FLOAT_EQ handles the sign correctly and no

-// overflow occurs when comparing numbers whose absolute value is very

-// small.

-TEST_F(FloatTest, AlmostZeros) {

-  // In C++Builder, names within local classes (such as used by

-  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the

-  // scoping class.  Use a static local alias as a workaround.

-  static const FloatTest::TestValues& v(this->values_);

-

-  EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero);

-  EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero);

-  EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero);

-

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_FLOAT_EQ(v.close_to_positive_zero,

-                    v.further_from_negative_zero);

-  }, "v.further_from_negative_zero");

-}

-

-// Tests comparing numbers close to each other.

-TEST_F(FloatTest, SmallDiff) {

-  EXPECT_FLOAT_EQ(1.0, values_.close_to_one);

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one),

-                          "values_.further_from_one");

-}

-

-// Tests comparing numbers far apart.

-TEST_F(FloatTest, LargeDiff) {

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0),

-                          "3.0");

-}

-

-// Tests comparing with infinity.

-//

-// This ensures that no overflow occurs when comparing numbers whose

-// absolute value is very large.

-TEST_F(FloatTest, Infinity) {

-  EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity);

-  EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity);

-#if !GTEST_OS_SYMBIAN

-  // Nokia's STLport crashes if we try to output infinity or NaN.

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity),

-                          "-values_.infinity");

-

-  // This is interesting as the representations of infinity and nan1

-  // are only 1 DLP apart.

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1),

-                          "values_.nan1");

-#endif  // !GTEST_OS_SYMBIAN

-}

-

-// Tests that comparing with NAN always returns false.

-TEST_F(FloatTest, NaN) {

-#if !GTEST_OS_SYMBIAN

-// Nokia's STLport crashes if we try to output infinity or NaN.

-

-  // In C++Builder, names within local classes (such as used by

-  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the

-  // scoping class.  Use a static local alias as a workaround.

-  static const FloatTest::TestValues& v(this->values_);

-

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1),

-                          "v.nan1");

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2),

-                          "v.nan2");

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1),

-                          "v.nan1");

-

-  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity),

-                       "v.infinity");

-#endif  // !GTEST_OS_SYMBIAN

-}

-

-// Tests that *_FLOAT_EQ are reflexive.

-TEST_F(FloatTest, Reflexive) {

-  EXPECT_FLOAT_EQ(0.0, 0.0);

-  EXPECT_FLOAT_EQ(1.0, 1.0);

-  ASSERT_FLOAT_EQ(values_.infinity, values_.infinity);

-}

-

-// Tests that *_FLOAT_EQ are commutative.

-TEST_F(FloatTest, Commutative) {

-  // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one).

-  EXPECT_FLOAT_EQ(values_.close_to_one, 1.0);

-

-  // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one).

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0),

-                          "1.0");

-}

-

-// Tests EXPECT_NEAR.

-TEST_F(FloatTest, EXPECT_NEAR) {

-  EXPECT_NEAR(-1.0f, -1.1f, 0.2f);

-  EXPECT_NEAR(2.0f, 3.0f, 1.0f);

-  EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.2f, 0.1f),  // NOLINT

-                          "The difference between 1.0f and 1.2f is 0.2, "

-                          "which exceeds 0.1f");

-  // To work around a bug in gcc 2.95.0, there is intentionally no

-  // space after the first comma in the previous line.

-}

-

-// Tests ASSERT_NEAR.

-TEST_F(FloatTest, ASSERT_NEAR) {

-  ASSERT_NEAR(-1.0f, -1.1f, 0.2f);

-  ASSERT_NEAR(2.0f, 3.0f, 1.0f);

-  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.2f, 0.1f),  // NOLINT

-                       "The difference between 1.0f and 1.2f is 0.2, "

-                       "which exceeds 0.1f");

-  // To work around a bug in gcc 2.95.0, there is intentionally no

-  // space after the first comma in the previous line.

-}

-

-// Tests the cases where FloatLE() should succeed.

-TEST_F(FloatTest, FloatLESucceeds) {

-  EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f);  // When val1 < val2,

-  ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f);  // val1 == val2,

-

-  // or when val1 is greater than, but almost equals to, val2.

-  EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f);

-}

-

-// Tests the cases where FloatLE() should fail.

-TEST_F(FloatTest, FloatLEFails) {

-  // When val1 is greater than val2 by a large margin,

-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f),

-                          "(2.0f) <= (1.0f)");

-

-  // or by a small yet non-negligible margin,

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);

-  }, "(values_.further_from_one) <= (1.0f)");

-

-#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)

-  // Nokia's STLport crashes if we try to output infinity or NaN.

-  // C++Builder gives bad results for ordered comparisons involving NaNs

-  // due to compiler bugs.

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);

-  }, "(values_.nan1) <= (values_.infinity)");

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);

-  }, "(-values_.infinity) <= (values_.nan1)");

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);

-  }, "(values_.nan1) <= (values_.nan1)");

-#endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)

-}

-

-// Instantiates FloatingPointTest for testing *_DOUBLE_EQ.

-typedef FloatingPointTest<double> DoubleTest;

-

-// Tests that the size of Double::Bits matches the size of double.

-TEST_F(DoubleTest, Size) {

-  TestSize();

-}

-

-// Tests comparing with +0 and -0.

-TEST_F(DoubleTest, Zeros) {

-  EXPECT_DOUBLE_EQ(0.0, -0.0);

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0),

-                          "1.0");

-  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0),

-                       "1.0");

-}

-

-// Tests comparing numbers close to 0.

-//

-// This ensures that *_DOUBLE_EQ handles the sign correctly and no

-// overflow occurs when comparing numbers whose absolute value is very

-// small.

-TEST_F(DoubleTest, AlmostZeros) {

-  // In C++Builder, names within local classes (such as used by

-  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the

-  // scoping class.  Use a static local alias as a workaround.

-  static const DoubleTest::TestValues& v(this->values_);

-

-  EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero);

-  EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero);

-  EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero);

-

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_DOUBLE_EQ(v.close_to_positive_zero,

-                     v.further_from_negative_zero);

-  }, "v.further_from_negative_zero");

-}

-

-// Tests comparing numbers close to each other.

-TEST_F(DoubleTest, SmallDiff) {

-  EXPECT_DOUBLE_EQ(1.0, values_.close_to_one);

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one),

-                          "values_.further_from_one");

-}

-

-// Tests comparing numbers far apart.

-TEST_F(DoubleTest, LargeDiff) {

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0),

-                          "3.0");

-}

-

-// Tests comparing with infinity.

-//

-// This ensures that no overflow occurs when comparing numbers whose

-// absolute value is very large.

-TEST_F(DoubleTest, Infinity) {

-  EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity);

-  EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity);

-#if !GTEST_OS_SYMBIAN

-  // Nokia's STLport crashes if we try to output infinity or NaN.

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity),

-                          "-values_.infinity");

-

-  // This is interesting as the representations of infinity_ and nan1_

-  // are only 1 DLP apart.

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1),

-                          "values_.nan1");

-#endif  // !GTEST_OS_SYMBIAN

-}

-

-// Tests that comparing with NAN always returns false.

-TEST_F(DoubleTest, NaN) {

-#if !GTEST_OS_SYMBIAN

-  // In C++Builder, names within local classes (such as used by

-  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the

-  // scoping class.  Use a static local alias as a workaround.

-  static const DoubleTest::TestValues& v(this->values_);

-

-  // Nokia's STLport crashes if we try to output infinity or NaN.

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1),

-                          "v.nan1");

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");

-  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity),

-                       "v.infinity");

-#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);

-#if !GTEST_OS_SYMBIAN

-  // Nokia's STLport crashes if we try to output infinity or NaN.

-  ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity);

-#endif  // !GTEST_OS_SYMBIAN

-}

-

-// Tests that *_DOUBLE_EQ are commutative.

-TEST_F(DoubleTest, Commutative) {

-  // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one).

-  EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0);

-

-  // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one).

-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0),

-                          "1.0");

-}

-

-// Tests EXPECT_NEAR.

-TEST_F(DoubleTest, EXPECT_NEAR) {

-  EXPECT_NEAR(-1.0, -1.1, 0.2);

-  EXPECT_NEAR(2.0, 3.0, 1.0);

-  EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.2, 0.1),  // NOLINT

-                          "The difference between 1.0 and 1.2 is 0.2, "

-                          "which exceeds 0.1");

-  // To work around a bug in gcc 2.95.0, there is intentionally no

-  // space after the first comma in the previous statement.

-}

-

-// Tests ASSERT_NEAR.

-TEST_F(DoubleTest, ASSERT_NEAR) {

-  ASSERT_NEAR(-1.0, -1.1, 0.2);

-  ASSERT_NEAR(2.0, 3.0, 1.0);

-  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.2, 0.1),  // NOLINT

-                       "The difference between 1.0 and 1.2 is 0.2, "

-                       "which exceeds 0.1");

-  // To work around a bug in gcc 2.95.0, there is intentionally no

-  // space after the first comma in the previous statement.

-}

-

-// Tests the cases where DoubleLE() should succeed.

-TEST_F(DoubleTest, DoubleLESucceeds) {

-  EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0);  // When val1 < val2,

-  ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0);  // val1 == val2,

-

-  // or when val1 is greater than, but almost equals to, val2.

-  EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0);

-}

-

-// Tests the cases where DoubleLE() should fail.

-TEST_F(DoubleTest, DoubleLEFails) {

-  // When val1 is greater than val2 by a large margin,

-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0),

-                          "(2.0) <= (1.0)");

-

-  // or by a small yet non-negligible margin,

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);

-  }, "(values_.further_from_one) <= (1.0)");

-

-#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)

-  // Nokia's STLport crashes if we try to output infinity or NaN.

-  // C++Builder gives bad results for ordered comparisons involving NaNs

-  // due to compiler bugs.

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);

-  }, "(values_.nan1) <= (values_.infinity)");

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);

-  }, " (-values_.infinity) <= (values_.nan1)");

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);

-  }, "(values_.nan1) <= (values_.nan1)");

-#endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)

-}

-

-

-// Verifies that a test or test case whose name starts with DISABLED_ is

-// not run.

-

-// A test whose name starts with DISABLED_.

-// Should not run.

-TEST(DisabledTest, DISABLED_TestShouldNotRun) {

-  FAIL() << "Unexpected failure: Disabled test should not be run.";

-}

-

-// A test whose name does not start with DISABLED_.

-// Should run.

-TEST(DisabledTest, NotDISABLED_TestShouldRun) {

-  EXPECT_EQ(1, 1);

-}

-

-// A test case whose name starts with DISABLED_.

-// Should not run.

-TEST(DISABLED_TestCase, TestShouldNotRun) {

-  FAIL() << "Unexpected failure: Test in disabled test case should not be run.";

-}

-

-// A test case and test whose names start with DISABLED_.

-// Should not run.

-TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) {

-  FAIL() << "Unexpected failure: Test in disabled test case should not be run.";

-}

-

-// Check that when all tests in a test case are disabled, SetupTestCase() and

-// TearDownTestCase() are not called.

-class DisabledTestsTest : public Test {

- protected:

-  static void SetUpTestCase() {

-    FAIL() << "Unexpected failure: All tests disabled in test case. "

-              "SetupTestCase() should not be called.";

-  }

-

-  static void TearDownTestCase() {

-    FAIL() << "Unexpected failure: All tests disabled in test case. "

-              "TearDownTestCase() should not be called.";

-  }

-};

-

-TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) {

-  FAIL() << "Unexpected failure: Disabled test should not be run.";

-}

-

-TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {

-  FAIL() << "Unexpected failure: Disabled test should not be run.";

-}

-

-// Tests that disabled typed tests aren't run.

-

-#if GTEST_HAS_TYPED_TEST

-

-template <typename T>

-class TypedTest : public Test {

-};

-

-typedef testing::Types<int, double> NumericTypes;

-TYPED_TEST_CASE(TypedTest, NumericTypes);

-

-TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {

-  FAIL() << "Unexpected failure: Disabled typed test should not run.";

-}

-

-template <typename T>

-class DISABLED_TypedTest : public Test {

-};

-

-TYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes);

-

-TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {

-  FAIL() << "Unexpected failure: Disabled typed test should not run.";

-}

-

-#endif  // GTEST_HAS_TYPED_TEST

-

-// Tests that disabled type-parameterized tests aren't run.

-

-#if GTEST_HAS_TYPED_TEST_P

-

-template <typename T>

-class TypedTestP : public Test {

-};

-

-TYPED_TEST_CASE_P(TypedTestP);

-

-TYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) {

-  FAIL() << "Unexpected failure: "

-         << "Disabled type-parameterized test should not run.";

-}

-

-REGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun);

-

-INSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes);

-

-template <typename T>

-class DISABLED_TypedTestP : public Test {

-};

-

-TYPED_TEST_CASE_P(DISABLED_TypedTestP);

-

-TYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) {

-  FAIL() << "Unexpected failure: "

-         << "Disabled type-parameterized test should not run.";

-}

-

-REGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun);

-

-INSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes);

-

-#endif  // GTEST_HAS_TYPED_TEST_P

-

-// Tests that assertion macros evaluate their arguments exactly once.

-

-class SingleEvaluationTest : public Test {

- public:  // Must be public and not protected due to a bug in g++ 3.4.2.

-  // This helper function is needed by the FailedASSERT_STREQ test

-  // below.  It's public to work around C++Builder's bug with scoping local

-  // classes.

-  static void CompareAndIncrementCharPtrs() {

-    ASSERT_STREQ(p1_++, p2_++);

-  }

-

-  // This helper function is needed by the FailedASSERT_NE test below.  It's

-  // public to work around C++Builder's bug with scoping local classes.

-  static void CompareAndIncrementInts() {

-    ASSERT_NE(a_++, b_++);

-  }

-

- protected:

-  SingleEvaluationTest() {

-    p1_ = s1_;

-    p2_ = s2_;

-    a_ = 0;

-    b_ = 0;

-  }

-

-  static const char* const s1_;

-  static const char* const s2_;

-  static const char* p1_;

-  static const char* p2_;

-

-  static int a_;

-  static int b_;

-};

-

-const char* const SingleEvaluationTest::s1_ = "01234";

-const char* const SingleEvaluationTest::s2_ = "abcde";

-const char* SingleEvaluationTest::p1_;

-const char* SingleEvaluationTest::p2_;

-int SingleEvaluationTest::a_;

-int SingleEvaluationTest::b_;

-

-// Tests that when ASSERT_STREQ fails, it evaluates its arguments

-// exactly once.

-TEST_F(SingleEvaluationTest, FailedASSERT_STREQ) {

-  EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(),

-                       "p2_++");

-  EXPECT_EQ(s1_ + 1, p1_);

-  EXPECT_EQ(s2_ + 1, p2_);

-}

-

-// Tests that string assertion arguments are evaluated exactly once.

-TEST_F(SingleEvaluationTest, ASSERT_STR) {

-  // successful EXPECT_STRNE

-  EXPECT_STRNE(p1_++, p2_++);

-  EXPECT_EQ(s1_ + 1, p1_);

-  EXPECT_EQ(s2_ + 1, p2_);

-

-  // failed EXPECT_STRCASEEQ

-  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++),

-                          "ignoring case");

-  EXPECT_EQ(s1_ + 2, p1_);

-  EXPECT_EQ(s2_ + 2, p2_);

-}

-

-// Tests that when ASSERT_NE fails, it evaluates its arguments exactly

-// once.

-TEST_F(SingleEvaluationTest, FailedASSERT_NE) {

-  EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(),

-                       "(a_++) != (b_++)");

-  EXPECT_EQ(1, a_);

-  EXPECT_EQ(1, b_);

-}

-

-// Tests that assertion arguments are evaluated exactly once.

-TEST_F(SingleEvaluationTest, OtherCases) {

-  // successful EXPECT_TRUE

-  EXPECT_TRUE(0 == a_++);  // NOLINT

-  EXPECT_EQ(1, a_);

-

-  // failed EXPECT_TRUE

-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++");

-  EXPECT_EQ(2, a_);

-

-  // successful EXPECT_GT

-  EXPECT_GT(a_++, b_++);

-  EXPECT_EQ(3, a_);

-  EXPECT_EQ(1, b_);

-

-  // failed EXPECT_LT

-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)");

-  EXPECT_EQ(4, a_);

-  EXPECT_EQ(2, b_);

-

-  // successful ASSERT_TRUE

-  ASSERT_TRUE(0 < a_++);  // NOLINT

-  EXPECT_EQ(5, a_);

-

-  // successful ASSERT_GT

-  ASSERT_GT(a_++, b_++);

-  EXPECT_EQ(6, a_);

-  EXPECT_EQ(3, b_);

-}

-

-#if GTEST_HAS_EXCEPTIONS

-

-void ThrowAnInteger() {

-  throw 1;

-}

-

-// Tests that assertion arguments are evaluated exactly once.

-TEST_F(SingleEvaluationTest, ExceptionTests) {

-  // successful EXPECT_THROW

-  EXPECT_THROW({  // NOLINT

-    a_++;

-    ThrowAnInteger();

-  }, int);

-  EXPECT_EQ(1, a_);

-

-  // failed EXPECT_THROW, throws different

-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT

-    a_++;

-    ThrowAnInteger();

-  }, bool), "throws a different type");

-  EXPECT_EQ(2, a_);

-

-  // failed EXPECT_THROW, throws nothing

-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing");

-  EXPECT_EQ(3, a_);

-

-  // successful EXPECT_NO_THROW

-  EXPECT_NO_THROW(a_++);

-  EXPECT_EQ(4, a_);

-

-  // failed EXPECT_NO_THROW

-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({  // NOLINT

-    a_++;

-    ThrowAnInteger();

-  }), "it throws");

-  EXPECT_EQ(5, a_);

-

-  // successful EXPECT_ANY_THROW

-  EXPECT_ANY_THROW({  // NOLINT

-    a_++;

-    ThrowAnInteger();

-  });

-  EXPECT_EQ(6, a_);

-

-  // failed EXPECT_ANY_THROW

-  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");

-  EXPECT_EQ(7, a_);

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

-// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE.

-class NoFatalFailureTest : public Test {

- protected:

-  void Succeeds() {}

-  void FailsNonFatal() {

-    ADD_FAILURE() << "some non-fatal failure";

-  }

-  void Fails() {

-    FAIL() << "some fatal failure";

-  }

-

-  void DoAssertNoFatalFailureOnFails() {

-    ASSERT_NO_FATAL_FAILURE(Fails());

-    ADD_FAILURE() << "shold not reach here.";

-  }

-

-  void DoExpectNoFatalFailureOnFails() {

-    EXPECT_NO_FATAL_FAILURE(Fails());

-    ADD_FAILURE() << "other failure";

-  }

-};

-

-TEST_F(NoFatalFailureTest, NoFailure) {

-  EXPECT_NO_FATAL_FAILURE(Succeeds());

-  ASSERT_NO_FATAL_FAILURE(Succeeds());

-}

-

-TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {

-  EXPECT_NONFATAL_FAILURE(

-      EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),

-      "some non-fatal failure");

-  EXPECT_NONFATAL_FAILURE(

-      ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),

-      "some non-fatal failure");

-}

-

-TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {

-  TestPartResultArray gtest_failures;

-  {

-    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);

-    DoAssertNoFatalFailureOnFails();

-  }

-  ASSERT_EQ(2, gtest_failures.size());

-  EXPECT_EQ(TestPartResult::kFatalFailure,

-            gtest_failures.GetTestPartResult(0).type());

-  EXPECT_EQ(TestPartResult::kFatalFailure,

-            gtest_failures.GetTestPartResult(1).type());

-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",

-                      gtest_failures.GetTestPartResult(0).message());

-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",

-                      gtest_failures.GetTestPartResult(1).message());

-}

-

-TEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) {

-  TestPartResultArray gtest_failures;

-  {

-    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);

-    DoExpectNoFatalFailureOnFails();

-  }

-  ASSERT_EQ(3, gtest_failures.size());

-  EXPECT_EQ(TestPartResult::kFatalFailure,

-            gtest_failures.GetTestPartResult(0).type());

-  EXPECT_EQ(TestPartResult::kNonFatalFailure,

-            gtest_failures.GetTestPartResult(1).type());

-  EXPECT_EQ(TestPartResult::kNonFatalFailure,

-            gtest_failures.GetTestPartResult(2).type());

-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",

-                      gtest_failures.GetTestPartResult(0).message());

-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",

-                      gtest_failures.GetTestPartResult(1).message());

-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure",

-                      gtest_failures.GetTestPartResult(2).message());

-}

-

-TEST_F(NoFatalFailureTest, MessageIsStreamable) {

-  TestPartResultArray gtest_failures;

-  {

-    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);

-    EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message";

-  }

-  ASSERT_EQ(2, gtest_failures.size());

-  EXPECT_EQ(TestPartResult::kNonFatalFailure,

-            gtest_failures.GetTestPartResult(0).type());

-  EXPECT_EQ(TestPartResult::kNonFatalFailure,

-            gtest_failures.GetTestPartResult(1).type());

-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo",

-                      gtest_failures.GetTestPartResult(0).message());

-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message",

-                      gtest_failures.GetTestPartResult(1).message());

-}

-

-// Tests non-string assertions.

-

-// Tests EqFailure(), used for implementing *EQ* assertions.

-TEST(AssertionTest, EqFailure) {

-  const String foo_val("5"), bar_val("6");

-  const String msg1(

-      EqFailure("foo", "bar", foo_val, bar_val, false)

-      .failure_message());

-  EXPECT_STREQ(

-      "Value of: bar\n"

-      "  Actual: 6\n"

-      "Expected: foo\n"

-      "Which is: 5",

-      msg1.c_str());

-

-  const String msg2(

-      EqFailure("foo", "6", foo_val, bar_val, false)

-      .failure_message());

-  EXPECT_STREQ(

-      "Value of: 6\n"

-      "Expected: foo\n"

-      "Which is: 5",

-      msg2.c_str());

-

-  const String msg3(

-      EqFailure("5", "bar", foo_val, bar_val, false)

-      .failure_message());

-  EXPECT_STREQ(

-      "Value of: bar\n"

-      "  Actual: 6\n"

-      "Expected: 5",

-      msg3.c_str());

-

-  const String msg4(

-      EqFailure("5", "6", foo_val, bar_val, false).failure_message());

-  EXPECT_STREQ(

-      "Value of: 6\n"

-      "Expected: 5",

-      msg4.c_str());

-

-  const String msg5(

-      EqFailure("foo", "bar",

-                String("\"x\""), String("\"y\""),

-                true).failure_message());

-  EXPECT_STREQ(

-      "Value of: bar\n"

-      "  Actual: \"y\"\n"

-      "Expected: foo (ignoring case)\n"

-      "Which is: \"x\"",

-      msg5.c_str());

-}

-

-// Tests AppendUserMessage(), used for implementing the *EQ* macros.

-TEST(AssertionTest, AppendUserMessage) {

-  const String foo("foo");

-

-  Message msg;

-  EXPECT_STREQ("foo",

-               AppendUserMessage(foo, msg).c_str());

-

-  msg << "bar";

-  EXPECT_STREQ("foo\nbar",

-               AppendUserMessage(foo, msg).c_str());

-}

-

-#ifdef __BORLANDC__

-// Silences warnings: "Condition is always true", "Unreachable code"

-#pragma option push -w-ccc -w-rch

-#endif

-

-// Tests ASSERT_TRUE.

-TEST(AssertionTest, ASSERT_TRUE) {

-  ASSERT_TRUE(2 > 1);  // NOLINT

-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1),

-                       "2 < 1");

-}

-

-// Tests ASSERT_FALSE.

-TEST(AssertionTest, ASSERT_FALSE) {

-  ASSERT_FALSE(2 < 1);  // NOLINT

-  EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1),

-                       "Value of: 2 > 1\n"

-                       "  Actual: true\n"

-                       "Expected: false");

-}

-

-#ifdef __BORLANDC__

-// Restores warnings after previous "#pragma option push" supressed them

-#pragma option pop

-#endif

-

-// Tests using ASSERT_EQ on double values.  The purpose is to make

-// sure that the specialization we did for integer and anonymous enums

-// isn't used for double arguments.

-TEST(ExpectTest, ASSERT_EQ_Double) {

-  // A success.

-  ASSERT_EQ(5.6, 5.6);

-

-  // A failure.

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2),

-                       "5.1");

-}

-

-// Tests ASSERT_EQ.

-TEST(AssertionTest, ASSERT_EQ) {

-  ASSERT_EQ(5, 2 + 3);

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),

-                       "Value of: 2*3\n"

-                       "  Actual: 6\n"

-                       "Expected: 5");

-}

-

-// Tests ASSERT_EQ(NULL, pointer).

-#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.

-TEST(AssertionTest, ASSERT_EQ_NULL) {

-  // A success.

-  const char* p = NULL;

-  // Some older GCC versions may issue a spurious waring in this or the next

-  // assertion statement. This warning should not be suppressed with

-  // static_cast since the test verifies the ability to use bare NULL as the

-  // expected parameter to the macro.

-  ASSERT_EQ(NULL, p);

-

-  // A failure.

-  static int n = 0;

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),

-                       "Value of: &n\n");

-}

-#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

-// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as

-// ASSERT_EQ(static_cast<void*>(NULL), non_pointer).

-TEST(ExpectTest, ASSERT_EQ_0) {

-  int n = 0;

-

-  // A success.

-  ASSERT_EQ(0, n);

-

-  // A failure.

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),

-                       "Expected: 0");

-}

-

-// Tests ASSERT_NE.

-TEST(AssertionTest, ASSERT_NE) {

-  ASSERT_NE(6, 7);

-  EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'),

-                       "Expected: ('a') != ('a'), "

-                       "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");

-}

-

-// Tests ASSERT_LE.

-TEST(AssertionTest, ASSERT_LE) {

-  ASSERT_LE(2, 3);

-  ASSERT_LE(2, 2);

-  EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0),

-                       "Expected: (2) <= (0), actual: 2 vs 0");

-}

-

-// Tests ASSERT_LT.

-TEST(AssertionTest, ASSERT_LT) {

-  ASSERT_LT(2, 3);

-  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2),

-                       "Expected: (2) < (2), actual: 2 vs 2");

-}

-

-// Tests ASSERT_GE.

-TEST(AssertionTest, ASSERT_GE) {

-  ASSERT_GE(2, 1);

-  ASSERT_GE(2, 2);

-  EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3),

-                       "Expected: (2) >= (3), actual: 2 vs 3");

-}

-

-// Tests ASSERT_GT.

-TEST(AssertionTest, ASSERT_GT) {

-  ASSERT_GT(2, 1);

-  EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2),

-                       "Expected: (2) > (2), actual: 2 vs 2");

-}

-

-#if GTEST_HAS_EXCEPTIONS

-

-void ThrowNothing() {}

-

-// Tests ASSERT_THROW.

-TEST(AssertionTest, ASSERT_THROW) {

-  ASSERT_THROW(ThrowAnInteger(), int);

-#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x600 || defined(_DEBUG)

-  // ICE's in C++Builder 2007 (Release build).

-  EXPECT_FATAL_FAILURE(

-      ASSERT_THROW(ThrowAnInteger(), bool),

-      "Expected: ThrowAnInteger() throws an exception of type bool.\n"

-      "  Actual: it throws a different type.");

-#endif

-  EXPECT_FATAL_FAILURE(

-      ASSERT_THROW(ThrowNothing(), bool),

-      "Expected: ThrowNothing() throws an exception of type bool.\n"

-      "  Actual: it throws nothing.");

-}

-

-// Tests ASSERT_NO_THROW.

-TEST(AssertionTest, ASSERT_NO_THROW) {

-  ASSERT_NO_THROW(ThrowNothing());

-  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),

-                       "Expected: ThrowAnInteger() doesn't throw an exception."

-                       "\n  Actual: it throws.");

-}

-

-// Tests ASSERT_ANY_THROW.

-TEST(AssertionTest, ASSERT_ANY_THROW) {

-  ASSERT_ANY_THROW(ThrowAnInteger());

-  EXPECT_FATAL_FAILURE(

-      ASSERT_ANY_THROW(ThrowNothing()),

-      "Expected: ThrowNothing() throws an exception.\n"

-      "  Actual: it doesn't.");

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

-// Makes sure we deal with the precedence of <<.  This test should

-// compile.

-TEST(AssertionTest, AssertPrecedence) {

-  ASSERT_EQ(1 < 2, true);

-  ASSERT_EQ(true && false, false);

-}

-

-// A subroutine used by the following test.

-void TestEq1(int x) {

-  ASSERT_EQ(1, x);

-}

-

-// Tests calling a test subroutine that's not part of a fixture.

-TEST(AssertionTest, NonFixtureSubroutine) {

-  EXPECT_FATAL_FAILURE(TestEq1(2),

-                       "Value of: x");

-}

-

-// An uncopyable class.

-class Uncopyable {

- public:

-  explicit Uncopyable(int value) : value_(value) {}

-

-  int value() const { return value_; }

-  bool operator==(const Uncopyable& rhs) const {

-    return value() == rhs.value();

-  }

- private:

-  // This constructor deliberately has no implementation, as we don't

-  // want this class to be copyable.

-  Uncopyable(const Uncopyable&);  // NOLINT

-

-  int value_;

-};

-

-::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) {

-  return os << value.value();

-}

-

-

-bool IsPositiveUncopyable(const Uncopyable& x) {

-  return x.value() > 0;

-}

-

-// A subroutine used by the following test.

-void TestAssertNonPositive() {

-  Uncopyable y(-1);

-  ASSERT_PRED1(IsPositiveUncopyable, y);

-}

-// A subroutine used by the following test.

-void TestAssertEqualsUncopyable() {

-  Uncopyable x(5);

-  Uncopyable y(-1);

-  ASSERT_EQ(x, y);

-}

-

-// Tests that uncopyable objects can be used in assertions.

-TEST(AssertionTest, AssertWorksWithUncopyableObject) {

-  Uncopyable x(5);

-  ASSERT_PRED1(IsPositiveUncopyable, x);

-  ASSERT_EQ(x, x);

-  EXPECT_FATAL_FAILURE(TestAssertNonPositive(),

-    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");

-  EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),

-    "Value of: y\n  Actual: -1\nExpected: x\nWhich is: 5");

-}

-

-// Tests that uncopyable objects can be used in expects.

-TEST(AssertionTest, ExpectWorksWithUncopyableObject) {

-  Uncopyable x(5);

-  EXPECT_PRED1(IsPositiveUncopyable, x);

-  Uncopyable y(-1);

-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y),

-    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");

-  EXPECT_EQ(x, x);

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),

-    "Value of: y\n  Actual: -1\nExpected: x\nWhich is: 5");

-}

-

-

-// 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 not

-// done on Mac.

-#if !GTEST_OS_MAC

-

-// Tests using assertions with anonymous enums.

-enum {

-  CASE_A = -1,

-#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

-  // (incorrectly) doesn't allow an enum value to exceed the range of

-  // an int, so this has to be conditionally compiled.

-  //

-  // On Linux, CASE_B and CASE_A have the same value when truncated to

-  // int size.  We want to test whether this will confuse the

-  // assertions.

-  CASE_B = testing::internal::kMaxBiggestInt,

-#else

-  CASE_B = INT_MAX,

-#endif  // GTEST_OS_LINUX

-};

-

-TEST(AssertionTest, AnonymousEnum) {

-#if GTEST_OS_LINUX

-  EXPECT_EQ(static_cast<int>(CASE_A), static_cast<int>(CASE_B));

-#endif  // GTEST_OS_LINUX

-

-  EXPECT_EQ(CASE_A, CASE_A);

-  EXPECT_NE(CASE_A, CASE_B);

-  EXPECT_LT(CASE_A, CASE_B);

-  EXPECT_LE(CASE_A, CASE_B);

-  EXPECT_GT(CASE_B, CASE_A);

-  EXPECT_GE(CASE_A, CASE_A);

-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(CASE_A, CASE_B),

-                          "(CASE_A) >= (CASE_B)");

-

-  ASSERT_EQ(CASE_A, CASE_A);

-  ASSERT_NE(CASE_A, CASE_B);

-  ASSERT_LT(CASE_A, CASE_B);

-  ASSERT_LE(CASE_A, CASE_B);

-  ASSERT_GT(CASE_B, CASE_A);

-  ASSERT_GE(CASE_A, CASE_A);

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(CASE_A, CASE_B),

-                       "Value of: CASE_B");

-}

-

-#endif  // !GTEST_OS_MAC

-

-#if GTEST_OS_WINDOWS

-

-static HRESULT UnexpectedHRESULTFailure() {

-  return E_UNEXPECTED;

-}

-

-static HRESULT OkHRESULTSuccess() {

-  return S_OK;

-}

-

-static HRESULT FalseHRESULTSuccess() {

-  return S_FALSE;

-}

-

-// HRESULT assertion tests test both zero and non-zero

-// success codes as well as failure message for each.

-//

-// Windows CE doesn't support message texts.

-TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {

-  EXPECT_HRESULT_SUCCEEDED(S_OK);

-  EXPECT_HRESULT_SUCCEEDED(S_FALSE);

-

-  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),

-    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"

-    "  Actual: 0x8000FFFF");

-}

-

-TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {

-  ASSERT_HRESULT_SUCCEEDED(S_OK);

-  ASSERT_HRESULT_SUCCEEDED(S_FALSE);

-

-  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),

-    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"

-    "  Actual: 0x8000FFFF");

-}

-

-TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {

-  EXPECT_HRESULT_FAILED(E_UNEXPECTED);

-

-  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()),

-    "Expected: (OkHRESULTSuccess()) fails.\n"

-    "  Actual: 0x00000000");

-  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()),

-    "Expected: (FalseHRESULTSuccess()) fails.\n"

-    "  Actual: 0x00000001");

-}

-

-TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {

-  ASSERT_HRESULT_FAILED(E_UNEXPECTED);

-

-#ifndef __BORLANDC__

-  // ICE's in C++Builder 2007 and 2009.

-  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()),

-    "Expected: (OkHRESULTSuccess()) fails.\n"

-    "  Actual: 0x00000000");

-#endif

-  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()),

-    "Expected: (FalseHRESULTSuccess()) fails.\n"

-    "  Actual: 0x00000001");

-}

-

-// Tests that streaming to the HRESULT macros works.

-TEST(HRESULTAssertionTest, Streaming) {

-  EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";

-  ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";

-  EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";

-  ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";

-

-  EXPECT_NONFATAL_FAILURE(

-      EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",

-      "expected failure");

-

-#ifndef __BORLANDC__

-  // ICE's in C++Builder 2007 and 2009.

-  EXPECT_FATAL_FAILURE(

-      ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",

-      "expected failure");

-#endif

-

-  EXPECT_NONFATAL_FAILURE(

-      EXPECT_HRESULT_FAILED(S_OK) << "expected failure",

-      "expected failure");

-

-  EXPECT_FATAL_FAILURE(

-      ASSERT_HRESULT_FAILED(S_OK) << "expected failure",

-      "expected failure");

-}

-

-#endif  // GTEST_OS_WINDOWS

-

-#ifdef __BORLANDC__

-// Silences warnings: "Condition is always true", "Unreachable code"

-#pragma option push -w-ccc -w-rch

-#endif

-

-// Tests that the assertion macros behave like single statements.

-TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {

-  if (AlwaysFalse())

-    ASSERT_TRUE(false) << "This should never be executed; "

-                          "It's a compilation test only.";

-

-  if (AlwaysTrue())

-    EXPECT_FALSE(false);

-  else

-    ;  // NOLINT

-

-  if (AlwaysFalse())

-    ASSERT_LT(1, 3);

-

-  if (AlwaysFalse())

-    ;  // NOLINT

-  else

-    EXPECT_GT(3, 2) << "";

-}

-

-#if GTEST_HAS_EXCEPTIONS

-// Tests that the compiler will not complain about unreachable code in the

-// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros.

-TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {

-  int n = 0;

-

-  EXPECT_THROW(throw 1, int);

-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), "");

-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), "");

-  EXPECT_NO_THROW(n++);

-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), "");

-  EXPECT_ANY_THROW(throw 1);

-  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), "");

-}

-

-TEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) {

-  if (AlwaysFalse())

-    EXPECT_THROW(ThrowNothing(), bool);

-

-  if (AlwaysTrue())

-    EXPECT_THROW(ThrowAnInteger(), int);

-  else

-    ;  // NOLINT

-

-  if (AlwaysFalse())

-    EXPECT_NO_THROW(ThrowAnInteger());

-

-  if (AlwaysTrue())

-    EXPECT_NO_THROW(ThrowNothing());

-  else

-    ;  // NOLINT

-

-  if (AlwaysFalse())

-    EXPECT_ANY_THROW(ThrowNothing());

-

-  if (AlwaysTrue())

-    EXPECT_ANY_THROW(ThrowAnInteger());

-  else

-    ;  // NOLINT

-}

-#endif  // GTEST_HAS_EXCEPTIONS

-

-TEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) {

-  if (AlwaysFalse())

-    EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. "

-                                    << "It's a compilation test only.";

-  else

-    ;  // NOLINT

-

-  if (AlwaysFalse())

-    ASSERT_NO_FATAL_FAILURE(FAIL()) << "";

-  else

-    ;  // NOLINT

-

-  if (AlwaysTrue())

-    EXPECT_NO_FATAL_FAILURE(SUCCEED());

-  else

-    ;  // NOLINT

-

-  if (AlwaysFalse())

-    ;  // NOLINT

-  else

-    ASSERT_NO_FATAL_FAILURE(SUCCEED());

-}

-

-// Tests that the assertion macros work well with switch statements.

-TEST(AssertionSyntaxTest, WorksWithSwitch) {

-  switch (0) {

-    case 1:

-      break;

-    default:

-      ASSERT_TRUE(true);

-  }

-

-  switch (0)

-    case 0:

-      EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";

-

-  // Binary assertions are implemented using a different code path

-  // than the Boolean assertions.  Hence we test them separately.

-  switch (0) {

-    case 1:

-    default:

-      ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler";

-  }

-

-  switch (0)

-    case 0:

-      EXPECT_NE(1, 2);

-}

-

-#if GTEST_HAS_EXCEPTIONS

-

-void ThrowAString() {

-    throw "String";

-}

-

-// Test that the exception assertion macros compile and work with const

-// type qualifier.

-TEST(AssertionSyntaxTest, WorksWithConst) {

-    ASSERT_THROW(ThrowAString(), const char*);

-

-    EXPECT_THROW(ThrowAString(), const char*);

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

-}  // namespace

-

-namespace testing {

-

-// Tests that Google Test tracks SUCCEED*.

-TEST(SuccessfulAssertionTest, SUCCEED) {

-  SUCCEED();

-  SUCCEED() << "OK";

-  EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count());

-}

-

-// Tests that Google Test doesn't track successful EXPECT_*.

-TEST(SuccessfulAssertionTest, EXPECT) {

-  EXPECT_TRUE(true);

-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());

-}

-

-// Tests that Google Test doesn't track successful EXPECT_STR*.

-TEST(SuccessfulAssertionTest, EXPECT_STR) {

-  EXPECT_STREQ("", "");

-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());

-}

-

-// Tests that Google Test doesn't track successful ASSERT_*.

-TEST(SuccessfulAssertionTest, ASSERT) {

-  ASSERT_TRUE(true);

-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());

-}

-

-// Tests that Google Test doesn't track successful ASSERT_STR*.

-TEST(SuccessfulAssertionTest, ASSERT_STR) {

-  ASSERT_STREQ("", "");

-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());

-}

-

-}  // namespace testing

-

-namespace {

-

-// Tests EXPECT_TRUE.

-TEST(ExpectTest, EXPECT_TRUE) {

-  EXPECT_TRUE(2 > 1);  // NOLINT

-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1),

-                          "Value of: 2 < 1\n"

-                          "  Actual: false\n"

-                          "Expected: true");

-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3),

-                          "2 > 3");

-}

-

-// Tests EXPECT_FALSE.

-TEST(ExpectTest, EXPECT_FALSE) {

-  EXPECT_FALSE(2 < 1);  // NOLINT

-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1),

-                          "Value of: 2 > 1\n"

-                          "  Actual: true\n"

-                          "Expected: false");

-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3),

-                          "2 < 3");

-}

-

-#ifdef __BORLANDC__

-// Restores warnings after previous "#pragma option push" supressed them

-#pragma option pop

-#endif

-

-// Tests EXPECT_EQ.

-TEST(ExpectTest, EXPECT_EQ) {

-  EXPECT_EQ(5, 2 + 3);

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),

-                          "Value of: 2*3\n"

-                          "  Actual: 6\n"

-                          "Expected: 5");

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),

-                          "2 - 3");

-}

-

-// Tests using EXPECT_EQ on double values.  The purpose is to make

-// sure that the specialization we did for integer and anonymous enums

-// isn't used for double arguments.

-TEST(ExpectTest, EXPECT_EQ_Double) {

-  // A success.

-  EXPECT_EQ(5.6, 5.6);

-

-  // A failure.

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2),

-                          "5.1");

-}

-

-#if !GTEST_OS_SYMBIAN

-// Tests EXPECT_EQ(NULL, pointer).

-TEST(ExpectTest, EXPECT_EQ_NULL) {

-  // A success.

-  const char* p = NULL;

-  // Some older GCC versions may issue a spurious waring in this or the next

-  // assertion statement. This warning should not be suppressed with

-  // static_cast since the test verifies the ability to use bare NULL as the

-  // expected parameter to the macro.

-  EXPECT_EQ(NULL, p);

-

-  // A failure.

-  int n = 0;

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),

-                          "Value of: &n\n");

-}

-#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

-// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as

-// EXPECT_EQ(static_cast<void*>(NULL), non_pointer).

-TEST(ExpectTest, EXPECT_EQ_0) {

-  int n = 0;

-

-  // A success.

-  EXPECT_EQ(0, n);

-

-  // A failure.

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),

-                          "Expected: 0");

-}

-

-// Tests EXPECT_NE.

-TEST(ExpectTest, EXPECT_NE) {

-  EXPECT_NE(6, 7);

-

-  EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'),

-                          "Expected: ('a') != ('a'), "

-                          "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");

-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2),

-                          "2");

-  char* const p0 = NULL;

-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0),

-                          "p0");

-  // Only way to get the Nokia compiler to compile the cast

-  // is to have a separate void* variable first. Putting

-  // the two casts on the same line doesn't work, neither does

-  // a direct C-style to char*.

-  void* pv1 = (void*)0x1234;  // NOLINT

-  char* const p1 = reinterpret_cast<char*>(pv1);

-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1),

-                          "p1");

-}

-

-// Tests EXPECT_LE.

-TEST(ExpectTest, EXPECT_LE) {

-  EXPECT_LE(2, 3);

-  EXPECT_LE(2, 2);

-  EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0),

-                          "Expected: (2) <= (0), actual: 2 vs 0");

-  EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9),

-                          "(1.1) <= (0.9)");

-}

-

-// Tests EXPECT_LT.

-TEST(ExpectTest, EXPECT_LT) {

-  EXPECT_LT(2, 3);

-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2),

-                          "Expected: (2) < (2), actual: 2 vs 2");

-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1),

-                          "(2) < (1)");

-}

-

-// Tests EXPECT_GE.

-TEST(ExpectTest, EXPECT_GE) {

-  EXPECT_GE(2, 1);

-  EXPECT_GE(2, 2);

-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3),

-                          "Expected: (2) >= (3), actual: 2 vs 3");

-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1),

-                          "(0.9) >= (1.1)");

-}

-

-// Tests EXPECT_GT.

-TEST(ExpectTest, EXPECT_GT) {

-  EXPECT_GT(2, 1);

-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2),

-                          "Expected: (2) > (2), actual: 2 vs 2");

-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3),

-                          "(2) > (3)");

-}

-

-#if GTEST_HAS_EXCEPTIONS

-

-// Tests EXPECT_THROW.

-TEST(ExpectTest, EXPECT_THROW) {

-  EXPECT_THROW(ThrowAnInteger(), int);

-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),

-                          "Expected: ThrowAnInteger() throws an exception of "

-                          "type bool.\n  Actual: it throws a different type.");

-  EXPECT_NONFATAL_FAILURE(

-      EXPECT_THROW(ThrowNothing(), bool),

-      "Expected: ThrowNothing() throws an exception of type bool.\n"

-      "  Actual: it throws nothing.");

-}

-

-// Tests EXPECT_NO_THROW.

-TEST(ExpectTest, EXPECT_NO_THROW) {

-  EXPECT_NO_THROW(ThrowNothing());

-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),

-                          "Expected: ThrowAnInteger() doesn't throw an "

-                          "exception.\n  Actual: it throws.");

-}

-

-// Tests EXPECT_ANY_THROW.

-TEST(ExpectTest, EXPECT_ANY_THROW) {

-  EXPECT_ANY_THROW(ThrowAnInteger());

-  EXPECT_NONFATAL_FAILURE(

-      EXPECT_ANY_THROW(ThrowNothing()),

-      "Expected: ThrowNothing() throws an exception.\n"

-      "  Actual: it doesn't.");

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

-// Make sure we deal with the precedence of <<.

-TEST(ExpectTest, ExpectPrecedence) {

-  EXPECT_EQ(1 < 2, true);

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),

-                          "Value of: true && false");

-}

-

-

-// Tests the StreamableToString() function.

-

-// Tests using StreamableToString() on a scalar.

-TEST(StreamableToStringTest, Scalar) {

-  EXPECT_STREQ("5", StreamableToString(5).c_str());

-}

-

-// Tests using StreamableToString() on a non-char pointer.

-TEST(StreamableToStringTest, Pointer) {

-  int n = 0;

-  int* p = &n;

-  EXPECT_STRNE("(null)", StreamableToString(p).c_str());

-}

-

-// Tests using StreamableToString() on a NULL non-char pointer.

-TEST(StreamableToStringTest, NullPointer) {

-  int* p = NULL;

-  EXPECT_STREQ("(null)", StreamableToString(p).c_str());

-}

-

-// Tests using StreamableToString() on a C string.

-TEST(StreamableToStringTest, CString) {

-  EXPECT_STREQ("Foo", StreamableToString("Foo").c_str());

-}

-

-// Tests using StreamableToString() on a NULL C string.

-TEST(StreamableToStringTest, NullCString) {

-  char* p = NULL;

-  EXPECT_STREQ("(null)", StreamableToString(p).c_str());

-}

-

-// Tests using streamable values as assertion messages.

-

-#if GTEST_HAS_STD_STRING

-// Tests using std::string as an assertion message.

-TEST(StreamableTest, string) {

-  static const std::string str(

-      "This failure message is a std::string, and is expected.");

-  EXPECT_FATAL_FAILURE(FAIL() << str,

-                       str.c_str());

-}

-

-// Tests that we can output strings containing embedded NULs.

-// Limited to Linux because we can only do this with std::string's.

-TEST(StreamableTest, stringWithEmbeddedNUL) {

-  static const char char_array_with_nul[] =

-      "Here's a NUL\0 and some more string";

-  static const std::string string_with_nul(char_array_with_nul,

-                                           sizeof(char_array_with_nul)

-                                           - 1);  // drops the trailing NUL

-  EXPECT_FATAL_FAILURE(FAIL() << string_with_nul,

-                       "Here's a NUL\\0 and some more string");

-}

-

-#endif  // GTEST_HAS_STD_STRING

-

-// Tests that we can output a NUL char.

-TEST(StreamableTest, NULChar) {

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    FAIL() << "A NUL" << '\0' << " and some more string";

-  }, "A NUL\\0 and some more string");

-}

-

-// Tests using int as an assertion message.

-TEST(StreamableTest, int) {

-  EXPECT_FATAL_FAILURE(FAIL() << 900913,

-                       "900913");

-}

-

-// Tests using NULL char pointer as an assertion message.

-//

-// In MSVC, streaming a NULL char * causes access violation.  Google Test

-// implemented a workaround (substituting "(null)" for NULL).  This

-// tests whether the workaround works.

-TEST(StreamableTest, NullCharPtr) {

-  EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL),

-                       "(null)");

-}

-

-// Tests that basic IO manipulators (endl, ends, and flush) can be

-// streamed to testing::Message.

-TEST(StreamableTest, BasicIoManip) {

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    FAIL() << "Line 1." << std::endl

-           << "A NUL char " << std::ends << std::flush << " in line 2.";

-  }, "Line 1.\nA NUL char \\0 in line 2.");

-}

-

-// Tests the macros that haven't been covered so far.

-

-void AddFailureHelper(bool* aborted) {

-  *aborted = true;

-  ADD_FAILURE() << "Failure";

-  *aborted = false;

-}

-

-// Tests ADD_FAILURE.

-TEST(MacroTest, ADD_FAILURE) {

-  bool aborted = true;

-  EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted),

-                          "Failure");

-  EXPECT_FALSE(aborted);

-}

-

-// Tests FAIL.

-TEST(MacroTest, FAIL) {

-  EXPECT_FATAL_FAILURE(FAIL(),

-                       "Failed");

-  EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.",

-                       "Intentional failure.");

-}

-

-// Tests SUCCEED

-TEST(MacroTest, SUCCEED) {

-  SUCCEED();

-  SUCCEED() << "Explicit success.";

-}

-

-

-// Tests for EXPECT_EQ() and ASSERT_EQ().

-//

-// These tests fail *intentionally*, s.t. the failure messages can be

-// generated and tested.

-//

-// We have different tests for different argument types.

-

-// Tests using bool values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, Bool) {

-  EXPECT_EQ(true,  true);

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(false, true),

-                       "Value of: true");

-}

-

-// Tests using int values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, Int) {

-  ASSERT_EQ(32, 32);

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),

-                          "33");

-}

-

-// Tests using time_t values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, Time_T) {

-  EXPECT_EQ(static_cast<time_t>(0),

-            static_cast<time_t>(0));

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0),

-                                 static_cast<time_t>(1234)),

-                       "1234");

-}

-

-// Tests using char values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, Char) {

-  ASSERT_EQ('z', 'z');

-  const char ch = 'b';

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),

-                          "ch");

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),

-                          "ch");

-}

-

-// Tests using wchar_t values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, WideChar) {

-  EXPECT_EQ(L'b', L'b');

-

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),

-                          "Value of: L'x'\n"

-                          "  Actual: L'x' (120, 0x78)\n"

-                          "Expected: L'\0'\n"

-                          "Which is: L'\0' (0, 0x0)");

-

-  static wchar_t wchar;

-  wchar = L'b';

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),

-                          "wchar");

-  wchar = L'\x8119';

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(L'\x8120', wchar),

-                       "Value of: wchar");

-}

-

-#if GTEST_HAS_STD_STRING

-// Tests using ::std::string values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, StdString) {

-  // Compares a const char* to an std::string that has identical

-  // content.

-  ASSERT_EQ("Test", ::std::string("Test"));

-

-  // Compares two identical std::strings.

-  static const ::std::string str1("A * in the middle");

-  static const ::std::string str2(str1);

-  EXPECT_EQ(str1, str2);

-

-  // Compares a const char* to an std::string that has different

-  // content

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")),

-                          "::std::string(\"test\")");

-

-  // Compares an std::string to a char* that has different content.

-  char* const p1 = const_cast<char*>("foo");

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1),

-                          "p1");

-

-  // Compares two std::strings that have different contents, one of

-  // which having a NUL character in the middle.  This should fail.

-  static ::std::string str3(str1);

-  str3.at(2) = '\0';

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),

-                       "Value of: str3\n"

-                       "  Actual: \"A \\0 in the middle\"");

-}

-

-#endif  // GTEST_HAS_STD_STRING

-

-#if GTEST_HAS_STD_WSTRING

-

-// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, StdWideString) {

-  // Compares an std::wstring to a const wchar_t* that has identical

-  // content.

-  EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8119");

-

-  // Compares two identical std::wstrings.

-  const ::std::wstring wstr1(L"A * in the middle");

-  const ::std::wstring wstr2(wstr1);

-  ASSERT_EQ(wstr1, wstr2);

-

-  // Compares an std::wstring to a const wchar_t* that has different

-  // content.

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8120");

-  }, "L\"Test\\x8120\"");

-

-  // Compares two std::wstrings that have different contents, one of

-  // which having a NUL character in the middle.

-  ::std::wstring wstr3(wstr1);

-  wstr3.at(2) = L'\0';

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3),

-                          "wstr3");

-

-  // Compares a wchar_t* to an std::wstring that has different

-  // content.

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));

-  }, "");

-}

-

-#endif  // GTEST_HAS_STD_WSTRING

-

-#if GTEST_HAS_GLOBAL_STRING

-// Tests using ::string values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, GlobalString) {

-  // Compares a const char* to a ::string that has identical content.

-  EXPECT_EQ("Test", ::string("Test"));

-

-  // Compares two identical ::strings.

-  const ::string str1("A * in the middle");

-  const ::string str2(str1);

-  ASSERT_EQ(str1, str2);

-

-  // Compares a ::string to a const char* that has different content.

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"),

-                          "test");

-

-  // Compares two ::strings that have different contents, one of which

-  // having a NUL character in the middle.

-  ::string str3(str1);

-  str3.at(2) = '\0';

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3),

-                          "str3");

-

-  // Compares a ::string to a char* that has different content.

-  EXPECT_FATAL_FAILURE({  // NOLINT

-    ASSERT_EQ(::string("bar"), const_cast<char*>("foo"));

-  }, "");

-}

-

-#endif  // GTEST_HAS_GLOBAL_STRING

-

-#if GTEST_HAS_GLOBAL_WSTRING

-

-// Tests using ::wstring values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, GlobalWideString) {

-  // Compares a const wchar_t* to a ::wstring that has identical content.

-  ASSERT_EQ(L"Test\x8119", ::wstring(L"Test\x8119"));

-

-  // Compares two identical ::wstrings.

-  static const ::wstring wstr1(L"A * in the middle");

-  static const ::wstring wstr2(wstr1);

-  EXPECT_EQ(wstr1, wstr2);

-

-  // Compares a const wchar_t* to a ::wstring that has different

-  // content.

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_EQ(L"Test\x8120", ::wstring(L"Test\x8119"));

-  }, "Test\\x8119");

-

-  // Compares a wchar_t* to a ::wstring that has different content.

-  wchar_t* const p1 = const_cast<wchar_t*>(L"foo");

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")),

-                          "bar");

-

-  // Compares two ::wstrings that have different contents, one of which

-  // having a NUL character in the middle.

-  static ::wstring wstr3;

-  wstr3 = wstr1;

-  wstr3.at(2) = L'\0';

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3),

-                       "wstr3");

-}

-

-#endif  // GTEST_HAS_GLOBAL_WSTRING

-

-// Tests using char pointers in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, CharPointer) {

-  char* const p0 = NULL;

-  // Only way to get the Nokia compiler to compile the cast

-  // is to have a separate void* variable first. Putting

-  // the two casts on the same line doesn't work, neither does

-  // a direct C-style to char*.

-  void* pv1 = (void*)0x1234;  // NOLINT

-  void* pv2 = (void*)0xABC0;  // NOLINT

-  char* const p1 = reinterpret_cast<char*>(pv1);

-  char* const p2 = reinterpret_cast<char*>(pv2);

-  ASSERT_EQ(p1, p1);

-

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),

-                          "Value of: p2");

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),

-                          "p2");

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),

-                                 reinterpret_cast<char*>(0xABC0)),

-                       "ABC0");

-}

-

-// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, WideCharPointer) {

-  wchar_t* const p0 = NULL;

-  // Only way to get the Nokia compiler to compile the cast

-  // is to have a separate void* variable first. Putting

-  // the two casts on the same line doesn't work, neither does

-  // a direct C-style to char*.

-  void* pv1 = (void*)0x1234;  // NOLINT

-  void* pv2 = (void*)0xABC0;  // NOLINT

-  wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1);

-  wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2);

-  EXPECT_EQ(p0, p0);

-

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),

-                          "Value of: p2");

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),

-                          "p2");

-  void* pv3 = (void*)0x1234;  // NOLINT

-  void* pv4 = (void*)0xABC0;  // NOLINT

-  const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);

-  const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4);

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4),

-                          "p4");

-}

-

-// Tests using other types of pointers in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, OtherPointer) {

-  ASSERT_EQ(static_cast<const int*>(NULL),

-            static_cast<const int*>(NULL));

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL),

-                                 reinterpret_cast<const int*>(0x1234)),

-                       "0x1234");

-}

-

-// Tests the FRIEND_TEST macro.

-

-// This class has a private member we want to test.  We will test it

-// both in a TEST and in a TEST_F.

-class Foo {

- public:

-  Foo() {}

-

- private:

-  int Bar() const { return 1; }

-

-  // Declares the friend tests that can access the private member

-  // Bar().

-  FRIEND_TEST(FRIEND_TEST_Test, TEST);

-  FRIEND_TEST(FRIEND_TEST_Test2, TEST_F);

-};

-

-// Tests that the FRIEND_TEST declaration allows a TEST to access a

-// class's private members.  This should compile.

-TEST(FRIEND_TEST_Test, TEST) {

-  ASSERT_EQ(1, Foo().Bar());

-}

-

-// The fixture needed to test using FRIEND_TEST with TEST_F.

-class FRIEND_TEST_Test2 : public Test {

- protected:

-  Foo foo;

-};

-

-// Tests that the FRIEND_TEST declaration allows a TEST_F to access a

-// class's private members.  This should compile.

-TEST_F(FRIEND_TEST_Test2, TEST_F) {

-  ASSERT_EQ(1, foo.Bar());

-}

-

-// Tests the life cycle of Test objects.

-

-// The test fixture for testing the life cycle of Test objects.

-//

-// This class counts the number of live test objects that uses this

-// fixture.

-class TestLifeCycleTest : public Test {

- protected:

-  // Constructor.  Increments the number of test objects that uses

-  // this fixture.

-  TestLifeCycleTest() { count_++; }

-

-  // Destructor.  Decrements the number of test objects that uses this

-  // fixture.

-  ~TestLifeCycleTest() { count_--; }

-

-  // Returns the number of live test objects that uses this fixture.

-  int count() const { return count_; }

-

- private:

-  static int count_;

-};

-

-int TestLifeCycleTest::count_ = 0;

-

-// Tests the life cycle of test objects.

-TEST_F(TestLifeCycleTest, Test1) {

-  // There should be only one test object in this test case that's

-  // currently alive.

-  ASSERT_EQ(1, count());

-}

-

-// Tests the life cycle of test objects.

-TEST_F(TestLifeCycleTest, Test2) {

-  // After Test1 is done and Test2 is started, there should still be

-  // only one live test object, as the object for Test1 should've been

-  // deleted.

-  ASSERT_EQ(1, count());

-}

-

-}  // namespace

-

-// Tests streaming a user type whose definition and operator << are

-// both in the global namespace.

-class Base {

- public:

-  explicit Base(int x) : x_(x) {}

-  int x() const { return x_; }

- private:

-  int x_;

-};

-std::ostream& operator<<(std::ostream& os,

-                         const Base& val) {

-  return os << val.x();

-}

-std::ostream& operator<<(std::ostream& os,

-                         const Base* pointer) {

-  return os << "(" << pointer->x() << ")";

-}

-

-TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {

-  Message msg;

-  Base a(1);

-

-  msg << a << &a;  // Uses ::operator<<.

-  EXPECT_STREQ("1(1)", msg.GetString().c_str());

-}

-

-// Tests streaming a user type whose definition and operator<< are

-// both in an unnamed namespace.

-namespace {

-class MyTypeInUnnamedNameSpace : public Base {

- public:

-  explicit MyTypeInUnnamedNameSpace(int x): Base(x) {}

-};

-std::ostream& operator<<(std::ostream& os,

-                         const MyTypeInUnnamedNameSpace& val) {

-  return os << val.x();

-}

-std::ostream& operator<<(std::ostream& os,

-                         const MyTypeInUnnamedNameSpace* pointer) {

-  return os << "(" << pointer->x() << ")";

-}

-}  // namespace

-

-TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {

-  Message msg;

-  MyTypeInUnnamedNameSpace a(1);

-

-  msg << a << &a;  // Uses <unnamed_namespace>::operator<<.

-  EXPECT_STREQ("1(1)", msg.GetString().c_str());

-}

-

-// Tests streaming a user type whose definition and operator<< are

-// both in a user namespace.

-namespace namespace1 {

-class MyTypeInNameSpace1 : public Base {

- public:

-  explicit MyTypeInNameSpace1(int x): Base(x) {}

-};

-std::ostream& operator<<(std::ostream& os,

-                         const MyTypeInNameSpace1& val) {

-  return os << val.x();

-}

-std::ostream& operator<<(std::ostream& os,

-                         const MyTypeInNameSpace1* pointer) {

-  return os << "(" << pointer->x() << ")";

-}

-}  // namespace namespace1

-

-TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {

-  Message msg;

-  namespace1::MyTypeInNameSpace1 a(1);

-

-  msg << a << &a;  // Uses namespace1::operator<<.

-  EXPECT_STREQ("1(1)", msg.GetString().c_str());

-}

-

-// Tests streaming a user type whose definition is in a user namespace

-// but whose operator<< is in the global namespace.

-namespace namespace2 {

-class MyTypeInNameSpace2 : public ::Base {

- public:

-  explicit MyTypeInNameSpace2(int x): Base(x) {}

-};

-}  // namespace namespace2

-std::ostream& operator<<(std::ostream& os,

-                         const namespace2::MyTypeInNameSpace2& val) {

-  return os << val.x();

-}

-std::ostream& operator<<(std::ostream& os,

-                         const namespace2::MyTypeInNameSpace2* pointer) {

-  return os << "(" << pointer->x() << ")";

-}

-

-TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) {

-  Message msg;

-  namespace2::MyTypeInNameSpace2 a(1);

-

-  msg << a << &a;  // Uses ::operator<<.

-  EXPECT_STREQ("1(1)", msg.GetString().c_str());

-}

-

-// Tests streaming NULL pointers to testing::Message.

-TEST(MessageTest, NullPointers) {

-  Message msg;

-  char* const p1 = NULL;

-  unsigned char* const p2 = NULL;

-  int* p3 = NULL;

-  double* p4 = NULL;

-  bool* p5 = NULL;

-  Message* p6 = NULL;

-

-  msg << p1 << p2 << p3 << p4 << p5 << p6;

-  ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",

-               msg.GetString().c_str());

-}

-

-// Tests streaming wide strings to testing::Message.

-TEST(MessageTest, WideStrings) {

-  // Streams a NULL of type const wchar_t*.

-  const wchar_t* const_wstr = NULL;

-  EXPECT_STREQ("(null)",

-               (Message() << const_wstr).GetString().c_str());

-

-  // Streams a NULL of type wchar_t*.

-  wchar_t* wstr = NULL;

-  EXPECT_STREQ("(null)",

-               (Message() << wstr).GetString().c_str());

-

-  // Streams a non-NULL of type const wchar_t*.

-  const_wstr = L"abc\x8119";

-  EXPECT_STREQ("abc\xe8\x84\x99",

-               (Message() << const_wstr).GetString().c_str());

-

-  // Streams a non-NULL of type wchar_t*.

-  wstr = const_cast<wchar_t*>(const_wstr);

-  EXPECT_STREQ("abc\xe8\x84\x99",

-               (Message() << wstr).GetString().c_str());

-}

-

-

-// This line tests that we can define tests in the testing namespace.

-namespace testing {

-

-// Tests the TestInfo class.

-

-class TestInfoTest : public Test {

- protected:

-  static const TestInfo* GetTestInfo(const char* test_name) {

-    const TestCase* const test_case = GetUnitTestImpl()->

-        GetTestCase("TestInfoTest", "", NULL, NULL);

-

-    for (int i = 0; i < test_case->total_test_count(); ++i) {

-      const TestInfo* const test_info = test_case->GetTestInfo(i);

-      if (strcmp(test_name, test_info->name()) == 0)

-        return test_info;

-    }

-    return NULL;

-  }

-

-  static const TestResult* GetTestResult(

-      const TestInfo* test_info) {

-    return test_info->result();

-  }

-};

-

-// Tests TestInfo::test_case_name() and TestInfo::name().

-TEST_F(TestInfoTest, Names) {

-  const TestInfo* const test_info = GetTestInfo("Names");

-

-  ASSERT_STREQ("TestInfoTest", test_info->test_case_name());

-  ASSERT_STREQ("Names", test_info->name());

-}

-

-// Tests TestInfo::result().

-TEST_F(TestInfoTest, result) {

-  const TestInfo* const test_info = GetTestInfo("result");

-

-  // Initially, there is no TestPartResult for this test.

-  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());

-

-  // After the previous assertion, there is still none.

-  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());

-}

-

-// Tests setting up and tearing down a test case.

-

-class SetUpTestCaseTest : public Test {

- protected:

-  // This will be called once before the first test in this test case

-  // is run.

-  static void SetUpTestCase() {

-    printf("Setting up the test case . . .\n");

-

-    // Initializes some shared resource.  In this simple example, we

-    // just create a C string.  More complex stuff can be done if

-    // desired.

-    shared_resource_ = "123";

-

-    // Increments the number of test cases that have been set up.

-    counter_++;

-

-    // SetUpTestCase() should be called only once.

-    EXPECT_EQ(1, counter_);

-  }

-

-  // This will be called once after the last test in this test case is

-  // run.

-  static void TearDownTestCase() {

-    printf("Tearing down the test case . . .\n");

-

-    // Decrements the number of test cases that have been set up.

-    counter_--;

-

-    // TearDownTestCase() should be called only once.

-    EXPECT_EQ(0, counter_);

-

-    // Cleans up the shared resource.

-    shared_resource_ = NULL;

-  }

-

-  // This will be called before each test in this test case.

-  virtual void SetUp() {

-    // SetUpTestCase() should be called only once, so counter_ should

-    // always be 1.

-    EXPECT_EQ(1, counter_);

-  }

-

-  // Number of test cases that have been set up.

-  static int counter_;

-

-  // Some resource to be shared by all tests in this test case.

-  static const char* shared_resource_;

-};

-

-int SetUpTestCaseTest::counter_ = 0;

-const char* SetUpTestCaseTest::shared_resource_ = NULL;

-

-// A test that uses the shared resource.

-TEST_F(SetUpTestCaseTest, Test1) {

-  EXPECT_STRNE(NULL, shared_resource_);

-}

-

-// Another test that uses the shared resource.

-TEST_F(SetUpTestCaseTest, Test2) {

-  EXPECT_STREQ("123", shared_resource_);

-}

-

-// The InitGoogleTestTest test case tests testing::InitGoogleTest().

-

-// The Flags struct stores a copy of all Google Test flags.

-struct Flags {

-  // Constructs a Flags struct where each flag has its default value.

-  Flags() : also_run_disabled_tests(false),

-            break_on_failure(false),

-            catch_exceptions(false),

-            death_test_use_fork(false),

-            filter(""),

-            list_tests(false),

-            output(""),

-            print_time(true),

-            random_seed(0),

-            repeat(1),

-            shuffle(false),

-            throw_on_failure(false) {}

-

-  // Factory methods.

-

-  // Creates a Flags struct where the gtest_also_run_disabled_tests flag has

-  // the given value.

-  static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {

-    Flags flags;

-    flags.also_run_disabled_tests = also_run_disabled_tests;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_break_on_failure flag has

-  // the given value.

-  static Flags BreakOnFailure(bool break_on_failure) {

-    Flags flags;

-    flags.break_on_failure = break_on_failure;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_catch_exceptions flag has

-  // the given value.

-  static Flags CatchExceptions(bool catch_exceptions) {

-    Flags flags;

-    flags.catch_exceptions = catch_exceptions;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_death_test_use_fork flag has

-  // the given value.

-  static Flags DeathTestUseFork(bool death_test_use_fork) {

-    Flags flags;

-    flags.death_test_use_fork = death_test_use_fork;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_filter flag has the given

-  // value.

-  static Flags Filter(const char* filter) {

-    Flags flags;

-    flags.filter = filter;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_list_tests flag has the

-  // given value.

-  static Flags ListTests(bool list_tests) {

-    Flags flags;

-    flags.list_tests = list_tests;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_output flag has the given

-  // value.

-  static Flags Output(const char* output) {

-    Flags flags;

-    flags.output = output;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_print_time flag has the given

-  // value.

-  static Flags PrintTime(bool print_time) {

-    Flags flags;

-    flags.print_time = print_time;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_random_seed flag has

-  // the given value.

-  static Flags RandomSeed(Int32 random_seed) {

-    Flags flags;

-    flags.random_seed = random_seed;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_repeat flag has the given

-  // value.

-  static Flags Repeat(Int32 repeat) {

-    Flags flags;

-    flags.repeat = repeat;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_shuffle flag has

-  // the given value.

-  static Flags Shuffle(bool shuffle) {

-    Flags flags;

-    flags.shuffle = shuffle;

-    return flags;

-  }

-

-  // Creates a Flags struct where the gtest_throw_on_failure flag has

-  // the given value.

-  static Flags ThrowOnFailure(bool throw_on_failure) {

-    Flags flags;

-    flags.throw_on_failure = throw_on_failure;

-    return flags;

-  }

-

-  // These fields store the flag values.

-  bool also_run_disabled_tests;

-  bool break_on_failure;

-  bool catch_exceptions;

-  bool death_test_use_fork;

-  const char* filter;

-  bool list_tests;

-  const char* output;

-  bool print_time;

-  Int32 random_seed;

-  Int32 repeat;

-  bool shuffle;

-  bool throw_on_failure;

-};

-

-// Fixture for testing InitGoogleTest().

-class InitGoogleTestTest : public Test {

- protected:

-  // Clears the flags before each test.

-  virtual void SetUp() {

-    GTEST_FLAG(also_run_disabled_tests) = false;

-    GTEST_FLAG(break_on_failure) = false;

-    GTEST_FLAG(catch_exceptions) = false;

-    GTEST_FLAG(death_test_use_fork) = false;

-    GTEST_FLAG(filter) = "";

-    GTEST_FLAG(list_tests) = false;

-    GTEST_FLAG(output) = "";

-    GTEST_FLAG(print_time) = true;

-    GTEST_FLAG(random_seed) = 0;

-    GTEST_FLAG(repeat) = 1;

-    GTEST_FLAG(shuffle) = false;

-    GTEST_FLAG(throw_on_failure) = false;

-  }

-

-  // Asserts that two narrow or wide string arrays are equal.

-  template <typename CharType>

-  static void AssertStringArrayEq(size_t size1, CharType** array1,

-                                  size_t size2, CharType** array2) {

-    ASSERT_EQ(size1, size2) << " Array sizes different.";

-

-    for (size_t i = 0; i != size1; i++) {

-      ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i;

-    }

-  }

-

-  // Verifies that the flag values match the expected values.

-  static void CheckFlags(const Flags& expected) {

-    EXPECT_EQ(expected.also_run_disabled_tests,

-              GTEST_FLAG(also_run_disabled_tests));

-    EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));

-    EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));

-    EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));

-    EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());

-    EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));

-    EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());

-    EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));

-    EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));

-    EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));

-    EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));

-    EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));

-  }

-

-  // Parses a command line (specified by argc1 and argv1), then

-  // verifies that the flag values are expected and that the

-  // recognized flags are removed from the command line.

-  template <typename CharType>

-  static void TestParsingFlags(int argc1, const CharType** argv1,

-                               int argc2, const CharType** argv2,

-                               const Flags& expected) {

-    // Parses the command line.

-    internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));

-

-    // Verifies the flag values.

-    CheckFlags(expected);

-

-    // Verifies that the recognized flags are removed from the command

-    // line.

-    AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);

-  }

-

-  // This macro wraps TestParsingFlags s.t. the user doesn't need

-  // to specify the array sizes.

-#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected) \

-  TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \

-                   sizeof(argv2)/sizeof(*argv2) - 1, argv2, expected)

-};

-

-// Tests parsing an empty command line.

-TEST_F(InitGoogleTestTest, Empty) {

-  const char* argv[] = {

-    NULL

-  };

-

-  const char* argv2[] = {

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());

-}

-

-// Tests parsing a command line that has no flag.

-TEST_F(InitGoogleTestTest, NoFlag) {

-  const char* argv[] = {

-    "foo.exe",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());

-}

-

-// Tests parsing a bad --gtest_filter flag.

-TEST_F(InitGoogleTestTest, FilterBad) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_filter",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    "--gtest_filter",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""));

-}

-

-// Tests parsing an empty --gtest_filter flag.

-TEST_F(InitGoogleTestTest, FilterEmpty) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_filter=",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""));

-}

-

-// Tests parsing a non-empty --gtest_filter flag.

-TEST_F(InitGoogleTestTest, FilterNonEmpty) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_filter=abc",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"));

-}

-

-// Tests parsing --gtest_break_on_failure.

-TEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_break_on_failure",

-    NULL

-};

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true));

-}

-

-// Tests parsing --gtest_break_on_failure=0.

-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_break_on_failure=0",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));

-}

-

-// Tests parsing --gtest_break_on_failure=f.

-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_break_on_failure=f",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));

-}

-

-// Tests parsing --gtest_break_on_failure=F.

-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_break_on_failure=F",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));

-}

-

-// Tests parsing a --gtest_break_on_failure flag that has a "true"

-// definition.

-TEST_F(InitGoogleTestTest, BreakOnFailureTrue) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_break_on_failure=1",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true));

-}

-

-// Tests parsing --gtest_catch_exceptions.

-TEST_F(InitGoogleTestTest, CatchExceptions) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_catch_exceptions",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true));

-}

-

-// Tests parsing --gtest_death_test_use_fork.

-TEST_F(InitGoogleTestTest, DeathTestUseFork) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_death_test_use_fork",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true));

-}

-

-// Tests having the same flag twice with different values.  The

-// expected behavior is that the one coming last takes precedence.

-TEST_F(InitGoogleTestTest, DuplicatedFlags) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_filter=a",

-    "--gtest_filter=b",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"));

-}

-

-// Tests having an unrecognized flag on the command line.

-TEST_F(InitGoogleTestTest, UnrecognizedFlag) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_break_on_failure",

-    "bar",  // Unrecognized by Google Test.

-    "--gtest_filter=b",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    "bar",

-    NULL

-  };

-

-  Flags flags;

-  flags.break_on_failure = true;

-  flags.filter = "b";

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags);

-}

-

-// Tests having a --gtest_list_tests flag

-TEST_F(InitGoogleTestTest, ListTestsFlag) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_list_tests",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true));

-}

-

-// Tests having a --gtest_list_tests flag with a "true" value

-TEST_F(InitGoogleTestTest, ListTestsTrue) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_list_tests=1",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true));

-}

-

-// Tests having a --gtest_list_tests flag with a "false" value

-TEST_F(InitGoogleTestTest, ListTestsFalse) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_list_tests=0",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));

-}

-

-// Tests parsing --gtest_list_tests=f.

-TEST_F(InitGoogleTestTest, ListTestsFalse_f) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_list_tests=f",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));

-}

-

-// Tests parsing --gtest_list_tests=F.

-TEST_F(InitGoogleTestTest, ListTestsFalse_F) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_list_tests=F",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));

-}

-

-// Tests parsing --gtest_output (invalid).

-TEST_F(InitGoogleTestTest, OutputEmpty) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_output",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    "--gtest_output",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());

-}

-

-// Tests parsing --gtest_output=xml

-TEST_F(InitGoogleTestTest, OutputXml) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_output=xml",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"));

-}

-

-// Tests parsing --gtest_output=xml:file

-TEST_F(InitGoogleTestTest, OutputXmlFile) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_output=xml:file",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"));

-}

-

-// Tests parsing --gtest_output=xml:directory/path/

-TEST_F(InitGoogleTestTest, OutputXmlDirectory) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_output=xml:directory/path/",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:directory/path/"));

-}

-

-// Tests having a --gtest_print_time flag

-TEST_F(InitGoogleTestTest, PrintTimeFlag) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_print_time",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true));

-}

-

-// Tests having a --gtest_print_time flag with a "true" value

-TEST_F(InitGoogleTestTest, PrintTimeTrue) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_print_time=1",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true));

-}

-

-// Tests having a --gtest_print_time flag with a "false" value

-TEST_F(InitGoogleTestTest, PrintTimeFalse) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_print_time=0",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));

-}

-

-// Tests parsing --gtest_print_time=f.

-TEST_F(InitGoogleTestTest, PrintTimeFalse_f) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_print_time=f",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));

-}

-

-// Tests parsing --gtest_print_time=F.

-TEST_F(InitGoogleTestTest, PrintTimeFalse_F) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_print_time=F",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));

-}

-

-// Tests parsing --gtest_random_seed=number

-TEST_F(InitGoogleTestTest, RandomSeed) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_random_seed=1000",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000));

-}

-

-// Tests parsing --gtest_repeat=number

-TEST_F(InitGoogleTestTest, Repeat) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_repeat=1000",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000));

-}

-

-// Tests having a --gtest_also_run_disabled_tests flag

-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_also_run_disabled_tests",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true));

-}

-

-// Tests having a --gtest_also_run_disabled_tests flag with a "true" value

-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_also_run_disabled_tests=1",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true));

-}

-

-// Tests having a --gtest_also_run_disabled_tests flag with a "false" value

-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) {

-    const char* argv[] = {

-      "foo.exe",

-      "--gtest_also_run_disabled_tests=0",

-      NULL

-    };

-

-    const char* argv2[] = {

-      "foo.exe",

-      NULL

-    };

-

-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(false));

-}

-

-// Tests parsing --gtest_shuffle.

-TEST_F(InitGoogleTestTest, ShuffleWithoutValue) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_shuffle",

-    NULL

-};

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true));

-}

-

-// Tests parsing --gtest_shuffle=0.

-TEST_F(InitGoogleTestTest, ShuffleFalse_0) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_shuffle=0",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false));

-}

-

-// Tests parsing a --gtest_shuffle flag that has a "true"

-// definition.

-TEST_F(InitGoogleTestTest, ShuffleTrue) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_shuffle=1",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true));

-}

-

-// Tests parsing --gtest_throw_on_failure.

-TEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_throw_on_failure",

-    NULL

-};

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true));

-}

-

-// Tests parsing --gtest_throw_on_failure=0.

-TEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_throw_on_failure=0",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false));

-}

-

-// Tests parsing a --gtest_throw_on_failure flag that has a "true"

-// definition.

-TEST_F(InitGoogleTestTest, ThrowOnFailureTrue) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_throw_on_failure=1",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true));

-}

-

-#if GTEST_OS_WINDOWS

-// Tests parsing wide strings.

-TEST_F(InitGoogleTestTest, WideStrings) {

-  const wchar_t* argv[] = {

-    L"foo.exe",

-    L"--gtest_filter=Foo*",

-    L"--gtest_list_tests=1",

-    L"--gtest_break_on_failure",

-    L"--non_gtest_flag",

-    NULL

-  };

-

-  const wchar_t* argv2[] = {

-    L"foo.exe",

-    L"--non_gtest_flag",

-    NULL

-  };

-

-  Flags expected_flags;

-  expected_flags.break_on_failure = true;

-  expected_flags.filter = "Foo*";

-  expected_flags.list_tests = true;

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags);

-}

-#endif  // GTEST_OS_WINDOWS

-

-// Tests current_test_info() in UnitTest.

-class CurrentTestInfoTest : public Test {

- protected:

-  // Tests that current_test_info() returns NULL before the first test in

-  // the test case is run.

-  static void SetUpTestCase() {

-    // There should be no tests running at this point.

-    const TestInfo* test_info =

-      UnitTest::GetInstance()->current_test_info();

-    EXPECT_TRUE(test_info == NULL)

-        << "There should be no tests running at this point.";

-  }

-

-  // Tests that current_test_info() returns NULL after the last test in

-  // the test case has run.

-  static void TearDownTestCase() {

-    const TestInfo* test_info =

-      UnitTest::GetInstance()->current_test_info();

-    EXPECT_TRUE(test_info == NULL)

-        << "There should be no tests running at this point.";

-  }

-};

-

-// Tests that current_test_info() returns TestInfo for currently running

-// test by checking the expected test name against the actual one.

-TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) {

-  const TestInfo* test_info =

-    UnitTest::GetInstance()->current_test_info();

-  ASSERT_TRUE(NULL != test_info)

-      << "There is a test running so we should have a valid TestInfo.";

-  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())

-      << "Expected the name of the currently running test case.";

-  EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name())

-      << "Expected the name of the currently running test.";

-}

-

-// Tests that current_test_info() returns TestInfo for currently running

-// test by checking the expected test name against the actual one.  We

-// use this test to see that the TestInfo object actually changed from

-// the previous invocation.

-TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) {

-  const TestInfo* test_info =

-    UnitTest::GetInstance()->current_test_info();

-  ASSERT_TRUE(NULL != test_info)

-      << "There is a test running so we should have a valid TestInfo.";

-  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())

-      << "Expected the name of the currently running test case.";

-  EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name())

-      << "Expected the name of the currently running test.";

-}

-

-}  // namespace testing

-

-// These two lines test that we can define tests in a namespace that

-// has the name "testing" and is nested in another namespace.

-namespace my_namespace {

-namespace testing {

-

-// Makes sure that TEST knows to use ::testing::Test instead of

-// ::my_namespace::testing::Test.

-class Test {};

-

-// Makes sure that an assertion knows to use ::testing::Message instead of

-// ::my_namespace::testing::Message.

-class Message {};

-

-// Makes sure that an assertion knows to use

-// ::testing::AssertionResult instead of

-// ::my_namespace::testing::AssertionResult.

-class AssertionResult {};

-

-// Tests that an assertion that should succeed works as expected.

-TEST(NestedTestingNamespaceTest, Success) {

-  EXPECT_EQ(1, 1) << "This shouldn't fail.";

-}

-

-// Tests that an assertion that should fail works as expected.

-TEST(NestedTestingNamespaceTest, Failure) {

-  EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.",

-                       "This failure is expected.");

-}

-

-}  // namespace testing

-}  // namespace my_namespace

-

-// Tests that one can call superclass SetUp and TearDown methods--

-// that is, that they are not private.

-// No tests are based on this fixture; the test "passes" if it compiles

-// successfully.

-class ProtectedFixtureMethodsTest : public Test {

- protected:

-  virtual void SetUp() {

-    Test::SetUp();

-  }

-  virtual void TearDown() {

-    Test::TearDown();

-  }

-};

-

-// StreamingAssertionsTest tests the streaming versions of a representative

-// sample of assertions.

-TEST(StreamingAssertionsTest, Unconditional) {

-  SUCCEED() << "expected success";

-  EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(FAIL() << "expected failure",

-                       "expected failure");

-}

-

-#ifdef __BORLANDC__

-// Silences warnings: "Condition is always true", "Unreachable code"

-#pragma option push -w-ccc -w-rch

-#endif

-

-TEST(StreamingAssertionsTest, Truth) {

-  EXPECT_TRUE(true) << "unexpected failure";

-  ASSERT_TRUE(true) << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure",

-                       "expected failure");

-}

-

-TEST(StreamingAssertionsTest, Truth2) {

-  EXPECT_FALSE(false) << "unexpected failure";

-  ASSERT_FALSE(false) << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure",

-                       "expected failure");

-}

-

-#ifdef __BORLANDC__

-// Restores warnings after previous "#pragma option push" supressed them

-#pragma option pop

-#endif

-

-TEST(StreamingAssertionsTest, IntegerEquals) {

-  EXPECT_EQ(1, 1) << "unexpected failure";

-  ASSERT_EQ(1, 1) << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure",

-                       "expected failure");

-}

-

-TEST(StreamingAssertionsTest, IntegerLessThan) {

-  EXPECT_LT(1, 2) << "unexpected failure";

-  ASSERT_LT(1, 2) << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure",

-                       "expected failure");

-}

-

-TEST(StreamingAssertionsTest, StringsEqual) {

-  EXPECT_STREQ("foo", "foo") << "unexpected failure";

-  ASSERT_STREQ("foo", "foo") << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure",

-                       "expected failure");

-}

-

-TEST(StreamingAssertionsTest, StringsNotEqual) {

-  EXPECT_STRNE("foo", "bar") << "unexpected failure";

-  ASSERT_STRNE("foo", "bar") << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure",

-                       "expected failure");

-}

-

-TEST(StreamingAssertionsTest, StringsEqualIgnoringCase) {

-  EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure";

-  ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure",

-                       "expected failure");

-}

-

-TEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) {

-  EXPECT_STRCASENE("foo", "bar") << "unexpected failure";

-  ASSERT_STRCASENE("foo", "bar") << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure",

-                       "expected failure");

-}

-

-TEST(StreamingAssertionsTest, FloatingPointEquals) {

-  EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";

-  ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure",

-                          "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure",

-                       "expected failure");

-}

-

-#if GTEST_HAS_EXCEPTIONS

-

-TEST(StreamingAssertionsTest, Throw) {

-  EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";

-  ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<

-                          "expected failure", "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<

-                       "expected failure", "expected failure");

-}

-

-TEST(StreamingAssertionsTest, NoThrow) {

-  EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure";

-  ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<

-                          "expected failure", "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<

-                       "expected failure", "expected failure");

-}

-

-TEST(StreamingAssertionsTest, AnyThrow) {

-  EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";

-  ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";

-  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) <<

-                          "expected failure", "expected failure");

-  EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) <<

-                       "expected failure", "expected failure");

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

-// Tests that Google Test correctly decides whether to use colors in the output.

-

-TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {

-  GTEST_FLAG(color) = "yes";

-

-  SetEnv("TERM", "xterm");  // TERM supports colors.

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.

-

-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.

-}

-

-TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {

-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.

-

-  GTEST_FLAG(color) = "True";

-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.

-

-  GTEST_FLAG(color) = "t";

-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.

-

-  GTEST_FLAG(color) = "1";

-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.

-}

-

-TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {

-  GTEST_FLAG(color) = "no";

-

-  SetEnv("TERM", "xterm");  // TERM supports colors.

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.

-

-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.

-}

-

-TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {

-  SetEnv("TERM", "xterm");  // TERM supports colors.

-

-  GTEST_FLAG(color) = "F";

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  GTEST_FLAG(color) = "0";

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  GTEST_FLAG(color) = "unknown";

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-}

-

-TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {

-  GTEST_FLAG(color) = "auto";

-

-  SetEnv("TERM", "xterm");  // TERM supports colors.

-  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.

-  EXPECT_TRUE(ShouldUseColor(true));    // Stdout is a TTY.

-}

-

-TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {

-  GTEST_FLAG(color) = "auto";

-

-#if GTEST_OS_WINDOWS

-  // On Windows, we ignore the TERM variable as it's usually not set.

-

-  SetEnv("TERM", "dumb");

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "");

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "xterm");

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-#else

-  // On non-Windows platforms, we rely on TERM to determine if the

-  // terminal supports colors.

-

-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "emacs");  // TERM doesn't support colors.

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "vt100");  // TERM doesn't support colors.

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "xterm-mono");  // TERM doesn't support colors.

-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "xterm");  // TERM supports colors.

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "xterm-color");  // TERM supports colors.

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "linux");  // TERM supports colors.

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-#endif  // GTEST_OS_WINDOWS

-}

-

-// Verifies that StaticAssertTypeEq works in a namespace scope.

-

-static bool dummy1 = StaticAssertTypeEq<bool, bool>();

-static bool dummy2 = StaticAssertTypeEq<const int, const int>();

-

-// Verifies that StaticAssertTypeEq works in a class.

-

-template <typename T>

-class StaticAssertTypeEqTestHelper {

- public:

-  StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); }

-};

-

-TEST(StaticAssertTypeEqTest, WorksInClass) {

-  StaticAssertTypeEqTestHelper<bool>();

-}

-

-// Verifies that StaticAssertTypeEq works inside a function.

-

-typedef int IntAlias;

-

-TEST(StaticAssertTypeEqTest, CompilesForEqualTypes) {

-  StaticAssertTypeEq<int, IntAlias>();

-  StaticAssertTypeEq<int*, IntAlias*>();

-}

-

-TEST(ThreadLocalTest, DefaultConstructor) {

-  ThreadLocal<int> t1;

-  EXPECT_EQ(0, t1.get());

-

-  ThreadLocal<void*> t2;

-  EXPECT_TRUE(t2.get() == NULL);

-}

-

-TEST(ThreadLocalTest, Init) {

-  ThreadLocal<int> t1(123);

-  EXPECT_EQ(123, t1.get());

-

-  int i = 0;

-  ThreadLocal<int*> t2(&i);

-  EXPECT_EQ(&i, t2.get());

-}

-

-TEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) {

-  testing::UnitTest* const unit_test = testing::UnitTest::GetInstance();

-

-  // We don't have a stack walker in Google Test yet.

-  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str());

-  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str());

-}

-

-TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {

-  EXPECT_FALSE(HasNonfatalFailure());

-}

-

-static void FailFatally() { FAIL(); }

-

-TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) {

-  FailFatally();

-  const bool has_nonfatal_failure = HasNonfatalFailure();

-  ClearCurrentTestPartResults();

-  EXPECT_FALSE(has_nonfatal_failure);

-}

-

-TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {

-  ADD_FAILURE();

-  const bool has_nonfatal_failure = HasNonfatalFailure();

-  ClearCurrentTestPartResults();

-  EXPECT_TRUE(has_nonfatal_failure);

-}

-

-TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {

-  FailFatally();

-  ADD_FAILURE();

-  const bool has_nonfatal_failure = HasNonfatalFailure();

-  ClearCurrentTestPartResults();

-  EXPECT_TRUE(has_nonfatal_failure);

-}

-

-// A wrapper for calling HasNonfatalFailure outside of a test body.

-static bool HasNonfatalFailureHelper() {

-  return testing::Test::HasNonfatalFailure();

-}

-

-TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) {

-  EXPECT_FALSE(HasNonfatalFailureHelper());

-}

-

-TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) {

-  ADD_FAILURE();

-  const bool has_nonfatal_failure = HasNonfatalFailureHelper();

-  ClearCurrentTestPartResults();

-  EXPECT_TRUE(has_nonfatal_failure);

-}

-

-TEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) {

-  EXPECT_FALSE(HasFailure());

-}

-

-TEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) {

-  FailFatally();

-  const bool has_failure = HasFailure();

-  ClearCurrentTestPartResults();

-  EXPECT_TRUE(has_failure);

-}

-

-TEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {

-  ADD_FAILURE();

-  const bool has_failure = HasFailure();

-  ClearCurrentTestPartResults();

-  EXPECT_TRUE(has_failure);

-}

-

-TEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {

-  FailFatally();

-  ADD_FAILURE();

-  const bool has_failure = HasFailure();

-  ClearCurrentTestPartResults();

-  EXPECT_TRUE(has_failure);

-}

-

-// A wrapper for calling HasFailure outside of a test body.

-static bool HasFailureHelper() { return testing::Test::HasFailure(); }

-

-TEST(HasFailureTest, WorksOutsideOfTestBody) {

-  EXPECT_FALSE(HasFailureHelper());

-}

-

-TEST(HasFailureTest, WorksOutsideOfTestBody2) {

-  ADD_FAILURE();

-  const bool has_failure = HasFailureHelper();

-  ClearCurrentTestPartResults();

-  EXPECT_TRUE(has_failure);

-}

-

-class TestListener : public EmptyTestEventListener {

- public:

-  TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {}

-  TestListener(int* on_start_counter, bool* is_destroyed)

-      : on_start_counter_(on_start_counter),

-        is_destroyed_(is_destroyed) {}

-

-  virtual ~TestListener() {

-    if (is_destroyed_)

-      *is_destroyed_ = true;

-  }

-

- protected:

-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {

-    if (on_start_counter_ != NULL)

-      (*on_start_counter_)++;

-  }

-

- private:

-  int* on_start_counter_;

-  bool* is_destroyed_;

-};

-

-// Tests the constructor.

-TEST(TestEventListenersTest, ConstructionWorks) {

-  TestEventListeners listeners;

-

-  EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL);

-  EXPECT_TRUE(listeners.default_result_printer() == NULL);

-  EXPECT_TRUE(listeners.default_xml_generator() == NULL);

-}

-

-// Tests that the TestEventListeners destructor deletes all the listeners it

-// owns.

-TEST(TestEventListenersTest, DestructionWorks) {

-  bool default_result_printer_is_destroyed = false;

-  bool default_xml_printer_is_destroyed = false;

-  bool extra_listener_is_destroyed = false;

-  TestListener* default_result_printer = new TestListener(

-      NULL, &default_result_printer_is_destroyed);

-  TestListener* default_xml_printer = new TestListener(

-      NULL, &default_xml_printer_is_destroyed);

-  TestListener* extra_listener = new TestListener(

-      NULL, &extra_listener_is_destroyed);

-

-  {

-    TestEventListeners listeners;

-    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners,

-                                                        default_result_printer);

-    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners,

-                                                       default_xml_printer);

-    listeners.Append(extra_listener);

-  }

-  EXPECT_TRUE(default_result_printer_is_destroyed);

-  EXPECT_TRUE(default_xml_printer_is_destroyed);

-  EXPECT_TRUE(extra_listener_is_destroyed);

-}

-

-// Tests that a listener Append'ed to a TestEventListeners list starts

-// receiving events.

-TEST(TestEventListenersTest, Append) {

-  int on_start_counter = 0;

-  bool is_destroyed = false;

-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);

-  {

-    TestEventListeners listeners;

-    listeners.Append(listener);

-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-        *UnitTest::GetInstance());

-    EXPECT_EQ(1, on_start_counter);

-  }

-  EXPECT_TRUE(is_destroyed);

-}

-

-// Tests that listeners receive events in the order they were appended to

-// the list, except for *End requests, which must be received in the reverse

-// order.

-class SequenceTestingListener : public EmptyTestEventListener {

- public:

-  SequenceTestingListener(Vector<String>* vector, const char* id)

-      : vector_(vector), id_(id) {}

-

- protected:

-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {

-    vector_->PushBack(GetEventDescription("OnTestProgramStart"));

-  }

-

-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {

-    vector_->PushBack(GetEventDescription("OnTestProgramEnd"));

-  }

-

-  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,

-                                    int /*iteration*/) {

-    vector_->PushBack(GetEventDescription("OnTestIterationStart"));

-  }

-

-  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,

-                                  int /*iteration*/) {

-    vector_->PushBack(GetEventDescription("OnTestIterationEnd"));

-  }

-

- private:

-  String GetEventDescription(const char* method) {

-    Message message;

-    message << id_ << "." << method;

-    return message.GetString();

-  }

-

-  Vector<String>* vector_;

-  const char* const id_;

-

-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);

-};

-

-TEST(EventListenerTest, AppendKeepsOrder) {

-  Vector<String> vec;

-  TestEventListeners listeners;

-  listeners.Append(new SequenceTestingListener(&vec, "1st"));

-  listeners.Append(new SequenceTestingListener(&vec, "2nd"));

-  listeners.Append(new SequenceTestingListener(&vec, "3rd"));

-

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-      *UnitTest::GetInstance());

-  ASSERT_EQ(3, vec.size());

-  EXPECT_STREQ("1st.OnTestProgramStart", vec.GetElement(0).c_str());

-  EXPECT_STREQ("2nd.OnTestProgramStart", vec.GetElement(1).c_str());

-  EXPECT_STREQ("3rd.OnTestProgramStart", vec.GetElement(2).c_str());

-

-  vec.Clear();

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(

-      *UnitTest::GetInstance());

-  ASSERT_EQ(3, vec.size());

-  EXPECT_STREQ("3rd.OnTestProgramEnd", vec.GetElement(0).c_str());

-  EXPECT_STREQ("2nd.OnTestProgramEnd", vec.GetElement(1).c_str());

-  EXPECT_STREQ("1st.OnTestProgramEnd", vec.GetElement(2).c_str());

-

-  vec.Clear();

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(

-      *UnitTest::GetInstance(), 0);

-  ASSERT_EQ(3, vec.size());

-  EXPECT_STREQ("1st.OnTestIterationStart", vec.GetElement(0).c_str());

-  EXPECT_STREQ("2nd.OnTestIterationStart", vec.GetElement(1).c_str());

-  EXPECT_STREQ("3rd.OnTestIterationStart", vec.GetElement(2).c_str());

-

-  vec.Clear();

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(

-      *UnitTest::GetInstance(), 0);

-  ASSERT_EQ(3, vec.size());

-  EXPECT_STREQ("3rd.OnTestIterationEnd", vec.GetElement(0).c_str());

-  EXPECT_STREQ("2nd.OnTestIterationEnd", vec.GetElement(1).c_str());

-  EXPECT_STREQ("1st.OnTestIterationEnd", vec.GetElement(2).c_str());

-}

-

-// Tests that a listener removed from a TestEventListeners list stops receiving

-// events and is not deleted when the list is destroyed.

-TEST(TestEventListenersTest, Release) {

-  int on_start_counter = 0;

-  bool is_destroyed = false;

-  // Although Append passes the ownership of this object to the list,

-  // the following calls release it, and we need to delete it before the

-  // test ends.

-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);

-  {

-    TestEventListeners listeners;

-    listeners.Append(listener);

-    EXPECT_EQ(listener, listeners.Release(listener));

-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-        *UnitTest::GetInstance());

-    EXPECT_TRUE(listeners.Release(listener) == NULL);

-  }

-  EXPECT_EQ(0, on_start_counter);

-  EXPECT_FALSE(is_destroyed);

-  delete listener;

-}

-

-// Tests that no events are forwarded when event forwarding is disabled.

-TEST(EventListenerTest, SuppressEventForwarding) {

-  int on_start_counter = 0;

-  TestListener* listener = new TestListener(&on_start_counter, NULL);

-

-  TestEventListeners listeners;

-  listeners.Append(listener);

-  ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));

-  TestEventListenersAccessor::SuppressEventForwarding(&listeners);

-  ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-      *UnitTest::GetInstance());

-  EXPECT_EQ(0, on_start_counter);

-}

-

-// Tests that events generated by Google Test are not forwarded in

-// death test subprocesses.

-TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) {

-  EXPECT_DEATH_IF_SUPPORTED({

-      GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(

-          *GetUnitTestImpl()->listeners())) << "expected failure";},

-      "expected failure");

-}

-

-// Tests that a listener installed via SetDefaultResultPrinter() starts

-// receiving events and is returned via default_result_printer() and that

-// the previous default_result_printer is removed from the list and deleted.

-TEST(EventListenerTest, default_result_printer) {

-  int on_start_counter = 0;

-  bool is_destroyed = false;

-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);

-

-  TestEventListeners listeners;

-  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);

-

-  EXPECT_EQ(listener, listeners.default_result_printer());

-

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-      *UnitTest::GetInstance());

-

-  EXPECT_EQ(1, on_start_counter);

-

-  // Replacing default_result_printer with something else should remove it

-  // from the list and destroy it.

-  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL);

-

-  EXPECT_TRUE(listeners.default_result_printer() == NULL);

-  EXPECT_TRUE(is_destroyed);

-

-  // After broadcasting an event the counter is still the same, indicating

-  // the listener is not in the list anymore.

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-      *UnitTest::GetInstance());

-  EXPECT_EQ(1, on_start_counter);

-}

-

-// Tests that the default_result_printer listener stops receiving events

-// when removed via Release and that is not owned by the list anymore.

-TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {

-  int on_start_counter = 0;

-  bool is_destroyed = false;

-  // Although Append passes the ownership of this object to the list,

-  // the following calls release it, and we need to delete it before the

-  // test ends.

-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);

-  {

-    TestEventListeners listeners;

-    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);

-

-    EXPECT_EQ(listener, listeners.Release(listener));

-    EXPECT_TRUE(listeners.default_result_printer() == NULL);

-    EXPECT_FALSE(is_destroyed);

-

-    // Broadcasting events now should not affect default_result_printer.

-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-        *UnitTest::GetInstance());

-    EXPECT_EQ(0, on_start_counter);

-  }

-  // Destroying the list should not affect the listener now, too.

-  EXPECT_FALSE(is_destroyed);

-  delete listener;

-}

-

-// Tests that a listener installed via SetDefaultXmlGenerator() starts

-// receiving events and is returned via default_xml_generator() and that

-// the previous default_xml_generator is removed from the list and deleted.

-TEST(EventListenerTest, default_xml_generator) {

-  int on_start_counter = 0;

-  bool is_destroyed = false;

-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);

-

-  TestEventListeners listeners;

-  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);

-

-  EXPECT_EQ(listener, listeners.default_xml_generator());

-

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-      *UnitTest::GetInstance());

-

-  EXPECT_EQ(1, on_start_counter);

-

-  // Replacing default_xml_generator with something else should remove it

-  // from the list and destroy it.

-  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL);

-

-  EXPECT_TRUE(listeners.default_xml_generator() == NULL);

-  EXPECT_TRUE(is_destroyed);

-

-  // After broadcasting an event the counter is still the same, indicating

-  // the listener is not in the list anymore.

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-      *UnitTest::GetInstance());

-  EXPECT_EQ(1, on_start_counter);

-}

-

-// Tests that the default_xml_generator listener stops receiving events

-// when removed via Release and that is not owned by the list anymore.

-TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {

-  int on_start_counter = 0;

-  bool is_destroyed = false;

-  // Although Append passes the ownership of this object to the list,

-  // the following calls release it, and we need to delete it before the

-  // test ends.

-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);

-  {

-    TestEventListeners listeners;

-    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);

-

-    EXPECT_EQ(listener, listeners.Release(listener));

-    EXPECT_TRUE(listeners.default_xml_generator() == NULL);

-    EXPECT_FALSE(is_destroyed);

-

-    // Broadcasting events now should not affect default_xml_generator.

-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(

-        *UnitTest::GetInstance());

-    EXPECT_EQ(0, on_start_counter);

-  }

-  // Destroying the list should not affect the listener now, too.

-  EXPECT_FALSE(is_destroyed);

-  delete listener;

-}

+// Copyright 2005, 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: [email protected] (Zhanyong Wan)
+//
+// Tests for Google Test itself.  This verifies that the basic constructs of
+// Google Test work.
+
+#include <gtest/gtest.h>
+
+// Verifies that the command line flag variables can be accessed
+// in code once <gtest/gtest.h> has been #included.
+// Do not move it after other #includes.
+TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
+  bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)
+      || testing::GTEST_FLAG(break_on_failure)
+      || testing::GTEST_FLAG(catch_exceptions)
+      || testing::GTEST_FLAG(color) != "unknown"
+      || testing::GTEST_FLAG(filter) != "unknown"
+      || testing::GTEST_FLAG(list_tests)
+      || testing::GTEST_FLAG(output) != "unknown"
+      || testing::GTEST_FLAG(print_time)
+      || testing::GTEST_FLAG(random_seed)
+      || testing::GTEST_FLAG(repeat) > 0
+      || testing::GTEST_FLAG(show_internal_stack_frames)
+      || testing::GTEST_FLAG(shuffle)
+      || testing::GTEST_FLAG(stack_trace_depth) > 0
+      || testing::GTEST_FLAG(throw_on_failure);
+  EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.
+}
+
+#include <gtest/gtest-spi.h>
+
+// 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_
+
+#include <limits.h>  // For INT_MAX.
+#include <stdlib.h>
+#include <time.h>
+
+#if GTEST_HAS_PTHREAD
+#include <pthread.h>
+#endif  // GTEST_HAS_PTHREAD
+
+#ifdef __BORLANDC__
+#include <map>
+#endif
+
+namespace testing {
+namespace internal {
+
+bool ShouldUseColor(bool stdout_is_tty);
+const char* FormatTimeInMillisAsSeconds(TimeInMillis ms);
+bool ParseInt32Flag(const char* str, const char* flag, Int32* value);
+
+// Provides access to otherwise private parts of the TestEventListeners class
+// that are needed to test it.
+class TestEventListenersAccessor {
+ public:
+  static TestEventListener* GetRepeater(TestEventListeners* listeners) {
+    return listeners->repeater();
+  }
+
+  static void SetDefaultResultPrinter(TestEventListeners* listeners,
+                                      TestEventListener* listener) {
+    listeners->SetDefaultResultPrinter(listener);
+  }
+  static void SetDefaultXmlGenerator(TestEventListeners* listeners,
+                                     TestEventListener* listener) {
+    listeners->SetDefaultXmlGenerator(listener);
+  }
+
+  static bool EventForwardingEnabled(const TestEventListeners& listeners) {
+    return listeners.EventForwardingEnabled();
+  }
+
+  static void SuppressEventForwarding(TestEventListeners* listeners) {
+    listeners->SuppressEventForwarding();
+  }
+};
+
+}  // namespace internal
+}  // namespace testing
+
+using testing::AssertionFailure;
+using testing::AssertionResult;
+using testing::AssertionSuccess;
+using testing::DoubleLE;
+using testing::EmptyTestEventListener;
+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(death_test_use_fork);
+using testing::GTEST_FLAG(filter);
+using testing::GTEST_FLAG(list_tests);
+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(show_internal_stack_frames);
+using testing::GTEST_FLAG(shuffle);
+using testing::GTEST_FLAG(stack_trace_depth);
+using testing::GTEST_FLAG(throw_on_failure);
+using testing::IsNotSubstring;
+using testing::IsSubstring;
+using testing::Message;
+using testing::ScopedFakeTestPartResultReporter;
+using testing::StaticAssertTypeEq;
+using testing::Test;
+using testing::TestEventListeners;
+using testing::TestCase;
+using testing::TestPartResult;
+using testing::TestPartResultArray;
+using testing::TestProperty;
+using testing::TestResult;
+using testing::UnitTest;
+using testing::internal::AlwaysFalse;
+using testing::internal::AlwaysTrue;
+using testing::internal::AppendUserMessage;
+using testing::internal::CodePointToUtf8;
+using testing::internal::EqFailure;
+using testing::internal::FloatingPoint;
+using testing::internal::FormatTimeInMillisAsSeconds;
+using testing::internal::GTestFlagSaver;
+using testing::internal::GetCurrentOsStackTraceExceptTop;
+using testing::internal::GetNextRandomSeed;
+using testing::internal::GetRandomSeedFromFlag;
+using testing::internal::GetTestTypeId;
+using testing::internal::GetTypeId;
+using testing::internal::GetUnitTestImpl;
+using testing::internal::Int32;
+using testing::internal::Int32FromEnvOrDie;
+using testing::internal::ParseInt32Flag;
+using testing::internal::ShouldRunTestOnShard;
+using testing::internal::ShouldShard;
+using testing::internal::ShouldUseColor;
+using testing::internal::StreamableToString;
+using testing::internal::String;
+using testing::internal::TestEventListenersAccessor;
+using testing::internal::TestResultAccessor;
+using testing::internal::ThreadLocal;
+using testing::internal::UInt32;
+using testing::internal::Vector;
+using testing::internal::WideStringToUtf8;
+using testing::internal::kMaxRandomSeed;
+using testing::internal::kTestTypeIdInGoogleTest;
+using testing::internal::scoped_ptr;
+
+class TestingVector : public Vector<int> {
+};
+
+::std::ostream& operator<<(::std::ostream& os,
+                           const TestingVector& vector) {
+  os << "{ ";
+  for (int i = 0; i < vector.size(); i++) {
+    os << vector.GetElement(i) << " ";
+  }
+  os << "}";
+  return os;
+}
+
+// This line tests that we can define tests in an unnamed namespace.
+namespace {
+
+TEST(GetRandomSeedFromFlagTest, HandlesZero) {
+  const int seed = GetRandomSeedFromFlag(0);
+  EXPECT_LE(1, seed);
+  EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed));
+}
+
+TEST(GetRandomSeedFromFlagTest, PreservesValidSeed) {
+  EXPECT_EQ(1, GetRandomSeedFromFlag(1));
+  EXPECT_EQ(2, GetRandomSeedFromFlag(2));
+  EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1));
+  EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
+            GetRandomSeedFromFlag(kMaxRandomSeed));
+}
+
+TEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) {
+  const int seed1 = GetRandomSeedFromFlag(-1);
+  EXPECT_LE(1, seed1);
+  EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed));
+
+  const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1);
+  EXPECT_LE(1, seed2);
+  EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed));
+}
+
+TEST(GetNextRandomSeedTest, WorksForValidInput) {
+  EXPECT_EQ(2, GetNextRandomSeed(1));
+  EXPECT_EQ(3, GetNextRandomSeed(2));
+  EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
+            GetNextRandomSeed(kMaxRandomSeed - 1));
+  EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed));
+
+  // We deliberately don't test GetNextRandomSeed() with invalid
+  // inputs, as that requires death tests, which are expensive.  This
+  // is fine as GetNextRandomSeed() is internal and has a
+  // straightforward definition.
+}
+
+static void ClearCurrentTestPartResults() {
+  TestResultAccessor::ClearTestPartResults(
+      GetUnitTestImpl()->current_test_result());
+}
+
+// Tests GetTypeId.
+
+TEST(GetTypeIdTest, ReturnsSameValueForSameType) {
+  EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>());
+  EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>());
+}
+
+class SubClassOfTest : public Test {};
+class AnotherSubClassOfTest : public Test {};
+
+TEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) {
+  EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>());
+  EXPECT_NE(GetTypeId<int>(), GetTypeId<char>());
+  EXPECT_NE(GetTypeId<int>(), GetTestTypeId());
+  EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId());
+  EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId());
+  EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>());
+}
+
+// Verifies that GetTestTypeId() returns the same value, no matter it
+// is called from inside Google Test or outside of it.
+TEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) {
+  EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId());
+}
+
+// Tests FormatTimeInMillisAsSeconds().
+
+TEST(FormatTimeInMillisAsSecondsTest, FormatsZero) {
+  EXPECT_STREQ("0", FormatTimeInMillisAsSeconds(0));
+}
+
+TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {
+  EXPECT_STREQ("0.003", FormatTimeInMillisAsSeconds(3));
+  EXPECT_STREQ("0.01", FormatTimeInMillisAsSeconds(10));
+  EXPECT_STREQ("0.2", FormatTimeInMillisAsSeconds(200));
+  EXPECT_STREQ("1.2", FormatTimeInMillisAsSeconds(1200));
+  EXPECT_STREQ("3", FormatTimeInMillisAsSeconds(3000));
+}
+
+TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
+  EXPECT_STREQ("-0.003", FormatTimeInMillisAsSeconds(-3));
+  EXPECT_STREQ("-0.01", FormatTimeInMillisAsSeconds(-10));
+  EXPECT_STREQ("-0.2", FormatTimeInMillisAsSeconds(-200));
+  EXPECT_STREQ("-1.2", FormatTimeInMillisAsSeconds(-1200));
+  EXPECT_STREQ("-3", FormatTimeInMillisAsSeconds(-3000));
+}
+
+#if !GTEST_OS_SYMBIAN
+// NULL testing does not work with Symbian compilers.
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true", "Unreachable code"
+#pragma option push -w-ccc -w-rch
+#endif
+
+// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null
+// pointer literal.
+TEST(NullLiteralTest, IsTrueForNullLiterals) {
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL));
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0));
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U));
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L));
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(false));
+#ifndef __BORLANDC__
+  // Some compilers may fail to detect some null pointer literals;
+  // as long as users of the framework don't use such literals, this
+  // is harmless.
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(1 - 1));
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(true && false));
+#endif
+}
+
+// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null
+// pointer literal.
+TEST(NullLiteralTest, IsFalseForNonNullLiterals) {
+  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1));
+  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0));
+  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a'));
+  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL)));
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" supressed them
+#pragma option pop
+#endif
+
+#endif  // !GTEST_OS_SYMBIAN
+//
+// Tests CodePointToUtf8().
+
+// Tests that the NUL character L'\0' is encoded correctly.
+TEST(CodePointToUtf8Test, CanEncodeNul) {
+  char buffer[32];
+  EXPECT_STREQ("", CodePointToUtf8(L'\0', buffer));
+}
+
+// Tests that ASCII characters are encoded correctly.
+TEST(CodePointToUtf8Test, CanEncodeAscii) {
+  char buffer[32];
+  EXPECT_STREQ("a", CodePointToUtf8(L'a', buffer));
+  EXPECT_STREQ("Z", CodePointToUtf8(L'Z', buffer));
+  EXPECT_STREQ("&", CodePointToUtf8(L'&', buffer));
+  EXPECT_STREQ("\x7F", CodePointToUtf8(L'\x7F', buffer));
+}
+
+// Tests that Unicode code-points that have 8 to 11 bits are encoded
+// as 110xxxxx 10xxxxxx.
+TEST(CodePointToUtf8Test, CanEncode8To11Bits) {
+  char buffer[32];
+  // 000 1101 0011 => 110-00011 10-010011
+  EXPECT_STREQ("\xC3\x93", CodePointToUtf8(L'\xD3', buffer));
+
+  // 101 0111 0110 => 110-10101 10-110110
+  EXPECT_STREQ("\xD5\xB6", CodePointToUtf8(L'\x576', buffer));
+}
+
+// Tests that Unicode code-points that have 12 to 16 bits are encoded
+// as 1110xxxx 10xxxxxx 10xxxxxx.
+TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
+  char buffer[32];
+  // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
+  EXPECT_STREQ("\xE0\xA3\x93", CodePointToUtf8(L'\x8D3', buffer));
+
+  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
+  EXPECT_STREQ("\xEC\x9D\x8D", CodePointToUtf8(L'\xC74D', buffer));
+}
+
+#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.
+
+// Tests that Unicode code-points that have 17 to 21 bits are encoded
+// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx.
+TEST(CodePointToUtf8Test, CanEncode17To21Bits) {
+  char buffer[32];
+  // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
+  EXPECT_STREQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3', buffer));
+
+  // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000
+  EXPECT_STREQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400', buffer));
+
+  // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
+  EXPECT_STREQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634', buffer));
+}
+
+// Tests that encoding an invalid code-point generates the expected result.
+TEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) {
+  char buffer[32];
+  EXPECT_STREQ("(Invalid Unicode 0x1234ABCD)",
+               CodePointToUtf8(L'\x1234ABCD', buffer));
+}
+
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
+
+// Tests WideStringToUtf8().
+
+// Tests that the NUL character L'\0' is encoded correctly.
+TEST(WideStringToUtf8Test, CanEncodeNul) {
+  EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str());
+  EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str());
+}
+
+// Tests that ASCII strings are encoded correctly.
+TEST(WideStringToUtf8Test, CanEncodeAscii) {
+  EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str());
+  EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str());
+  EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str());
+  EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str());
+}
+
+// Tests that Unicode code-points that have 8 to 11 bits are encoded
+// as 110xxxxx 10xxxxxx.
+TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
+  // 000 1101 0011 => 110-00011 10-010011
+  EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str());
+  EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str());
+
+  // 101 0111 0110 => 110-10101 10-110110
+  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", 1).c_str());
+  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", -1).c_str());
+}
+
+// Tests that Unicode code-points that have 12 to 16 bits are encoded
+// as 1110xxxx 10xxxxxx 10xxxxxx.
+TEST(WideStringToUtf8Test, CanEncode12To16Bits) {
+  // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
+  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", 1).c_str());
+  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", -1).c_str());
+
+  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
+  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", 1).c_str());
+  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", -1).c_str());
+}
+
+// Tests that the conversion stops when the function encounters \0 character.
+TEST(WideStringToUtf8Test, StopsOnNulCharacter) {
+  EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str());
+}
+
+// Tests that the conversion stops when the function reaches the limit
+// specified by the 'length' parameter.
+TEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) {
+  EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str());
+}
+
+
+#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.
+TEST(WideStringToUtf8Test, CanEncode17To21Bits) {
+  // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
+  EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str());
+  EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str());
+
+  // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
+  EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str());
+  EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str());
+}
+
+// Tests that encoding an invalid code-point generates the expected result.
+TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
+  EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",
+               WideStringToUtf8(L"\xABCDFF", -1).c_str());
+}
+#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) {
+  EXPECT_STREQ("\xF0\x90\x90\x80",
+               WideStringToUtf8(L"\xD801\xDC00", -1).c_str());
+}
+
+// Tests that encoding an invalid UTF-16 surrogate pair
+// generates the expected result.
+TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
+  // Leading surrogate is at the end of the string.
+  EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(L"\xD800", -1).c_str());
+  // Leading surrogate is not followed by the trailing surrogate.
+  EXPECT_STREQ("\xED\xA0\x80$", WideStringToUtf8(L"\xD800$", -1).c_str());
+  // Trailing surrogate appearas without a leading surrogate.
+  EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(L"\xDC00PQR", -1).c_str());
+}
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
+
+// Tests that codepoint concatenation works correctly.
+#if !GTEST_WIDE_STRING_USES_UTF16_
+TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
+  EXPECT_STREQ(
+      "\xF4\x88\x98\xB4"
+          "\xEC\x9D\x8D"
+          "\n"
+          "\xD5\xB6"
+          "\xE0\xA3\x93"
+          "\xF4\x88\x98\xB4",
+      WideStringToUtf8(L"\x108634\xC74D\n\x576\x8D3\x108634", -1).c_str());
+}
+#else
+TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
+  EXPECT_STREQ(
+      "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
+      WideStringToUtf8(L"\xC74D\n\x576\x8D3", -1).c_str());
+}
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
+
+// Tests the Random class.
+
+TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {
+  testing::internal::Random random(42);
+  EXPECT_DEATH_IF_SUPPORTED(
+      random.Generate(0),
+      "Cannot generate a number in the range \\[0, 0\\)");
+  EXPECT_DEATH_IF_SUPPORTED(
+      random.Generate(testing::internal::Random::kMaxRange + 1),
+      "Generation of a number in \\[0, 2147483649\\) was requested, "
+      "but this can only generate numbers in \\[0, 2147483648\\)");
+}
+
+TEST(RandomTest, GeneratesNumbersWithinRange) {
+  const UInt32 kRange = 10000;
+  testing::internal::Random random(12345);
+  for (int i = 0; i < 10; i++) {
+    EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i;
+  }
+
+  testing::internal::Random random2(testing::internal::Random::kMaxRange);
+  for (int i = 0; i < 10; i++) {
+    EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i;
+  }
+}
+
+TEST(RandomTest, RepeatsWhenReseeded) {
+  const int kSeed = 123;
+  const int kArraySize = 10;
+  const UInt32 kRange = 10000;
+  UInt32 values[kArraySize];
+
+  testing::internal::Random random(kSeed);
+  for (int i = 0; i < kArraySize; i++) {
+    values[i] = random.Generate(kRange);
+  }
+
+  random.Reseed(kSeed);
+  for (int i = 0; i < kArraySize; i++) {
+    EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i;
+  }
+}
+
+// Tests the Vector class template.
+
+// Tests Vector::Clear().
+TEST(VectorTest, Clear) {
+  Vector<int> a;
+  a.PushBack(1);
+  a.Clear();
+  EXPECT_EQ(0, a.size());
+
+  a.PushBack(2);
+  a.PushBack(3);
+  a.Clear();
+  EXPECT_EQ(0, a.size());
+}
+
+// Tests Vector::PushBack().
+TEST(VectorTest, PushBack) {
+  Vector<char> a;
+  a.PushBack('a');
+  ASSERT_EQ(1, a.size());
+  EXPECT_EQ('a', a.GetElement(0));
+
+  a.PushBack('b');
+  ASSERT_EQ(2, a.size());
+  EXPECT_EQ('a', a.GetElement(0));
+  EXPECT_EQ('b', a.GetElement(1));
+}
+
+// Tests Vector::PushFront().
+TEST(VectorTest, PushFront) {
+  Vector<int> a;
+  ASSERT_EQ(0, a.size());
+
+  // Calls PushFront() on an empty Vector.
+  a.PushFront(1);
+  ASSERT_EQ(1, a.size());
+  EXPECT_EQ(1, a.GetElement(0));
+
+  // Calls PushFront() on a singleton Vector.
+  a.PushFront(2);
+  ASSERT_EQ(2, a.size());
+  EXPECT_EQ(2, a.GetElement(0));
+  EXPECT_EQ(1, a.GetElement(1));
+
+  // Calls PushFront() on a Vector with more than one elements.
+  a.PushFront(3);
+  ASSERT_EQ(3, a.size());
+  EXPECT_EQ(3, a.GetElement(0));
+  EXPECT_EQ(2, a.GetElement(1));
+  EXPECT_EQ(1, a.GetElement(2));
+}
+
+// Tests Vector::PopFront().
+TEST(VectorTest, PopFront) {
+  Vector<int> a;
+
+  // Popping on an empty Vector should fail.
+  EXPECT_FALSE(a.PopFront(NULL));
+
+  // Popping again on an empty Vector should fail, and the result element
+  // shouldn't be overwritten.
+  int element = 1;
+  EXPECT_FALSE(a.PopFront(&element));
+  EXPECT_EQ(1, element);
+
+  a.PushFront(2);
+  a.PushFront(3);
+
+  // PopFront() should pop the element in the front of the Vector.
+  EXPECT_TRUE(a.PopFront(&element));
+  EXPECT_EQ(3, element);
+
+  // After popping the last element, the Vector should be empty.
+  EXPECT_TRUE(a.PopFront(NULL));
+  EXPECT_EQ(0, a.size());
+}
+
+// Tests inserting at the beginning using Vector::Insert().
+TEST(VectorTest, InsertAtBeginning) {
+  Vector<int> a;
+  ASSERT_EQ(0, a.size());
+
+  // Inserts into an empty Vector.
+  a.Insert(1, 0);
+  ASSERT_EQ(1, a.size());
+  EXPECT_EQ(1, a.GetElement(0));
+
+  // Inserts at the beginning of a singleton Vector.
+  a.Insert(2, 0);
+  ASSERT_EQ(2, a.size());
+  EXPECT_EQ(2, a.GetElement(0));
+  EXPECT_EQ(1, a.GetElement(1));
+
+  // Inserts at the beginning of a Vector with more than one elements.
+  a.Insert(3, 0);
+  ASSERT_EQ(3, a.size());
+  EXPECT_EQ(3, a.GetElement(0));
+  EXPECT_EQ(2, a.GetElement(1));
+  EXPECT_EQ(1, a.GetElement(2));
+}
+
+// Tests inserting at a location other than the beginning using
+// Vector::Insert().
+TEST(VectorTest, InsertNotAtBeginning) {
+  // Prepares a singleton Vector.
+  Vector<int> a;
+  a.PushBack(1);
+
+  // Inserts at the end of a singleton Vector.
+  a.Insert(2, a.size());
+  ASSERT_EQ(2, a.size());
+  EXPECT_EQ(1, a.GetElement(0));
+  EXPECT_EQ(2, a.GetElement(1));
+
+  // Inserts at the end of a Vector with more than one elements.
+  a.Insert(3, a.size());
+  ASSERT_EQ(3, a.size());
+  EXPECT_EQ(1, a.GetElement(0));
+  EXPECT_EQ(2, a.GetElement(1));
+  EXPECT_EQ(3, a.GetElement(2));
+
+  // Inserts in the middle of a Vector.
+  a.Insert(4, 1);
+  ASSERT_EQ(4, a.size());
+  EXPECT_EQ(1, a.GetElement(0));
+  EXPECT_EQ(4, a.GetElement(1));
+  EXPECT_EQ(2, a.GetElement(2));
+  EXPECT_EQ(3, a.GetElement(3));
+}
+
+// Tests Vector::GetElementOr().
+TEST(VectorTest, GetElementOr) {
+  Vector<char> a;
+  EXPECT_EQ('x', a.GetElementOr(0, 'x'));
+
+  a.PushBack('a');
+  a.PushBack('b');
+  EXPECT_EQ('a', a.GetElementOr(0, 'x'));
+  EXPECT_EQ('b', a.GetElementOr(1, 'x'));
+  EXPECT_EQ('x', a.GetElementOr(-2, 'x'));
+  EXPECT_EQ('x', a.GetElementOr(2, 'x'));
+}
+
+TEST(VectorTest, Swap) {
+  Vector<int> a;
+  a.PushBack(0);
+  a.PushBack(1);
+  a.PushBack(2);
+
+  // Swaps an element with itself.
+  a.Swap(0, 0);
+  ASSERT_EQ(0, a.GetElement(0));
+  ASSERT_EQ(1, a.GetElement(1));
+  ASSERT_EQ(2, a.GetElement(2));
+
+  // Swaps two different elements where the indices go up.
+  a.Swap(0, 1);
+  ASSERT_EQ(1, a.GetElement(0));
+  ASSERT_EQ(0, a.GetElement(1));
+  ASSERT_EQ(2, a.GetElement(2));
+
+  // Swaps two different elements where the indices go down.
+  a.Swap(2, 0);
+  ASSERT_EQ(2, a.GetElement(0));
+  ASSERT_EQ(0, a.GetElement(1));
+  ASSERT_EQ(1, a.GetElement(2));
+}
+
+TEST(VectorTest, Clone) {
+  // Clones an empty Vector.
+  Vector<int> a;
+  scoped_ptr<Vector<int> > empty(a.Clone());
+  EXPECT_EQ(0, empty->size());
+
+  // Clones a singleton.
+  a.PushBack(42);
+  scoped_ptr<Vector<int> > singleton(a.Clone());
+  ASSERT_EQ(1, singleton->size());
+  EXPECT_EQ(42, singleton->GetElement(0));
+
+  // Clones a Vector with more elements.
+  a.PushBack(43);
+  a.PushBack(44);
+  scoped_ptr<Vector<int> > big(a.Clone());
+  ASSERT_EQ(3, big->size());
+  EXPECT_EQ(42, big->GetElement(0));
+  EXPECT_EQ(43, big->GetElement(1));
+  EXPECT_EQ(44, big->GetElement(2));
+}
+
+// Tests Vector::Erase().
+TEST(VectorDeathTest, Erase) {
+  Vector<int> a;
+
+  // Tests erasing from an empty vector.
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.Erase(0),
+      "Invalid Vector index 0: must be in range \\[0, -1\\]\\.");
+
+  // Tests erasing from a singleton vector.
+  a.PushBack(0);
+
+  a.Erase(0);
+  EXPECT_EQ(0, a.size());
+
+  // Tests Erase parameters beyond the bounds of the vector.
+  Vector<int> a1;
+  a1.PushBack(0);
+  a1.PushBack(1);
+  a1.PushBack(2);
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      a1.Erase(3),
+      "Invalid Vector index 3: must be in range \\[0, 2\\]\\.");
+  EXPECT_DEATH_IF_SUPPORTED(
+      a1.Erase(-1),
+      "Invalid Vector index -1: must be in range \\[0, 2\\]\\.");
+
+  // Tests erasing at the end of the vector.
+  Vector<int> a2;
+  a2.PushBack(0);
+  a2.PushBack(1);
+  a2.PushBack(2);
+
+  a2.Erase(2);
+  ASSERT_EQ(2, a2.size());
+  EXPECT_EQ(0, a2.GetElement(0));
+  EXPECT_EQ(1, a2.GetElement(1));
+
+  // Tests erasing in the middle of the vector.
+  Vector<int> a3;
+  a3.PushBack(0);
+  a3.PushBack(1);
+  a3.PushBack(2);
+
+  a3.Erase(1);
+  ASSERT_EQ(2, a3.size());
+  EXPECT_EQ(0, a3.GetElement(0));
+  EXPECT_EQ(2, a3.GetElement(1));
+
+  // Tests erasing at the beginning of the vector.
+  Vector<int> a4;
+  a4.PushBack(0);
+  a4.PushBack(1);
+  a4.PushBack(2);
+
+  a4.Erase(0);
+  ASSERT_EQ(2, a4.size());
+  EXPECT_EQ(1, a4.GetElement(0));
+  EXPECT_EQ(2, a4.GetElement(1));
+}
+
+// Tests the GetElement accessor.
+TEST(VectorDeathTest, GetElement) {
+  Vector<int> a;
+  a.PushBack(0);
+  a.PushBack(1);
+  a.PushBack(2);
+  const Vector<int>& b = a;
+
+  EXPECT_EQ(0, b.GetElement(0));
+  EXPECT_EQ(1, b.GetElement(1));
+  EXPECT_EQ(2, b.GetElement(2));
+  EXPECT_DEATH_IF_SUPPORTED(
+      b.GetElement(3),
+      "Invalid Vector index 3: must be in range \\[0, 2\\]\\.");
+  EXPECT_DEATH_IF_SUPPORTED(
+      b.GetElement(-1),
+      "Invalid Vector index -1: must be in range \\[0, 2\\]\\.");
+}
+
+// Tests the GetMutableElement accessor.
+TEST(VectorDeathTest, GetMutableElement) {
+  Vector<int> a;
+  a.PushBack(0);
+  a.PushBack(1);
+  a.PushBack(2);
+
+  EXPECT_EQ(0, a.GetMutableElement(0));
+  EXPECT_EQ(1, a.GetMutableElement(1));
+  EXPECT_EQ(2, a.GetMutableElement(2));
+
+  a.GetMutableElement(0) = 42;
+  EXPECT_EQ(42, a.GetMutableElement(0));
+  EXPECT_EQ(1, a.GetMutableElement(1));
+  EXPECT_EQ(2, a.GetMutableElement(2));
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.GetMutableElement(3),
+      "Invalid Vector index 3: must be in range \\[0, 2\\]\\.");
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.GetMutableElement(-1),
+      "Invalid Vector index -1: must be in range \\[0, 2\\]\\.");
+}
+
+TEST(VectorDeathTest, Swap) {
+  Vector<int> a;
+  a.PushBack(0);
+  a.PushBack(1);
+  a.PushBack(2);
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.Swap(-1, 1),
+      "Invalid first swap element -1: must be in range \\[0, 2\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.Swap(3, 1),
+      "Invalid first swap element 3: must be in range \\[0, 2\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.Swap(1, -1),
+      "Invalid second swap element -1: must be in range \\[0, 2\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.Swap(1, 3),
+      "Invalid second swap element 3: must be in range \\[0, 2\\]");
+}
+
+TEST(VectorDeathTest, ShuffleRange) {
+  Vector<int> a;
+  a.PushBack(0);
+  a.PushBack(1);
+  a.PushBack(2);
+  testing::internal::Random random(1);
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.ShuffleRange(&random, -1, 1),
+      "Invalid shuffle range start -1: must be in range \\[0, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.ShuffleRange(&random, 4, 4),
+      "Invalid shuffle range start 4: must be in range \\[0, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.ShuffleRange(&random, 3, 2),
+      "Invalid shuffle range finish 2: must be in range \\[3, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      a.ShuffleRange(&random, 3, 4),
+      "Invalid shuffle range finish 4: must be in range \\[3, 3\\]");
+}
+
+class VectorShuffleTest : public Test {
+ protected:
+  static const int kVectorSize = 20;
+
+  VectorShuffleTest() : random_(1) {
+    for (int i = 0; i < kVectorSize; i++) {
+      vector_.PushBack(i);
+    }
+  }
+
+  static bool VectorIsCorrupt(const TestingVector& vector) {
+    if (kVectorSize != vector.size()) {
+      return true;
+    }
+
+    bool found_in_vector[kVectorSize] = { false };
+    for (int i = 0; i < vector.size(); i++) {
+      const int e = vector.GetElement(i);
+      if (e < 0 || e >= kVectorSize || found_in_vector[e]) {
+        return true;
+      }
+      found_in_vector[e] = true;
+    }
+
+    // Vector size is correct, elements' range is correct, no
+    // duplicate elements.  Therefore no corruption has occurred.
+    return false;
+  }
+
+  static bool VectorIsNotCorrupt(const TestingVector& vector) {
+    return !VectorIsCorrupt(vector);
+  }
+
+  static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) {
+    for (int i = begin; i < end; i++) {
+      if (i != vector.GetElement(i)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  static bool RangeIsUnshuffled(
+      const TestingVector& vector, int begin, int end) {
+    return !RangeIsShuffled(vector, begin, end);
+  }
+
+  static bool VectorIsShuffled(const TestingVector& vector) {
+    return RangeIsShuffled(vector, 0, vector.size());
+  }
+
+  static bool VectorIsUnshuffled(const TestingVector& vector) {
+    return !VectorIsShuffled(vector);
+  }
+
+  testing::internal::Random random_;
+  TestingVector vector_;
+};  // class VectorShuffleTest
+
+const int VectorShuffleTest::kVectorSize;
+
+TEST_F(VectorShuffleTest, HandlesEmptyRange) {
+  // Tests an empty range at the beginning...
+  vector_.ShuffleRange(&random_, 0, 0);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...in the middle...
+  vector_.ShuffleRange(&random_, kVectorSize/2, kVectorSize/2);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...at the end...
+  vector_.ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...and past the end.
+  vector_.ShuffleRange(&random_, kVectorSize, kVectorSize);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+}
+
+TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
+  // Tests a size one range at the beginning...
+  vector_.ShuffleRange(&random_, 0, 1);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...in the middle...
+  vector_.ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...and at the end.
+  vector_.ShuffleRange(&random_, kVectorSize - 1, kVectorSize);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+}
+
+// Because we use our own random number generator and a fixed seed,
+// we can guarantee that the following "random" tests will succeed.
+
+TEST_F(VectorShuffleTest, ShufflesEntireVector) {
+  vector_.Shuffle(&random_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_;
+
+  // Tests the first and last elements in particular to ensure that
+  // there are no off-by-one problems in our shuffle algorithm.
+  EXPECT_NE(0, vector_.GetElement(0));
+  EXPECT_NE(kVectorSize - 1, vector_.GetElement(kVectorSize - 1));
+}
+
+TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
+  const int kRangeSize = kVectorSize/2;
+
+  vector_.ShuffleRange(&random_, 0, kRangeSize);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize);
+}
+
+TEST_F(VectorShuffleTest, ShufflesEndOfVector) {
+  const int kRangeSize = kVectorSize / 2;
+  vector_.ShuffleRange(&random_, kRangeSize, kVectorSize);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
+  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize);
+}
+
+TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
+  int kRangeSize = kVectorSize/3;
+  vector_.ShuffleRange(&random_, kRangeSize, 2*kRangeSize);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
+  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize);
+}
+
+TEST_F(VectorShuffleTest, ShufflesRepeatably) {
+  TestingVector vector2;
+  for (int i = 0; i < kVectorSize; i++) {
+    vector2.PushBack(i);
+  }
+
+  random_.Reseed(1234);
+  vector_.Shuffle(&random_);
+  random_.Reseed(1234);
+  vector2.Shuffle(&random_);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector2);
+
+  for (int i = 0; i < kVectorSize; i++) {
+    EXPECT_EQ(vector_.GetElement(i), vector2.GetElement(i))
+        << " where i is " << i;
+  }
+}
+
+// Tests the size of the AssertHelper class.
+
+TEST(AssertHelperTest, AssertHelperIsSmall) {
+  // To avoid breaking clients that use lots of assertions in one
+  // function, we cannot grow the size of AssertHelper.
+  EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*));
+}
+
+// Tests the String class.
+
+// Tests String's constructors.
+TEST(StringTest, Constructors) {
+  // Default ctor.
+  String s1;
+  // We aren't using EXPECT_EQ(NULL, s1.c_str()) because comparing
+  // pointers with NULL isn't supported on all platforms.
+  EXPECT_EQ(0U, s1.length());
+  EXPECT_TRUE(NULL == s1.c_str());
+
+  // Implicitly constructs from a C-string.
+  String s2 = "Hi";
+  EXPECT_EQ(2U, s2.length());
+  EXPECT_STREQ("Hi", s2.c_str());
+
+  // Constructs from a C-string and a length.
+  String s3("hello", 3);
+  EXPECT_EQ(3U, s3.length());
+  EXPECT_STREQ("hel", s3.c_str());
+
+  // The empty String should be created when String is constructed with
+  // a NULL pointer and length 0.
+  EXPECT_EQ(0U, String(NULL, 0).length());
+  EXPECT_FALSE(String(NULL, 0).c_str() == NULL);
+
+  // Constructs a String that contains '\0'.
+  String s4("a\0bcd", 4);
+  EXPECT_EQ(4U, s4.length());
+  EXPECT_EQ('a', s4.c_str()[0]);
+  EXPECT_EQ('\0', s4.c_str()[1]);
+  EXPECT_EQ('b', s4.c_str()[2]);
+  EXPECT_EQ('c', s4.c_str()[3]);
+
+  // Copy ctor where the source is NULL.
+  const String null_str;
+  String s5 = null_str;
+  EXPECT_TRUE(s5.c_str() == NULL);
+
+  // Copy ctor where the source isn't NULL.
+  String s6 = s3;
+  EXPECT_EQ(3U, s6.length());
+  EXPECT_STREQ("hel", s6.c_str());
+
+  // Copy ctor where the source contains '\0'.
+  String s7 = s4;
+  EXPECT_EQ(4U, s7.length());
+  EXPECT_EQ('a', s7.c_str()[0]);
+  EXPECT_EQ('\0', s7.c_str()[1]);
+  EXPECT_EQ('b', s7.c_str()[2]);
+  EXPECT_EQ('c', s7.c_str()[3]);
+}
+
+#if GTEST_HAS_STD_STRING
+
+TEST(StringTest, ConvertsFromStdString) {
+  // An empty std::string.
+  const std::string src1("");
+  const String dest1 = src1;
+  EXPECT_EQ(0U, dest1.length());
+  EXPECT_STREQ("", dest1.c_str());
+
+  // A normal std::string.
+  const std::string src2("Hi");
+  const String dest2 = src2;
+  EXPECT_EQ(2U, dest2.length());
+  EXPECT_STREQ("Hi", dest2.c_str());
+
+  // An std::string with an embedded NUL character.
+  const char src3[] = "a\0b";
+  const String dest3 = std::string(src3, sizeof(src3));
+  EXPECT_EQ(sizeof(src3), dest3.length());
+  EXPECT_EQ('a', dest3.c_str()[0]);
+  EXPECT_EQ('\0', dest3.c_str()[1]);
+  EXPECT_EQ('b', dest3.c_str()[2]);
+}
+
+TEST(StringTest, ConvertsToStdString) {
+  // An empty String.
+  const String src1("");
+  const std::string dest1 = src1;
+  EXPECT_EQ("", dest1);
+
+  // A normal String.
+  const String src2("Hi");
+  const std::string dest2 = src2;
+  EXPECT_EQ("Hi", dest2);
+
+  // A String containing a '\0'.
+  const String src3("x\0y", 3);
+  const std::string dest3 = src3;
+  EXPECT_EQ(std::string("x\0y", 3), dest3);
+}
+
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_GLOBAL_STRING
+
+TEST(StringTest, ConvertsFromGlobalString) {
+  // An empty ::string.
+  const ::string src1("");
+  const String dest1 = src1;
+  EXPECT_EQ(0U, dest1.length());
+  EXPECT_STREQ("", dest1.c_str());
+
+  // A normal ::string.
+  const ::string src2("Hi");
+  const String dest2 = src2;
+  EXPECT_EQ(2U, dest2.length());
+  EXPECT_STREQ("Hi", dest2.c_str());
+
+  // An ::string with an embedded NUL character.
+  const char src3[] = "x\0y";
+  const String dest3 = ::string(src3, sizeof(src3));
+  EXPECT_EQ(sizeof(src3), dest3.length());
+  EXPECT_EQ('x', dest3.c_str()[0]);
+  EXPECT_EQ('\0', dest3.c_str()[1]);
+  EXPECT_EQ('y', dest3.c_str()[2]);
+}
+
+TEST(StringTest, ConvertsToGlobalString) {
+  // An empty String.
+  const String src1("");
+  const ::string dest1 = src1;
+  EXPECT_EQ("", dest1);
+
+  // A normal String.
+  const String src2("Hi");
+  const ::string dest2 = src2;
+  EXPECT_EQ("Hi", dest2);
+
+  const String src3("x\0y", 3);
+  const ::string dest3 = src3;
+  EXPECT_EQ(::string("x\0y", 3), dest3);
+}
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+// Tests String::ShowCStringQuoted().
+TEST(StringTest, ShowCStringQuoted) {
+  EXPECT_STREQ("(null)",
+               String::ShowCStringQuoted(NULL).c_str());
+  EXPECT_STREQ("\"\"",
+               String::ShowCStringQuoted("").c_str());
+  EXPECT_STREQ("\"foo\"",
+               String::ShowCStringQuoted("foo").c_str());
+}
+
+// Tests String::empty().
+TEST(StringTest, Empty) {
+  EXPECT_TRUE(String("").empty());
+  EXPECT_FALSE(String().empty());
+  EXPECT_FALSE(String(NULL).empty());
+  EXPECT_FALSE(String("a").empty());
+  EXPECT_FALSE(String("\0", 1).empty());
+}
+
+// Tests String::Compare().
+TEST(StringTest, Compare) {
+  // NULL vs NULL.
+  EXPECT_EQ(0, String().Compare(String()));
+
+  // NULL vs non-NULL.
+  EXPECT_EQ(-1, String().Compare(String("")));
+
+  // Non-NULL vs NULL.
+  EXPECT_EQ(1, String("").Compare(String()));
+
+  // The following covers non-NULL vs non-NULL.
+
+  // "" vs "".
+  EXPECT_EQ(0, String("").Compare(String("")));
+
+  // "" vs non-"".
+  EXPECT_EQ(-1, String("").Compare(String("\0", 1)));
+  EXPECT_EQ(-1, String("").Compare(" "));
+
+  // Non-"" vs "".
+  EXPECT_EQ(1, String("a").Compare(String("")));
+
+  // The following covers non-"" vs non-"".
+
+  // Same length and equal.
+  EXPECT_EQ(0, String("a").Compare(String("a")));
+
+  // Same length and different.
+  EXPECT_EQ(-1, String("a\0b", 3).Compare(String("a\0c", 3)));
+  EXPECT_EQ(1, String("b").Compare(String("a")));
+
+  // Different lengths.
+  EXPECT_EQ(-1, String("a").Compare(String("ab")));
+  EXPECT_EQ(-1, String("a").Compare(String("a\0", 2)));
+  EXPECT_EQ(1, String("abc").Compare(String("aacd")));
+}
+
+// Tests String::operator==().
+TEST(StringTest, Equals) {
+  const String null(NULL);
+  EXPECT_TRUE(null == NULL);  // NOLINT
+  EXPECT_FALSE(null == "");  // NOLINT
+  EXPECT_FALSE(null == "bar");  // NOLINT
+
+  const String empty("");
+  EXPECT_FALSE(empty == NULL);  // NOLINT
+  EXPECT_TRUE(empty == "");  // NOLINT
+  EXPECT_FALSE(empty == "bar");  // NOLINT
+
+  const String foo("foo");
+  EXPECT_FALSE(foo == NULL);  // NOLINT
+  EXPECT_FALSE(foo == "");  // NOLINT
+  EXPECT_FALSE(foo == "bar");  // NOLINT
+  EXPECT_TRUE(foo == "foo");  // NOLINT
+
+  const String bar("x\0y", 3);
+  EXPECT_FALSE(bar == "x");
+}
+
+// Tests String::operator!=().
+TEST(StringTest, NotEquals) {
+  const String null(NULL);
+  EXPECT_FALSE(null != NULL);  // NOLINT
+  EXPECT_TRUE(null != "");  // NOLINT
+  EXPECT_TRUE(null != "bar");  // NOLINT
+
+  const String empty("");
+  EXPECT_TRUE(empty != NULL);  // NOLINT
+  EXPECT_FALSE(empty != "");  // NOLINT
+  EXPECT_TRUE(empty != "bar");  // NOLINT
+
+  const String foo("foo");
+  EXPECT_TRUE(foo != NULL);  // NOLINT
+  EXPECT_TRUE(foo != "");  // NOLINT
+  EXPECT_TRUE(foo != "bar");  // NOLINT
+  EXPECT_FALSE(foo != "foo");  // NOLINT
+
+  const String bar("x\0y", 3);
+  EXPECT_TRUE(bar != "x");
+}
+
+// Tests String::length().
+TEST(StringTest, Length) {
+  EXPECT_EQ(0U, String().length());
+  EXPECT_EQ(0U, String("").length());
+  EXPECT_EQ(2U, String("ab").length());
+  EXPECT_EQ(3U, String("a\0b", 3).length());
+}
+
+// Tests String::EndsWith().
+TEST(StringTest, EndsWith) {
+  EXPECT_TRUE(String("foobar").EndsWith("bar"));
+  EXPECT_TRUE(String("foobar").EndsWith(""));
+  EXPECT_TRUE(String("").EndsWith(""));
+
+  EXPECT_FALSE(String("foobar").EndsWith("foo"));
+  EXPECT_FALSE(String("").EndsWith("foo"));
+}
+
+// Tests String::EndsWithCaseInsensitive().
+TEST(StringTest, EndsWithCaseInsensitive) {
+  EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("BAR"));
+  EXPECT_TRUE(String("foobaR").EndsWithCaseInsensitive("bar"));
+  EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive(""));
+  EXPECT_TRUE(String("").EndsWithCaseInsensitive(""));
+
+  EXPECT_FALSE(String("Foobar").EndsWithCaseInsensitive("foo"));
+  EXPECT_FALSE(String("foobar").EndsWithCaseInsensitive("Foo"));
+  EXPECT_FALSE(String("").EndsWithCaseInsensitive("foo"));
+}
+
+// C++Builder's preprocessor is buggy; it fails to expand macros that
+// appear in macro parameters after wide char literals.  Provide an alias
+// for NULL as a workaround.
+static const wchar_t* const kNull = NULL;
+
+// Tests String::CaseInsensitiveWideCStringEquals
+TEST(StringTest, CaseInsensitiveWideCStringEquals) {
+  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL));
+  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L""));
+  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull));
+  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar"));
+  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull));
+  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar"));
+  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR"));
+  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar"));
+}
+
+// Tests that NULL can be assigned to a String.
+TEST(StringTest, CanBeAssignedNULL) {
+  const String src(NULL);
+  String dest;
+
+  dest = src;
+  EXPECT_STREQ(NULL, dest.c_str());
+}
+
+// Tests that the empty string "" can be assigned to a String.
+TEST(StringTest, CanBeAssignedEmpty) {
+  const String src("");
+  String dest;
+
+  dest = src;
+  EXPECT_STREQ("", dest.c_str());
+}
+
+// Tests that a non-empty string can be assigned to a String.
+TEST(StringTest, CanBeAssignedNonEmpty) {
+  const String src("hello");
+  String dest;
+  dest = src;
+  EXPECT_EQ(5U, dest.length());
+  EXPECT_STREQ("hello", dest.c_str());
+
+  const String src2("x\0y", 3);
+  String dest2;
+  dest2 = src2;
+  EXPECT_EQ(3U, dest2.length());
+  EXPECT_EQ('x', dest2.c_str()[0]);
+  EXPECT_EQ('\0', dest2.c_str()[1]);
+  EXPECT_EQ('y', dest2.c_str()[2]);
+}
+
+// Tests that a String can be assigned to itself.
+TEST(StringTest, CanBeAssignedSelf) {
+  String dest("hello");
+
+  dest = dest;
+  EXPECT_STREQ("hello", dest.c_str());
+}
+
+// Tests streaming a String.
+TEST(StringTest, Streams) {
+  EXPECT_EQ(StreamableToString(String()), "(null)");
+  EXPECT_EQ(StreamableToString(String("")), "");
+  EXPECT_EQ(StreamableToString(String("a\0b", 3)), "a\\0b");
+}
+
+// Tests that String::Format() works.
+TEST(StringTest, FormatWorks) {
+  // Normal case: the format spec is valid, the arguments match the
+  // spec, and the result is < 4095 characters.
+  EXPECT_STREQ("Hello, 42", String::Format("%s, %d", "Hello", 42).c_str());
+
+  // Edge case: the result is 4095 characters.
+  char buffer[4096];
+  const size_t kSize = sizeof(buffer);
+  memset(buffer, 'a', kSize - 1);
+  buffer[kSize - 1] = '\0';
+  EXPECT_STREQ(buffer, String::Format("%s", buffer).c_str());
+
+  // The result needs to be 4096 characters, exceeding Format()'s limit.
+  EXPECT_STREQ("<formatting error or buffer exceeded>",
+               String::Format("x%s", buffer).c_str());
+
+#if GTEST_OS_LINUX
+  // On Linux, invalid format spec should lead to an error message.
+  // In other environment (e.g. MSVC on Windows), String::Format() may
+  // simply ignore a bad format spec, so this assertion is run on
+  // Linux only.
+  EXPECT_STREQ("<formatting error or buffer exceeded>",
+               String::Format("%").c_str());
+#endif
+}
+
+#if GTEST_OS_WINDOWS
+
+// Tests String::ShowWideCString().
+TEST(StringTest, ShowWideCString) {
+  EXPECT_STREQ("(null)",
+               String::ShowWideCString(NULL).c_str());
+  EXPECT_STREQ("", String::ShowWideCString(L"").c_str());
+  EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());
+}
+
+// Tests String::ShowWideCStringQuoted().
+TEST(StringTest, ShowWideCStringQuoted) {
+  EXPECT_STREQ("(null)",
+               String::ShowWideCStringQuoted(NULL).c_str());
+  EXPECT_STREQ("L\"\"",
+               String::ShowWideCStringQuoted(L"").c_str());
+  EXPECT_STREQ("L\"foo\"",
+               String::ShowWideCStringQuoted(L"foo").c_str());
+}
+
+#if GTEST_OS_WINDOWS_MOBILE
+TEST(StringTest, AnsiAndUtf16Null) {
+  EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));
+  EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));
+}
+
+TEST(StringTest, AnsiAndUtf16ConvertBasic) {
+  const char* ansi = String::Utf16ToAnsi(L"str");
+  EXPECT_STREQ("str", ansi);
+  delete [] ansi;
+  const WCHAR* utf16 = String::AnsiToUtf16("str");
+  EXPECT_EQ(0, wcsncmp(L"str", utf16, 3));
+  delete [] utf16;
+}
+
+TEST(StringTest, AnsiAndUtf16ConvertPathChars) {
+  const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?");
+  EXPECT_STREQ(".:\\ \"*?", ansi);
+  delete [] ansi;
+  const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?");
+  EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3));
+  delete [] utf16;
+}
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+#endif  // GTEST_OS_WINDOWS
+
+// Tests TestProperty construction.
+TEST(TestPropertyTest, StringValue) {
+  TestProperty property("key", "1");
+  EXPECT_STREQ("key", property.key());
+  EXPECT_STREQ("1", property.value());
+}
+
+// Tests TestProperty replacing a value.
+TEST(TestPropertyTest, ReplaceStringValue) {
+  TestProperty property("key", "1");
+  EXPECT_STREQ("1", property.value());
+  property.SetValue("2");
+  EXPECT_STREQ("2", property.value());
+}
+
+// AddFatalFailure() and AddNonfatalFailure() must be stand-alone
+// functions (i.e. their definitions cannot be inlined at the call
+// sites), or C++Builder won't compile the code.
+static void AddFatalFailure() {
+  FAIL() << "Expected fatal failure.";
+}
+
+static void AddNonfatalFailure() {
+  ADD_FAILURE() << "Expected non-fatal failure.";
+}
+
+class ScopedFakeTestPartResultReporterTest : public Test {
+ public:  // Must be public and not protected due to a bug in g++ 3.4.2.
+  enum FailureMode {
+    FATAL_FAILURE,
+    NONFATAL_FAILURE
+  };
+  static void AddFailure(FailureMode failure) {
+    if (failure == FATAL_FAILURE) {
+      AddFatalFailure();
+    } else {
+      AddNonfatalFailure();
+    }
+  }
+};
+
+// Tests that ScopedFakeTestPartResultReporter intercepts test
+// failures.
+TEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) {
+  TestPartResultArray results;
+  {
+    ScopedFakeTestPartResultReporter reporter(
+        ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,
+        &results);
+    AddFailure(NONFATAL_FAILURE);
+    AddFailure(FATAL_FAILURE);
+  }
+
+  EXPECT_EQ(2, results.size());
+  EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
+  EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
+}
+
+TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
+  TestPartResultArray results;
+  {
+    // Tests, that the deprecated constructor still works.
+    ScopedFakeTestPartResultReporter reporter(&results);
+    AddFailure(NONFATAL_FAILURE);
+  }
+  EXPECT_EQ(1, results.size());
+}
+
+#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
+
+class ScopedFakeTestPartResultReporterWithThreadsTest
+  : public ScopedFakeTestPartResultReporterTest {
+ protected:
+  static void AddFailureInOtherThread(FailureMode failure) {
+    pthread_t tid;
+    pthread_create(&tid,
+                   NULL,
+                   ScopedFakeTestPartResultReporterWithThreadsTest::
+                       FailureThread,
+                   &failure);
+    pthread_join(tid, NULL);
+  }
+ private:
+  static void* FailureThread(void* attr) {
+    FailureMode* failure = static_cast<FailureMode*>(attr);
+    AddFailure(*failure);
+    return NULL;
+  }
+};
+
+TEST_F(ScopedFakeTestPartResultReporterWithThreadsTest,
+       InterceptsTestFailuresInAllThreads) {
+  TestPartResultArray results;
+  {
+    ScopedFakeTestPartResultReporter reporter(
+        ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results);
+    AddFailure(NONFATAL_FAILURE);
+    AddFailure(FATAL_FAILURE);
+    AddFailureInOtherThread(NONFATAL_FAILURE);
+    AddFailureInOtherThread(FATAL_FAILURE);
+  }
+
+  EXPECT_EQ(4, results.size());
+  EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
+  EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
+  EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed());
+  EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed());
+}
+
+#endif  // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
+
+// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}.  Makes sure that they
+// work even if the failure is generated in a called function rather than
+// the current context.
+
+typedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest;
+
+TEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) {
+  EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure.");
+}
+
+TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {
+  // We have another test below to verify that the macro catches fatal
+  // failures generated on another thread.
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(),
+                                      "Expected fatal failure.");
+}
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true"
+#pragma option push -w-ccc
+#endif
+
+// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void
+// function even when the statement in it contains ASSERT_*.
+
+int NonVoidFunction() {
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
+  return 0;
+}
+
+TEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) {
+  NonVoidFunction();
+}
+
+// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the
+// current function even though 'statement' generates a fatal failure.
+
+void DoesNotAbortHelper(bool* aborted) {
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
+
+  *aborted = false;
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" supressed them
+#pragma option pop
+#endif
+
+TEST_F(ExpectFatalFailureTest, DoesNotAbort) {
+  bool aborted = true;
+  DoesNotAbortHelper(&aborted);
+  EXPECT_FALSE(aborted);
+}
+
+// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a
+// statement that contains a macro which expands to code containing an
+// unprotected comma.
+
+static int global_var = 0;
+#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++
+
+TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
+#ifndef __BORLANDC__
+  // ICE's in C++Builder 2007.
+  EXPECT_FATAL_FAILURE({
+    GTEST_USE_UNPROTECTED_COMMA_;
+    AddFatalFailure();
+  }, "");
+#endif
+
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS({
+    GTEST_USE_UNPROTECTED_COMMA_;
+    AddFatalFailure();
+  }, "");
+}
+
+// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}.
+
+typedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest;
+
+TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {
+  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
+                          "Expected non-fatal failure.");
+}
+
+TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {
+  // We have another test below to verify that the macro catches
+  // non-fatal failures generated on another thread.
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(),
+                                         "Expected non-fatal failure.");
+}
+
+// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a
+// statement that contains a macro which expands to code containing an
+// unprotected comma.
+TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
+  EXPECT_NONFATAL_FAILURE({
+    GTEST_USE_UNPROTECTED_COMMA_;
+    AddNonfatalFailure();
+  }, "");
+
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({
+    GTEST_USE_UNPROTECTED_COMMA_;
+    AddNonfatalFailure();
+  }, "");
+}
+
+#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
+
+typedef ScopedFakeTestPartResultReporterWithThreadsTest
+    ExpectFailureWithThreadsTest;
+
+TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) {
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE),
+                                      "Expected fatal failure.");
+}
+
+TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) {
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
+      AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure.");
+}
+
+#endif  // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD
+
+// Tests the TestProperty class.
+
+TEST(TestPropertyTest, ConstructorWorks) {
+  const TestProperty property("key", "value");
+  EXPECT_STREQ("key", property.key());
+  EXPECT_STREQ("value", property.value());
+}
+
+TEST(TestPropertyTest, SetValue) {
+  TestProperty property("key", "value_1");
+  EXPECT_STREQ("key", property.key());
+  property.SetValue("value_2");
+  EXPECT_STREQ("key", property.key());
+  EXPECT_STREQ("value_2", property.value());
+}
+
+// Tests the TestPartResult class.
+
+TEST(TestPartResultTest, ConstructorWorks) {
+  Message message;
+  message << "something is terribly wrong";
+  message << static_cast<const char*>(testing::internal::kStackTraceMarker);
+  message << "some unimportant stack trace";
+
+  const TestPartResult result(TestPartResult::kNonFatalFailure,
+                              "some_file.cc",
+                              42,
+                              message.GetString().c_str());
+
+  EXPECT_EQ(TestPartResult::kNonFatalFailure, result.type());
+  EXPECT_STREQ("some_file.cc", result.file_name());
+  EXPECT_EQ(42, result.line_number());
+  EXPECT_STREQ(message.GetString().c_str(), result.message());
+  EXPECT_STREQ("something is terribly wrong", result.summary());
+}
+
+TEST(TestPartResultTest, ResultAccessorsWork) {
+  const TestPartResult success(TestPartResult::kSuccess,
+                               "file.cc",
+                               42,
+                               "message");
+  EXPECT_TRUE(success.passed());
+  EXPECT_FALSE(success.failed());
+  EXPECT_FALSE(success.nonfatally_failed());
+  EXPECT_FALSE(success.fatally_failed());
+
+  const TestPartResult nonfatal_failure(TestPartResult::kNonFatalFailure,
+                                        "file.cc",
+                                        42,
+                                        "message");
+  EXPECT_FALSE(nonfatal_failure.passed());
+  EXPECT_TRUE(nonfatal_failure.failed());
+  EXPECT_TRUE(nonfatal_failure.nonfatally_failed());
+  EXPECT_FALSE(nonfatal_failure.fatally_failed());
+
+  const TestPartResult fatal_failure(TestPartResult::kFatalFailure,
+                                     "file.cc",
+                                     42,
+                                     "message");
+  EXPECT_FALSE(fatal_failure.passed());
+  EXPECT_TRUE(fatal_failure.failed());
+  EXPECT_FALSE(fatal_failure.nonfatally_failed());
+  EXPECT_TRUE(fatal_failure.fatally_failed());
+}
+
+// Tests the TestResult class
+
+// The test fixture for testing TestResult.
+class TestResultTest : public Test {
+ protected:
+  typedef Vector<TestPartResult> TPRVector;
+
+  // We make use of 2 TestPartResult objects,
+  TestPartResult * pr1, * pr2;
+
+  // ... and 3 TestResult objects.
+  TestResult * r0, * r1, * r2;
+
+  virtual void SetUp() {
+    // pr1 is for success.
+    pr1 = new TestPartResult(TestPartResult::kSuccess,
+                             "foo/bar.cc",
+                             10,
+                             "Success!");
+
+    // pr2 is for fatal failure.
+    pr2 = new TestPartResult(TestPartResult::kFatalFailure,
+                             "foo/bar.cc",
+                             -1,  // This line number means "unknown"
+                             "Failure!");
+
+    // Creates the TestResult objects.
+    r0 = new TestResult();
+    r1 = new TestResult();
+    r2 = new TestResult();
+
+    // In order to test TestResult, we need to modify its internal
+    // state, in particular the TestPartResult Vector it holds.
+    // test_part_results() returns a const reference to this Vector.
+    // We cast it to a non-const object s.t. it can be modified (yes,
+    // this is a hack).
+    TPRVector* results1 = const_cast<Vector<TestPartResult> *>(
+        &TestResultAccessor::test_part_results(*r1));
+    TPRVector* results2 = const_cast<Vector<TestPartResult> *>(
+        &TestResultAccessor::test_part_results(*r2));
+
+    // r0 is an empty TestResult.
+
+    // r1 contains a single SUCCESS TestPartResult.
+    results1->PushBack(*pr1);
+
+    // r2 contains a SUCCESS, and a FAILURE.
+    results2->PushBack(*pr1);
+    results2->PushBack(*pr2);
+  }
+
+  virtual void TearDown() {
+    delete pr1;
+    delete pr2;
+
+    delete r0;
+    delete r1;
+    delete r2;
+  }
+
+  // Helper that compares two two TestPartResults.
+  static void CompareTestPartResult(const TestPartResult& expected,
+                                    const TestPartResult& actual) {
+    EXPECT_EQ(expected.type(), actual.type());
+    EXPECT_STREQ(expected.file_name(), actual.file_name());
+    EXPECT_EQ(expected.line_number(), actual.line_number());
+    EXPECT_STREQ(expected.summary(), actual.summary());
+    EXPECT_STREQ(expected.message(), actual.message());
+    EXPECT_EQ(expected.passed(), actual.passed());
+    EXPECT_EQ(expected.failed(), actual.failed());
+    EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed());
+    EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed());
+  }
+};
+
+// Tests TestResult::total_part_count().
+TEST_F(TestResultTest, total_part_count) {
+  ASSERT_EQ(0, r0->total_part_count());
+  ASSERT_EQ(1, r1->total_part_count());
+  ASSERT_EQ(2, r2->total_part_count());
+}
+
+// Tests TestResult::Passed().
+TEST_F(TestResultTest, Passed) {
+  ASSERT_TRUE(r0->Passed());
+  ASSERT_TRUE(r1->Passed());
+  ASSERT_FALSE(r2->Passed());
+}
+
+// Tests TestResult::Failed().
+TEST_F(TestResultTest, Failed) {
+  ASSERT_FALSE(r0->Failed());
+  ASSERT_FALSE(r1->Failed());
+  ASSERT_TRUE(r2->Failed());
+}
+
+// Tests TestResult::GetTestPartResult().
+
+typedef TestResultTest TestResultDeathTest;
+
+TEST_F(TestResultDeathTest, GetTestPartResult) {
+  CompareTestPartResult(*pr1, r2->GetTestPartResult(0));
+  CompareTestPartResult(*pr2, r2->GetTestPartResult(1));
+  EXPECT_DEATH_IF_SUPPORTED(
+      r2->GetTestPartResult(2),
+      "Invalid Vector index 2: must be in range \\[0, 1\\]\\.");
+  EXPECT_DEATH_IF_SUPPORTED(
+      r2->GetTestPartResult(-1),
+      "Invalid Vector index -1: must be in range \\[0, 1\\]\\.");
+}
+
+// Tests TestResult has no properties when none are added.
+TEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) {
+  TestResult test_result;
+  ASSERT_EQ(0, test_result.test_property_count());
+}
+
+// Tests TestResult has the expected property when added.
+TEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) {
+  TestResult test_result;
+  TestProperty property("key_1", "1");
+  TestResultAccessor::RecordProperty(&test_result, property);
+  ASSERT_EQ(1, test_result.test_property_count());
+  const TestProperty& actual_property = test_result.GetTestProperty(0);
+  EXPECT_STREQ("key_1", actual_property.key());
+  EXPECT_STREQ("1", actual_property.value());
+}
+
+// Tests TestResult has multiple properties when added.
+TEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) {
+  TestResult test_result;
+  TestProperty property_1("key_1", "1");
+  TestProperty property_2("key_2", "2");
+  TestResultAccessor::RecordProperty(&test_result, property_1);
+  TestResultAccessor::RecordProperty(&test_result, property_2);
+  ASSERT_EQ(2, test_result.test_property_count());
+  const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
+  EXPECT_STREQ("key_1", actual_property_1.key());
+  EXPECT_STREQ("1", actual_property_1.value());
+
+  const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
+  EXPECT_STREQ("key_2", actual_property_2.key());
+  EXPECT_STREQ("2", actual_property_2.value());
+}
+
+// Tests TestResult::RecordProperty() overrides values for duplicate keys.
+TEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) {
+  TestResult test_result;
+  TestProperty property_1_1("key_1", "1");
+  TestProperty property_2_1("key_2", "2");
+  TestProperty property_1_2("key_1", "12");
+  TestProperty property_2_2("key_2", "22");
+  TestResultAccessor::RecordProperty(&test_result, property_1_1);
+  TestResultAccessor::RecordProperty(&test_result, property_2_1);
+  TestResultAccessor::RecordProperty(&test_result, property_1_2);
+  TestResultAccessor::RecordProperty(&test_result, property_2_2);
+
+  ASSERT_EQ(2, test_result.test_property_count());
+  const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
+  EXPECT_STREQ("key_1", actual_property_1.key());
+  EXPECT_STREQ("12", actual_property_1.value());
+
+  const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
+  EXPECT_STREQ("key_2", actual_property_2.key());
+  EXPECT_STREQ("22", actual_property_2.value());
+}
+
+// Tests TestResult::GetTestProperty().
+TEST(TestResultPropertyDeathTest, GetTestProperty) {
+  TestResult test_result;
+  TestProperty property_1("key_1", "1");
+  TestProperty property_2("key_2", "2");
+  TestProperty property_3("key_3", "3");
+  TestResultAccessor::RecordProperty(&test_result, property_1);
+  TestResultAccessor::RecordProperty(&test_result, property_2);
+  TestResultAccessor::RecordProperty(&test_result, property_3);
+
+  const TestProperty& fetched_property_1 = test_result.GetTestProperty(0);
+  const TestProperty& fetched_property_2 = test_result.GetTestProperty(1);
+  const TestProperty& fetched_property_3 = test_result.GetTestProperty(2);
+
+  EXPECT_STREQ("key_1", fetched_property_1.key());
+  EXPECT_STREQ("1", fetched_property_1.value());
+
+  EXPECT_STREQ("key_2", fetched_property_2.key());
+  EXPECT_STREQ("2", fetched_property_2.value());
+
+  EXPECT_STREQ("key_3", fetched_property_3.key());
+  EXPECT_STREQ("3", fetched_property_3.value());
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      test_result.GetTestProperty(3),
+      "Invalid Vector index 3: must be in range \\[0, 2\\]\\.");
+  EXPECT_DEATH_IF_SUPPORTED(
+      test_result.GetTestProperty(-1),
+      "Invalid Vector index -1: must be in range \\[0, 2\\]\\.");
+}
+
+// When a property using a reserved key is supplied to this function, it tests
+// that a non-fatal failure is added, a fatal failure is not added, and that the
+// property is not recorded.
+void ExpectNonFatalFailureRecordingPropertyWithReservedKey(const char* key) {
+  TestResult test_result;
+  TestProperty property(key, "1");
+  EXPECT_NONFATAL_FAILURE(
+      TestResultAccessor::RecordProperty(&test_result, property),
+      "Reserved key");
+  ASSERT_EQ(0, test_result.test_property_count()) << "Not recorded";
+}
+
+// Attempting to recording a property with the Reserved literal "name"
+// should add a non-fatal failure and the property should not be recorded.
+TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledName) {
+  ExpectNonFatalFailureRecordingPropertyWithReservedKey("name");
+}
+
+// Attempting to recording a property with the Reserved literal "status"
+// should add a non-fatal failure and the property should not be recorded.
+TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledStatus) {
+  ExpectNonFatalFailureRecordingPropertyWithReservedKey("status");
+}
+
+// Attempting to recording a property with the Reserved literal "time"
+// should add a non-fatal failure and the property should not be recorded.
+TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledTime) {
+  ExpectNonFatalFailureRecordingPropertyWithReservedKey("time");
+}
+
+// Attempting to recording a property with the Reserved literal "classname"
+// should add a non-fatal failure and the property should not be recorded.
+TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledClassname) {
+  ExpectNonFatalFailureRecordingPropertyWithReservedKey("classname");
+}
+
+// Tests that GTestFlagSaver works on Windows and Mac.
+
+class GTestFlagSaverTest : public Test {
+ protected:
+  // Saves the Google Test flags such that we can restore them later, and
+  // then sets them to their default values.  This will be called
+  // before the first test in this test case is run.
+  static void SetUpTestCase() {
+    saver_ = new GTestFlagSaver;
+
+    GTEST_FLAG(also_run_disabled_tests) = false;
+    GTEST_FLAG(break_on_failure) = false;
+    GTEST_FLAG(catch_exceptions) = false;
+    GTEST_FLAG(death_test_use_fork) = false;
+    GTEST_FLAG(color) = "auto";
+    GTEST_FLAG(filter) = "";
+    GTEST_FLAG(list_tests) = false;
+    GTEST_FLAG(output) = "";
+    GTEST_FLAG(print_time) = true;
+    GTEST_FLAG(random_seed) = 0;
+    GTEST_FLAG(repeat) = 1;
+    GTEST_FLAG(shuffle) = false;
+    GTEST_FLAG(throw_on_failure) = false;
+  }
+
+  // Restores the Google Test flags that the tests have modified.  This will
+  // be called after the last test in this test case is run.
+  static void TearDownTestCase() {
+    delete saver_;
+    saver_ = NULL;
+  }
+
+  // Verifies that the Google Test flags have their default values, and then
+  // modifies each of them.
+  void VerifyAndModifyFlags() {
+    EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests));
+    EXPECT_FALSE(GTEST_FLAG(break_on_failure));
+    EXPECT_FALSE(GTEST_FLAG(catch_exceptions));
+    EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());
+    EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));
+    EXPECT_STREQ("", GTEST_FLAG(filter).c_str());
+    EXPECT_FALSE(GTEST_FLAG(list_tests));
+    EXPECT_STREQ("", GTEST_FLAG(output).c_str());
+    EXPECT_TRUE(GTEST_FLAG(print_time));
+    EXPECT_EQ(0, GTEST_FLAG(random_seed));
+    EXPECT_EQ(1, GTEST_FLAG(repeat));
+    EXPECT_FALSE(GTEST_FLAG(shuffle));
+    EXPECT_FALSE(GTEST_FLAG(throw_on_failure));
+
+    GTEST_FLAG(also_run_disabled_tests) = true;
+    GTEST_FLAG(break_on_failure) = true;
+    GTEST_FLAG(catch_exceptions) = true;
+    GTEST_FLAG(color) = "no";
+    GTEST_FLAG(death_test_use_fork) = true;
+    GTEST_FLAG(filter) = "abc";
+    GTEST_FLAG(list_tests) = true;
+    GTEST_FLAG(output) = "xml:foo.xml";
+    GTEST_FLAG(print_time) = false;
+    GTEST_FLAG(random_seed) = 1;
+    GTEST_FLAG(repeat) = 100;
+    GTEST_FLAG(shuffle) = true;
+    GTEST_FLAG(throw_on_failure) = true;
+  }
+ private:
+  // For saving Google Test flags during this test case.
+  static GTestFlagSaver* saver_;
+};
+
+GTestFlagSaver* GTestFlagSaverTest::saver_ = NULL;
+
+// Google Test doesn't guarantee the order of tests.  The following two
+// tests are designed to work regardless of their order.
+
+// Modifies the Google Test flags in the test body.
+TEST_F(GTestFlagSaverTest, ModifyGTestFlags) {
+  VerifyAndModifyFlags();
+}
+
+// Verifies that the Google Test flags in the body of the previous test were
+// restored to their original values.
+TEST_F(GTestFlagSaverTest, VerifyGTestFlags) {
+  VerifyAndModifyFlags();
+}
+
+// Sets an environment variable with the given name to the given
+// value.  If the value argument is "", unsets the environment
+// variable.  The caller must ensure that both arguments are not NULL.
+static void SetEnv(const char* name, const char* value) {
+#if GTEST_OS_WINDOWS_MOBILE
+  // Environment variables are not supported on Windows CE.
+  return;
+#elif defined(__BORLANDC__)
+  // C++Builder's putenv only stores a pointer to its parameter; we have to
+  // ensure that the string remains valid as long as it might be needed.
+  // We use an std::map to do so.
+  static std::map<String, String*> added_env;
+
+  // Because putenv stores a pointer to the string buffer, we can't delete the
+  // previous string (if present) until after it's replaced.
+  String *prev_env = NULL;
+  if (added_env.find(name) != added_env.end()) {
+    prev_env = added_env[name];
+  }
+  added_env[name] = new String((Message() << name << "=" << value).GetString());
+  putenv(added_env[name]->c_str());
+  delete prev_env;
+#elif GTEST_OS_WINDOWS  // If we are on Windows proper.
+  _putenv((Message() << name << "=" << value).GetString().c_str());
+#else
+  if (*value == '\0') {
+    unsetenv(name);
+  } else {
+    setenv(name, value, 1);
+  }
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+// Environment variables are not supported on Windows CE.
+
+using testing::internal::Int32FromGTestEnv;
+
+// Tests Int32FromGTestEnv().
+
+// Tests that Int32FromGTestEnv() returns the default value when the
+// environment variable is not set.
+TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "");
+  EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));
+}
+
+// Tests that Int32FromGTestEnv() returns the default value when the
+// environment variable overflows as an Int32.
+TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {
+  printf("(expecting 2 warnings)\n");
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321");
+  EXPECT_EQ(20, Int32FromGTestEnv("temp", 20));
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321");
+  EXPECT_EQ(30, Int32FromGTestEnv("temp", 30));
+}
+
+// Tests that Int32FromGTestEnv() returns the default value when the
+// environment variable does not represent a valid decimal integer.
+TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
+  printf("(expecting 2 warnings)\n");
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1");
+  EXPECT_EQ(40, Int32FromGTestEnv("temp", 40));
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X");
+  EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));
+}
+
+// Tests that Int32FromGTestEnv() parses and returns the value of the
+// 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");
+  EXPECT_EQ(123, Int32FromGTestEnv("temp", 0));
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321");
+  EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0));
+}
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Tests ParseInt32Flag().
+
+// Tests that ParseInt32Flag() returns false and doesn't change the
+// output value when the flag has wrong format
+TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {
+  Int32 value = 123;
+  EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value));
+  EXPECT_EQ(123, value);
+
+  EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value));
+  EXPECT_EQ(123, value);
+}
+
+// Tests that ParseInt32Flag() returns false and doesn't change the
+// output value when the flag overflows as an Int32.
+TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {
+  printf("(expecting 2 warnings)\n");
+
+  Int32 value = 123;
+  EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value));
+  EXPECT_EQ(123, value);
+
+  EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value));
+  EXPECT_EQ(123, value);
+}
+
+// Tests that ParseInt32Flag() returns false and doesn't change the
+// output value when the flag does not represent a valid decimal
+// integer.
+TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
+  printf("(expecting 2 warnings)\n");
+
+  Int32 value = 123;
+  EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value));
+  EXPECT_EQ(123, value);
+
+  EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value));
+  EXPECT_EQ(123, value);
+}
+
+// Tests that ParseInt32Flag() parses the value of the flag and
+// returns true when the flag represents a valid decimal integer in
+// the range of an Int32.
+TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
+  Int32 value = 123;
+  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_EQ(-789, value);
+}
+
+// Tests that Int32FromEnvOrDie() parses the value of the var or
+// returns the correct default.
+// Environment variables are not supported on Windows CE.
+#if !GTEST_OS_WINDOWS_MOBILE
+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));
+}
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// 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_IF_SUPPORTED(
+      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_IF_SUPPORTED(
+      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
+      ".*");
+}
+
+// Tests that ShouldRunTestOnShard() selects all tests
+// where there is 1 shard.
+TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) {
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0));
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1));
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2));
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3));
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4));
+}
+
+class ShouldShardTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX";
+    total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL";
+  }
+
+  virtual void TearDown() {
+    SetEnv(index_var_, "");
+    SetEnv(total_var_, "");
+  }
+
+  const char* index_var_;
+  const char* total_var_;
+};
+
+// Tests that sharding is disabled if neither of the environment variables
+// are set.
+TEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) {
+  SetEnv(index_var_, "");
+  SetEnv(total_var_, "");
+
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+}
+
+// Tests that sharding is not enabled if total_shards  == 1.
+TEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) {
+  SetEnv(index_var_, "0");
+  SetEnv(total_var_, "1");
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+}
+
+// Tests that sharding is enabled if total_shards > 1 and
+// we are not in a death test subprocess.
+// Environment variables are not supported on Windows CE.
+#if !GTEST_OS_WINDOWS_MOBILE
+TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {
+  SetEnv(index_var_, "4");
+  SetEnv(total_var_, "22");
+  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+
+  SetEnv(index_var_, "8");
+  SetEnv(total_var_, "9");
+  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+
+  SetEnv(index_var_, "0");
+  SetEnv(total_var_, "9");
+  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+}
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Tests that we exit in error if the sharding values are not valid.
+
+typedef ShouldShardTest ShouldShardDeathTest;
+
+TEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) {
+  SetEnv(index_var_, "4");
+  SetEnv(total_var_, "4");
+  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
+
+  SetEnv(index_var_, "4");
+  SetEnv(total_var_, "-2");
+  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
+
+  SetEnv(index_var_, "5");
+  SetEnv(total_var_, "");
+  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
+
+  SetEnv(index_var_, "");
+  SetEnv(total_var_, "5");
+  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
+}
+
+// Tests that ShouldRunTestOnShard is a partition when 5
+// shards are used.
+TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
+  // Choose an arbitrary number of tests and shards.
+  const int num_tests = 17;
+  const int num_shards = 5;
+
+  // Check partitioning: each test should be on exactly 1 shard.
+  for (int test_id = 0; test_id < num_tests; test_id++) {
+    int prev_selected_shard_index = -1;
+    for (int shard_index = 0; shard_index < num_shards; shard_index++) {
+      if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) {
+        if (prev_selected_shard_index < 0) {
+          prev_selected_shard_index = shard_index;
+        } else {
+          ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and "
+            << shard_index << " are both selected to run test " << test_id;
+        }
+      }
+    }
+  }
+
+  // Check balance: This is not required by the sharding protocol, but is a
+  // desirable property for performance.
+  for (int shard_index = 0; shard_index < num_shards; shard_index++) {
+    int num_tests_on_shard = 0;
+    for (int test_id = 0; test_id < num_tests; test_id++) {
+      num_tests_on_shard +=
+        ShouldRunTestOnShard(num_shards, shard_index, test_id);
+    }
+    EXPECT_GE(num_tests_on_shard, num_tests / num_shards);
+  }
+}
+
+// For the same reason we are not explicitly testing everything in the
+// Test class, there are no separate tests for the following classes
+// (except for some trivial cases):
+//
+//   TestCase, UnitTest, UnitTestResultPrinter.
+//
+// Similarly, there are no separate tests for the following macros:
+//
+//   TEST, TEST_F, RUN_ALL_TESTS
+
+TEST(UnitTestTest, CanGetOriginalWorkingDir) {
+  ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL);
+  EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), "");
+}
+
+// This group of tests is for predicate assertions (ASSERT_PRED*, etc)
+// of various arities.  They do not attempt to be exhaustive.  Rather,
+// view them as smoke tests that can be easily reviewed and verified.
+// A more complete set of tests for predicate assertions can be found
+// in gtest_pred_impl_unittest.cc.
+
+// First, some predicates and predicate-formatters needed by the tests.
+
+// Returns true iff the argument is an even number.
+bool IsEven(int n) {
+  return (n % 2) == 0;
+}
+
+// A functor that returns true iff the argument is an even number.
+struct IsEvenFunctor {
+  bool operator()(int n) { return IsEven(n); }
+};
+
+// A predicate-formatter function that asserts the argument is an even
+// number.
+AssertionResult AssertIsEven(const char* expr, int n) {
+  if (IsEven(n)) {
+    return AssertionSuccess();
+  }
+
+  Message msg;
+  msg << expr << " evaluates to " << n << ", which is not even.";
+  return AssertionFailure(msg);
+}
+
+// A predicate-formatter functor that asserts the argument is an even
+// number.
+struct AssertIsEvenFunctor {
+  AssertionResult operator()(const char* expr, int n) {
+    return AssertIsEven(expr, n);
+  }
+};
+
+// Returns true iff the sum of the arguments is an even number.
+bool SumIsEven2(int n1, int n2) {
+  return IsEven(n1 + n2);
+}
+
+// A functor that returns true iff the sum of the arguments is an even
+// number.
+struct SumIsEven3Functor {
+  bool operator()(int n1, int n2, int n3) {
+    return IsEven(n1 + n2 + n3);
+  }
+};
+
+// A predicate-formatter function that asserts the sum of the
+// arguments is an even number.
+AssertionResult AssertSumIsEven4(
+    const char* e1, const char* e2, const char* e3, const char* e4,
+    int n1, int n2, int n3, int n4) {
+  const int sum = n1 + n2 + n3 + n4;
+  if (IsEven(sum)) {
+    return AssertionSuccess();
+  }
+
+  Message msg;
+  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4
+      << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4
+      << ") evaluates to " << sum << ", which is not even.";
+  return AssertionFailure(msg);
+}
+
+// A predicate-formatter functor that asserts the sum of the arguments
+// is an even number.
+struct AssertSumIsEven5Functor {
+  AssertionResult operator()(
+      const char* e1, const char* e2, const char* e3, const char* e4,
+      const char* e5, int n1, int n2, int n3, int n4, int n5) {
+    const int sum = n1 + n2 + n3 + n4 + n5;
+    if (IsEven(sum)) {
+      return AssertionSuccess();
+    }
+
+    Message msg;
+    msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
+        << " ("
+        << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5
+        << ") evaluates to " << sum << ", which is not even.";
+    return AssertionFailure(msg);
+  }
+};
+
+
+// Tests unary predicate assertions.
+
+// Tests unary predicate assertions that don't use a custom formatter.
+TEST(Pred1Test, WithoutFormat) {
+  // Success cases.
+  EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!";
+  ASSERT_PRED1(IsEven, 4);
+
+  // Failure cases.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
+  }, "This failure is expected.");
+  EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5),
+                       "evaluates to false");
+}
+
+// Tests unary predicate assertions that use a custom formatter.
+TEST(Pred1Test, WithFormat) {
+  // Success cases.
+  EXPECT_PRED_FORMAT1(AssertIsEven, 2);
+  ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4)
+    << "This failure is UNEXPECTED!";
+
+  // Failure cases.
+  const int n = 5;
+  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n),
+                          "n evaluates to 5, which is not even.");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
+  }, "This failure is expected.");
+}
+
+// Tests that unary predicate assertions evaluates their arguments
+// exactly once.
+TEST(Pred1Test, SingleEvaluationOnFailure) {
+  // A success case.
+  static int n = 0;
+  EXPECT_PRED1(IsEven, n++);
+  EXPECT_EQ(1, n) << "The argument is not evaluated exactly once.";
+
+  // A failure case.
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
+        << "This failure is expected.";
+  }, "This failure is expected.");
+  EXPECT_EQ(2, n) << "The argument is not evaluated exactly once.";
+}
+
+
+// Tests predicate assertions whose arity is >= 2.
+
+// Tests predicate assertions that don't use a custom formatter.
+TEST(PredTest, WithoutFormat) {
+  // Success cases.
+  ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!";
+  EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8);
+
+  // Failure cases.
+  const int n1 = 1;
+  const int n2 = 2;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
+  }, "This failure is expected.");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
+  }, "evaluates to false");
+}
+
+// Tests predicate assertions that use a custom formatter.
+TEST(PredTest, WithFormat) {
+  // Success cases.
+  ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) <<
+    "This failure is UNEXPECTED!";
+  EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10);
+
+  // Failure cases.
+  const int n1 = 1;
+  const int n2 = 2;
+  const int n3 = 4;
+  const int n4 = 6;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
+  }, "evaluates to 13, which is not even.");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
+        << "This failure is expected.";
+  }, "This failure is expected.");
+}
+
+// Tests that predicate assertions evaluates their arguments
+// exactly once.
+TEST(PredTest, SingleEvaluationOnFailure) {
+  // A success case.
+  int n1 = 0;
+  int n2 = 0;
+  EXPECT_PRED2(SumIsEven2, n1++, n2++);
+  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
+  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
+
+  // Another success case.
+  n1 = n2 = 0;
+  int n3 = 0;
+  int n4 = 0;
+  int n5 = 0;
+  ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(),
+                      n1++, n2++, n3++, n4++, n5++)
+                        << "This failure is UNEXPECTED!";
+  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
+  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
+  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
+  EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
+  EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once.";
+
+  // A failure case.
+  n1 = n2 = n3 = 0;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
+        << "This failure is expected.";
+  }, "This failure is expected.");
+  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
+  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
+  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
+
+  // Another failure case.
+  n1 = n2 = n3 = n4 = 0;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
+  }, "evaluates to 1, which is not even.");
+  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
+  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
+  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
+  EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
+}
+
+
+// Some helper functions for testing using overloaded/template
+// functions with ASSERT_PREDn and EXPECT_PREDn.
+
+bool IsPositive(int n) {
+  return n > 0;
+}
+
+bool IsPositive(double x) {
+  return x > 0;
+}
+
+template <typename T>
+bool IsNegative(T x) {
+  return x < 0;
+}
+
+template <typename T1, typename T2>
+bool GreaterThan(T1 x1, T2 x2) {
+  return x1 > x2;
+}
+
+// Tests that overloaded functions can be used in *_PRED* as long as
+// their types are explicitly specified.
+TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {
+  // C++Builder requires C-style casts rather than static_cast.
+  EXPECT_PRED1((bool (*)(int))(IsPositive), 5);  // NOLINT
+  ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0);  // NOLINT
+}
+
+// Tests that template functions can be used in *_PRED* as long as
+// their types are explicitly specified.
+TEST(PredicateAssertionTest, AcceptsTemplateFunction) {
+  EXPECT_PRED1(IsNegative<int>, -5);
+  // Makes sure that we can handle templates with more than one
+  // parameter.
+  ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
+}
+
+
+// Some helper functions for testing using overloaded/template
+// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn.
+
+AssertionResult IsPositiveFormat(const char* /* expr */, int n) {
+  return n > 0 ? AssertionSuccess() :
+      AssertionFailure(Message() << "Failure");
+}
+
+AssertionResult IsPositiveFormat(const char* /* expr */, double x) {
+  return x > 0 ? AssertionSuccess() :
+      AssertionFailure(Message() << "Failure");
+}
+
+template <typename T>
+AssertionResult IsNegativeFormat(const char* /* expr */, T x) {
+  return x < 0 ? AssertionSuccess() :
+      AssertionFailure(Message() << "Failure");
+}
+
+template <typename T1, typename T2>
+AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */,
+                             const T1& x1, const T2& x2) {
+  return x1 == x2 ? AssertionSuccess() :
+      AssertionFailure(Message() << "Failure");
+}
+
+// Tests that overloaded functions can be used in *_PRED_FORMAT*
+// without explicitly specifying their types.
+TEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) {
+  EXPECT_PRED_FORMAT1(IsPositiveFormat, 5);
+  ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0);
+}
+
+// Tests that template functions can be used in *_PRED_FORMAT* without
+// explicitly specifying their types.
+TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {
+  EXPECT_PRED_FORMAT1(IsNegativeFormat, -5);
+  ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3);
+}
+
+
+// Tests string assertions.
+
+// Tests ASSERT_STREQ with non-NULL arguments.
+TEST(StringAssertionTest, ASSERT_STREQ) {
+  const char * const p1 = "good";
+  ASSERT_STREQ(p1, p1);
+
+  // Let p2 have the same content as p1, but be at a different address.
+  const char p2[] = "good";
+  ASSERT_STREQ(p1, p2);
+
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
+                       "Expected: \"bad\"");
+}
+
+// Tests ASSERT_STREQ with NULL arguments.
+TEST(StringAssertionTest, ASSERT_STREQ_Null) {
+  ASSERT_STREQ(static_cast<const char *>(NULL), NULL);
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"),
+                       "non-null");
+}
+
+// Tests ASSERT_STREQ with NULL arguments.
+TEST(StringAssertionTest, ASSERT_STREQ_Null2) {
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL),
+                       "non-null");
+}
+
+// Tests ASSERT_STRNE.
+TEST(StringAssertionTest, ASSERT_STRNE) {
+  ASSERT_STRNE("hi", "Hi");
+  ASSERT_STRNE("Hi", NULL);
+  ASSERT_STRNE(NULL, "Hi");
+  ASSERT_STRNE("", NULL);
+  ASSERT_STRNE(NULL, "");
+  ASSERT_STRNE("", "Hi");
+  ASSERT_STRNE("Hi", "");
+  EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"),
+                       "\"Hi\" vs \"Hi\"");
+}
+
+// Tests ASSERT_STRCASEEQ.
+TEST(StringAssertionTest, ASSERT_STRCASEEQ) {
+  ASSERT_STRCASEEQ("hi", "Hi");
+  ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL);
+
+  ASSERT_STRCASEEQ("", "");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"),
+                       "(ignoring case)");
+}
+
+// Tests ASSERT_STRCASENE.
+TEST(StringAssertionTest, ASSERT_STRCASENE) {
+  ASSERT_STRCASENE("hi1", "Hi2");
+  ASSERT_STRCASENE("Hi", NULL);
+  ASSERT_STRCASENE(NULL, "Hi");
+  ASSERT_STRCASENE("", NULL);
+  ASSERT_STRCASENE(NULL, "");
+  ASSERT_STRCASENE("", "Hi");
+  ASSERT_STRCASENE("Hi", "");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"),
+                       "(ignoring case)");
+}
+
+// Tests *_STREQ on wide strings.
+TEST(StringAssertionTest, STREQ_Wide) {
+  // NULL strings.
+  ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL);
+
+  // Empty strings.
+  ASSERT_STREQ(L"", L"");
+
+  // Non-null vs NULL.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL),
+                          "non-null");
+
+  // Equal strings.
+  EXPECT_STREQ(L"Hi", L"Hi");
+
+  // Unequal strings.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"),
+                          "Abc");
+
+  // Strings containing wide characters.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"),
+                          "abc");
+}
+
+// Tests *_STRNE on wide strings.
+TEST(StringAssertionTest, STRNE_Wide) {
+  // NULL strings.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL);
+  }, "");
+
+  // Empty strings.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""),
+                          "L\"\"");
+
+  // Non-null vs NULL.
+  ASSERT_STRNE(L"non-null", NULL);
+
+  // Equal strings.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"),
+                          "L\"Hi\"");
+
+  // Unequal strings.
+  EXPECT_STRNE(L"abc", L"Abc");
+
+  // Strings containing wide characters.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"),
+                          "abc");
+}
+
+// Tests for ::testing::IsSubstring().
+
+// Tests that IsSubstring() returns the correct result when the input
+// argument type is const char*.
+TEST(IsSubstringTest, ReturnsCorrectResultForCString) {
+  EXPECT_FALSE(IsSubstring("", "", NULL, "a"));
+  EXPECT_FALSE(IsSubstring("", "", "b", NULL));
+  EXPECT_FALSE(IsSubstring("", "", "needle", "haystack"));
+
+  EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL));
+  EXPECT_TRUE(IsSubstring("", "", "needle", "two needles"));
+}
+
+// Tests that IsSubstring() returns the correct result when the input
+// argument type is const wchar_t*.
+TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {
+  EXPECT_FALSE(IsSubstring("", "", kNull, L"a"));
+  EXPECT_FALSE(IsSubstring("", "", L"b", kNull));
+  EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack"));
+
+  EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL));
+  EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles"));
+}
+
+// Tests that IsSubstring() generates the correct message when the input
+// argument type is const char*.
+TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {
+  EXPECT_STREQ("Value of: needle_expr\n"
+               "  Actual: \"needle\"\n"
+               "Expected: a substring of haystack_expr\n"
+               "Which is: \"haystack\"",
+               IsSubstring("needle_expr", "haystack_expr",
+                           "needle", "haystack").failure_message());
+}
+
+#if GTEST_HAS_STD_STRING
+
+// Tests that IsSubstring returns the correct result when the input
+// argument type is ::std::string.
+TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) {
+  EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob"));
+  EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world")));
+}
+
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_STD_WSTRING
+// Tests that IsSubstring returns the correct result when the input
+// argument type is ::std::wstring.
+TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {
+  EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
+  EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack")));
+}
+
+// Tests that IsSubstring() generates the correct message when the input
+// argument type is ::std::wstring.
+TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {
+  EXPECT_STREQ("Value of: needle_expr\n"
+               "  Actual: L\"needle\"\n"
+               "Expected: a substring of haystack_expr\n"
+               "Which is: L\"haystack\"",
+               IsSubstring(
+                   "needle_expr", "haystack_expr",
+                   ::std::wstring(L"needle"), L"haystack").failure_message());
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Tests for ::testing::IsNotSubstring().
+
+// Tests that IsNotSubstring() returns the correct result when the input
+// argument type is const char*.
+TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) {
+  EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack"));
+  EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles"));
+}
+
+// Tests that IsNotSubstring() returns the correct result when the input
+// argument type is const wchar_t*.
+TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {
+  EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack"));
+  EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles"));
+}
+
+// Tests that IsNotSubstring() generates the correct message when the input
+// argument type is const wchar_t*.
+TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {
+  EXPECT_STREQ("Value of: needle_expr\n"
+               "  Actual: L\"needle\"\n"
+               "Expected: not a substring of haystack_expr\n"
+               "Which is: L\"two needles\"",
+               IsNotSubstring(
+                   "needle_expr", "haystack_expr",
+                   L"needle", L"two needles").failure_message());
+}
+
+#if GTEST_HAS_STD_STRING
+
+// Tests that IsNotSubstring returns the correct result when the input
+// argument type is ::std::string.
+TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {
+  EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob"));
+  EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world")));
+}
+
+// Tests that IsNotSubstring() generates the correct message when the input
+// argument type is ::std::string.
+TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {
+  EXPECT_STREQ("Value of: needle_expr\n"
+               "  Actual: \"needle\"\n"
+               "Expected: not a substring of haystack_expr\n"
+               "Which is: \"two needles\"",
+               IsNotSubstring(
+                   "needle_expr", "haystack_expr",
+                   ::std::string("needle"), "two needles").failure_message());
+}
+
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_STD_WSTRING
+
+// Tests that IsNotSubstring returns the correct result when the input
+// argument type is ::std::wstring.
+TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) {
+  EXPECT_FALSE(
+      IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
+  EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack")));
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Tests floating-point assertions.
+
+template <typename RawType>
+class FloatingPointTest : public Test {
+ protected:
+
+  // Pre-calculated numbers to be used by the tests.
+  struct TestValues {
+    RawType close_to_positive_zero;
+    RawType close_to_negative_zero;
+    RawType further_from_negative_zero;
+
+    RawType close_to_one;
+    RawType further_from_one;
+
+    RawType infinity;
+    RawType close_to_infinity;
+    RawType further_from_infinity;
+
+    RawType nan1;
+    RawType nan2;
+  };
+
+  typedef typename testing::internal::FloatingPoint<RawType> Floating;
+  typedef typename Floating::Bits Bits;
+
+  virtual void SetUp() {
+    const size_t max_ulps = Floating::kMaxUlps;
+
+    // The bits that represent 0.0.
+    const Bits zero_bits = Floating(0).bits();
+
+    // Makes some numbers close to 0.0.
+    values_.close_to_positive_zero = Floating::ReinterpretBits(
+        zero_bits + max_ulps/2);
+    values_.close_to_negative_zero = -Floating::ReinterpretBits(
+        zero_bits + max_ulps - max_ulps/2);
+    values_.further_from_negative_zero = -Floating::ReinterpretBits(
+        zero_bits + max_ulps + 1 - max_ulps/2);
+
+    // The bits that represent 1.0.
+    const Bits one_bits = Floating(1).bits();
+
+    // Makes some numbers close to 1.0.
+    values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps);
+    values_.further_from_one = Floating::ReinterpretBits(
+        one_bits + max_ulps + 1);
+
+    // +infinity.
+    values_.infinity = Floating::Infinity();
+
+    // The bits that represent +infinity.
+    const Bits infinity_bits = Floating(values_.infinity).bits();
+
+    // Makes some numbers close to infinity.
+    values_.close_to_infinity = Floating::ReinterpretBits(
+        infinity_bits - max_ulps);
+    values_.further_from_infinity = Floating::ReinterpretBits(
+        infinity_bits - max_ulps - 1);
+
+    // Makes some NAN's.  Sets the most significant bit of the fraction so that
+    // our NaN's are quiet; trying to process a signaling NaN would raise an
+    // exception if our environment enables floating point exceptions.
+    values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask
+        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
+    values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask
+        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
+  }
+
+  void TestSize() {
+    EXPECT_EQ(sizeof(RawType), sizeof(Bits));
+  }
+
+  static TestValues values_;
+};
+
+template <typename RawType>
+typename FloatingPointTest<RawType>::TestValues
+    FloatingPointTest<RawType>::values_;
+
+// Instantiates FloatingPointTest for testing *_FLOAT_EQ.
+typedef FloatingPointTest<float> FloatTest;
+
+// Tests that the size of Float::Bits matches the size of float.
+TEST_F(FloatTest, Size) {
+  TestSize();
+}
+
+// Tests comparing with +0 and -0.
+TEST_F(FloatTest, Zeros) {
+  EXPECT_FLOAT_EQ(0.0, -0.0);
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0),
+                          "1.0");
+  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5),
+                       "1.5");
+}
+
+// Tests comparing numbers close to 0.
+//
+// This ensures that *_FLOAT_EQ handles the sign correctly and no
+// overflow occurs when comparing numbers whose absolute value is very
+// small.
+TEST_F(FloatTest, AlmostZeros) {
+  // In C++Builder, names within local classes (such as used by
+  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
+  // scoping class.  Use a static local alias as a workaround.
+  static const FloatTest::TestValues& v(this->values_);
+
+  EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero);
+  EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero);
+  EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
+
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_FLOAT_EQ(v.close_to_positive_zero,
+                    v.further_from_negative_zero);
+  }, "v.further_from_negative_zero");
+}
+
+// Tests comparing numbers close to each other.
+TEST_F(FloatTest, SmallDiff) {
+  EXPECT_FLOAT_EQ(1.0, values_.close_to_one);
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one),
+                          "values_.further_from_one");
+}
+
+// Tests comparing numbers far apart.
+TEST_F(FloatTest, LargeDiff) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0),
+                          "3.0");
+}
+
+// Tests comparing with infinity.
+//
+// This ensures that no overflow occurs when comparing numbers whose
+// absolute value is very large.
+TEST_F(FloatTest, Infinity) {
+  EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity);
+  EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity);
+#if !GTEST_OS_SYMBIAN
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity),
+                          "-values_.infinity");
+
+  // This is interesting as the representations of infinity and nan1
+  // are only 1 DLP apart.
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1),
+                          "values_.nan1");
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that comparing with NAN always returns false.
+TEST_F(FloatTest, NaN) {
+#if !GTEST_OS_SYMBIAN
+// Nokia's STLport crashes if we try to output infinity or NaN.
+
+  // In C++Builder, names within local classes (such as used by
+  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
+  // scoping class.  Use a static local alias as a workaround.
+  static const FloatTest::TestValues& v(this->values_);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1),
+                          "v.nan1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2),
+                          "v.nan2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1),
+                          "v.nan1");
+
+  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity),
+                       "v.infinity");
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that *_FLOAT_EQ are reflexive.
+TEST_F(FloatTest, Reflexive) {
+  EXPECT_FLOAT_EQ(0.0, 0.0);
+  EXPECT_FLOAT_EQ(1.0, 1.0);
+  ASSERT_FLOAT_EQ(values_.infinity, values_.infinity);
+}
+
+// Tests that *_FLOAT_EQ are commutative.
+TEST_F(FloatTest, Commutative) {
+  // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one).
+  EXPECT_FLOAT_EQ(values_.close_to_one, 1.0);
+
+  // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one).
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0),
+                          "1.0");
+}
+
+// Tests EXPECT_NEAR.
+TEST_F(FloatTest, EXPECT_NEAR) {
+  EXPECT_NEAR(-1.0f, -1.1f, 0.2f);
+  EXPECT_NEAR(2.0f, 3.0f, 1.0f);
+  EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.2f, 0.1f),  // NOLINT
+                          "The difference between 1.0f and 1.2f is 0.2, "
+                          "which exceeds 0.1f");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous line.
+}
+
+// Tests ASSERT_NEAR.
+TEST_F(FloatTest, ASSERT_NEAR) {
+  ASSERT_NEAR(-1.0f, -1.1f, 0.2f);
+  ASSERT_NEAR(2.0f, 3.0f, 1.0f);
+  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.2f, 0.1f),  // NOLINT
+                       "The difference between 1.0f and 1.2f is 0.2, "
+                       "which exceeds 0.1f");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous line.
+}
+
+// Tests the cases where FloatLE() should succeed.
+TEST_F(FloatTest, FloatLESucceeds) {
+  EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f);  // When val1 < val2,
+  ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f);  // val1 == val2,
+
+  // or when val1 is greater than, but almost equals to, val2.
+  EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f);
+}
+
+// Tests the cases where FloatLE() should fail.
+TEST_F(FloatTest, FloatLEFails) {
+  // When val1 is greater than val2 by a large margin,
+  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f),
+                          "(2.0f) <= (1.0f)");
+
+  // or by a small yet non-negligible margin,
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
+  }, "(values_.further_from_one) <= (1.0f)");
+
+#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  // C++Builder gives bad results for ordered comparisons involving NaNs
+  // due to compiler bugs.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
+  }, "(values_.nan1) <= (values_.infinity)");
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
+  }, "(-values_.infinity) <= (values_.nan1)");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
+  }, "(values_.nan1) <= (values_.nan1)");
+#endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
+}
+
+// Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
+typedef FloatingPointTest<double> DoubleTest;
+
+// Tests that the size of Double::Bits matches the size of double.
+TEST_F(DoubleTest, Size) {
+  TestSize();
+}
+
+// Tests comparing with +0 and -0.
+TEST_F(DoubleTest, Zeros) {
+  EXPECT_DOUBLE_EQ(0.0, -0.0);
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0),
+                          "1.0");
+  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0),
+                       "1.0");
+}
+
+// Tests comparing numbers close to 0.
+//
+// This ensures that *_DOUBLE_EQ handles the sign correctly and no
+// overflow occurs when comparing numbers whose absolute value is very
+// small.
+TEST_F(DoubleTest, AlmostZeros) {
+  // In C++Builder, names within local classes (such as used by
+  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
+  // scoping class.  Use a static local alias as a workaround.
+  static const DoubleTest::TestValues& v(this->values_);
+
+  EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero);
+  EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero);
+  EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
+
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
+                     v.further_from_negative_zero);
+  }, "v.further_from_negative_zero");
+}
+
+// Tests comparing numbers close to each other.
+TEST_F(DoubleTest, SmallDiff) {
+  EXPECT_DOUBLE_EQ(1.0, values_.close_to_one);
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one),
+                          "values_.further_from_one");
+}
+
+// Tests comparing numbers far apart.
+TEST_F(DoubleTest, LargeDiff) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0),
+                          "3.0");
+}
+
+// Tests comparing with infinity.
+//
+// This ensures that no overflow occurs when comparing numbers whose
+// absolute value is very large.
+TEST_F(DoubleTest, Infinity) {
+  EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity);
+  EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity);
+#if !GTEST_OS_SYMBIAN
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity),
+                          "-values_.infinity");
+
+  // This is interesting as the representations of infinity_ and nan1_
+  // are only 1 DLP apart.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1),
+                          "values_.nan1");
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that comparing with NAN always returns false.
+TEST_F(DoubleTest, NaN) {
+#if !GTEST_OS_SYMBIAN
+  // In C++Builder, names within local classes (such as used by
+  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
+  // scoping class.  Use a static local alias as a workaround.
+  static const DoubleTest::TestValues& v(this->values_);
+
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1),
+                          "v.nan1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");
+  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity),
+                       "v.infinity");
+#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);
+#if !GTEST_OS_SYMBIAN
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity);
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that *_DOUBLE_EQ are commutative.
+TEST_F(DoubleTest, Commutative) {
+  // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one).
+  EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0);
+
+  // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one).
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0),
+                          "1.0");
+}
+
+// Tests EXPECT_NEAR.
+TEST_F(DoubleTest, EXPECT_NEAR) {
+  EXPECT_NEAR(-1.0, -1.1, 0.2);
+  EXPECT_NEAR(2.0, 3.0, 1.0);
+  EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.2, 0.1),  // NOLINT
+                          "The difference between 1.0 and 1.2 is 0.2, "
+                          "which exceeds 0.1");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous statement.
+}
+
+// Tests ASSERT_NEAR.
+TEST_F(DoubleTest, ASSERT_NEAR) {
+  ASSERT_NEAR(-1.0, -1.1, 0.2);
+  ASSERT_NEAR(2.0, 3.0, 1.0);
+  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.2, 0.1),  // NOLINT
+                       "The difference between 1.0 and 1.2 is 0.2, "
+                       "which exceeds 0.1");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous statement.
+}
+
+// Tests the cases where DoubleLE() should succeed.
+TEST_F(DoubleTest, DoubleLESucceeds) {
+  EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0);  // When val1 < val2,
+  ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0);  // val1 == val2,
+
+  // or when val1 is greater than, but almost equals to, val2.
+  EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0);
+}
+
+// Tests the cases where DoubleLE() should fail.
+TEST_F(DoubleTest, DoubleLEFails) {
+  // When val1 is greater than val2 by a large margin,
+  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0),
+                          "(2.0) <= (1.0)");
+
+  // or by a small yet non-negligible margin,
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
+  }, "(values_.further_from_one) <= (1.0)");
+
+#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  // C++Builder gives bad results for ordered comparisons involving NaNs
+  // due to compiler bugs.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
+  }, "(values_.nan1) <= (values_.infinity)");
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
+  }, " (-values_.infinity) <= (values_.nan1)");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
+  }, "(values_.nan1) <= (values_.nan1)");
+#endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
+}
+
+
+// Verifies that a test or test case whose name starts with DISABLED_ is
+// not run.
+
+// A test whose name starts with DISABLED_.
+// Should not run.
+TEST(DisabledTest, DISABLED_TestShouldNotRun) {
+  FAIL() << "Unexpected failure: Disabled test should not be run.";
+}
+
+// A test whose name does not start with DISABLED_.
+// Should run.
+TEST(DisabledTest, NotDISABLED_TestShouldRun) {
+  EXPECT_EQ(1, 1);
+}
+
+// A test case whose name starts with DISABLED_.
+// Should not run.
+TEST(DISABLED_TestCase, TestShouldNotRun) {
+  FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
+}
+
+// A test case and test whose names start with DISABLED_.
+// Should not run.
+TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) {
+  FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
+}
+
+// Check that when all tests in a test case are disabled, SetupTestCase() and
+// TearDownTestCase() are not called.
+class DisabledTestsTest : public Test {
+ protected:
+  static void SetUpTestCase() {
+    FAIL() << "Unexpected failure: All tests disabled in test case. "
+              "SetupTestCase() should not be called.";
+  }
+
+  static void TearDownTestCase() {
+    FAIL() << "Unexpected failure: All tests disabled in test case. "
+              "TearDownTestCase() should not be called.";
+  }
+};
+
+TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) {
+  FAIL() << "Unexpected failure: Disabled test should not be run.";
+}
+
+TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
+  FAIL() << "Unexpected failure: Disabled test should not be run.";
+}
+
+// Tests that disabled typed tests aren't run.
+
+#if GTEST_HAS_TYPED_TEST
+
+template <typename T>
+class TypedTest : public Test {
+};
+
+typedef testing::Types<int, double> NumericTypes;
+TYPED_TEST_CASE(TypedTest, NumericTypes);
+
+TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {
+  FAIL() << "Unexpected failure: Disabled typed test should not run.";
+}
+
+template <typename T>
+class DISABLED_TypedTest : public Test {
+};
+
+TYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes);
+
+TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
+  FAIL() << "Unexpected failure: Disabled typed test should not run.";
+}
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+// Tests that disabled type-parameterized tests aren't run.
+
+#if GTEST_HAS_TYPED_TEST_P
+
+template <typename T>
+class TypedTestP : public Test {
+};
+
+TYPED_TEST_CASE_P(TypedTestP);
+
+TYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) {
+  FAIL() << "Unexpected failure: "
+         << "Disabled type-parameterized test should not run.";
+}
+
+REGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes);
+
+template <typename T>
+class DISABLED_TypedTestP : public Test {
+};
+
+TYPED_TEST_CASE_P(DISABLED_TypedTestP);
+
+TYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) {
+  FAIL() << "Unexpected failure: "
+         << "Disabled type-parameterized test should not run.";
+}
+
+REGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes);
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+// Tests that assertion macros evaluate their arguments exactly once.
+
+class SingleEvaluationTest : public Test {
+ public:  // Must be public and not protected due to a bug in g++ 3.4.2.
+  // This helper function is needed by the FailedASSERT_STREQ test
+  // below.  It's public to work around C++Builder's bug with scoping local
+  // classes.
+  static void CompareAndIncrementCharPtrs() {
+    ASSERT_STREQ(p1_++, p2_++);
+  }
+
+  // This helper function is needed by the FailedASSERT_NE test below.  It's
+  // public to work around C++Builder's bug with scoping local classes.
+  static void CompareAndIncrementInts() {
+    ASSERT_NE(a_++, b_++);
+  }
+
+ protected:
+  SingleEvaluationTest() {
+    p1_ = s1_;
+    p2_ = s2_;
+    a_ = 0;
+    b_ = 0;
+  }
+
+  static const char* const s1_;
+  static const char* const s2_;
+  static const char* p1_;
+  static const char* p2_;
+
+  static int a_;
+  static int b_;
+};
+
+const char* const SingleEvaluationTest::s1_ = "01234";
+const char* const SingleEvaluationTest::s2_ = "abcde";
+const char* SingleEvaluationTest::p1_;
+const char* SingleEvaluationTest::p2_;
+int SingleEvaluationTest::a_;
+int SingleEvaluationTest::b_;
+
+// Tests that when ASSERT_STREQ fails, it evaluates its arguments
+// exactly once.
+TEST_F(SingleEvaluationTest, FailedASSERT_STREQ) {
+  EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(),
+                       "p2_++");
+  EXPECT_EQ(s1_ + 1, p1_);
+  EXPECT_EQ(s2_ + 1, p2_);
+}
+
+// Tests that string assertion arguments are evaluated exactly once.
+TEST_F(SingleEvaluationTest, ASSERT_STR) {
+  // successful EXPECT_STRNE
+  EXPECT_STRNE(p1_++, p2_++);
+  EXPECT_EQ(s1_ + 1, p1_);
+  EXPECT_EQ(s2_ + 1, p2_);
+
+  // failed EXPECT_STRCASEEQ
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++),
+                          "ignoring case");
+  EXPECT_EQ(s1_ + 2, p1_);
+  EXPECT_EQ(s2_ + 2, p2_);
+}
+
+// Tests that when ASSERT_NE fails, it evaluates its arguments exactly
+// once.
+TEST_F(SingleEvaluationTest, FailedASSERT_NE) {
+  EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(),
+                       "(a_++) != (b_++)");
+  EXPECT_EQ(1, a_);
+  EXPECT_EQ(1, b_);
+}
+
+// Tests that assertion arguments are evaluated exactly once.
+TEST_F(SingleEvaluationTest, OtherCases) {
+  // successful EXPECT_TRUE
+  EXPECT_TRUE(0 == a_++);  // NOLINT
+  EXPECT_EQ(1, a_);
+
+  // failed EXPECT_TRUE
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++");
+  EXPECT_EQ(2, a_);
+
+  // successful EXPECT_GT
+  EXPECT_GT(a_++, b_++);
+  EXPECT_EQ(3, a_);
+  EXPECT_EQ(1, b_);
+
+  // failed EXPECT_LT
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)");
+  EXPECT_EQ(4, a_);
+  EXPECT_EQ(2, b_);
+
+  // successful ASSERT_TRUE
+  ASSERT_TRUE(0 < a_++);  // NOLINT
+  EXPECT_EQ(5, a_);
+
+  // successful ASSERT_GT
+  ASSERT_GT(a_++, b_++);
+  EXPECT_EQ(6, a_);
+  EXPECT_EQ(3, b_);
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+void ThrowAnInteger() {
+  throw 1;
+}
+
+// Tests that assertion arguments are evaluated exactly once.
+TEST_F(SingleEvaluationTest, ExceptionTests) {
+  // successful EXPECT_THROW
+  EXPECT_THROW({  // NOLINT
+    a_++;
+    ThrowAnInteger();
+  }, int);
+  EXPECT_EQ(1, a_);
+
+  // failed EXPECT_THROW, throws different
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT
+    a_++;
+    ThrowAnInteger();
+  }, bool), "throws a different type");
+  EXPECT_EQ(2, a_);
+
+  // failed EXPECT_THROW, throws nothing
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing");
+  EXPECT_EQ(3, a_);
+
+  // successful EXPECT_NO_THROW
+  EXPECT_NO_THROW(a_++);
+  EXPECT_EQ(4, a_);
+
+  // failed EXPECT_NO_THROW
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({  // NOLINT
+    a_++;
+    ThrowAnInteger();
+  }), "it throws");
+  EXPECT_EQ(5, a_);
+
+  // successful EXPECT_ANY_THROW
+  EXPECT_ANY_THROW({  // NOLINT
+    a_++;
+    ThrowAnInteger();
+  });
+  EXPECT_EQ(6, a_);
+
+  // failed EXPECT_ANY_THROW
+  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");
+  EXPECT_EQ(7, a_);
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE.
+class NoFatalFailureTest : public Test {
+ protected:
+  void Succeeds() {}
+  void FailsNonFatal() {
+    ADD_FAILURE() << "some non-fatal failure";
+  }
+  void Fails() {
+    FAIL() << "some fatal failure";
+  }
+
+  void DoAssertNoFatalFailureOnFails() {
+    ASSERT_NO_FATAL_FAILURE(Fails());
+    ADD_FAILURE() << "shold not reach here.";
+  }
+
+  void DoExpectNoFatalFailureOnFails() {
+    EXPECT_NO_FATAL_FAILURE(Fails());
+    ADD_FAILURE() << "other failure";
+  }
+};
+
+TEST_F(NoFatalFailureTest, NoFailure) {
+  EXPECT_NO_FATAL_FAILURE(Succeeds());
+  ASSERT_NO_FATAL_FAILURE(Succeeds());
+}
+
+TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
+      "some non-fatal failure");
+  EXPECT_NONFATAL_FAILURE(
+      ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
+      "some non-fatal failure");
+}
+
+TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {
+  TestPartResultArray gtest_failures;
+  {
+    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
+    DoAssertNoFatalFailureOnFails();
+  }
+  ASSERT_EQ(2, gtest_failures.size());
+  EXPECT_EQ(TestPartResult::kFatalFailure,
+            gtest_failures.GetTestPartResult(0).type());
+  EXPECT_EQ(TestPartResult::kFatalFailure,
+            gtest_failures.GetTestPartResult(1).type());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
+                      gtest_failures.GetTestPartResult(0).message());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
+                      gtest_failures.GetTestPartResult(1).message());
+}
+
+TEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) {
+  TestPartResultArray gtest_failures;
+  {
+    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
+    DoExpectNoFatalFailureOnFails();
+  }
+  ASSERT_EQ(3, gtest_failures.size());
+  EXPECT_EQ(TestPartResult::kFatalFailure,
+            gtest_failures.GetTestPartResult(0).type());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+            gtest_failures.GetTestPartResult(1).type());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+            gtest_failures.GetTestPartResult(2).type());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
+                      gtest_failures.GetTestPartResult(0).message());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
+                      gtest_failures.GetTestPartResult(1).message());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure",
+                      gtest_failures.GetTestPartResult(2).message());
+}
+
+TEST_F(NoFatalFailureTest, MessageIsStreamable) {
+  TestPartResultArray gtest_failures;
+  {
+    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
+    EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message";
+  }
+  ASSERT_EQ(2, gtest_failures.size());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+            gtest_failures.GetTestPartResult(0).type());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+            gtest_failures.GetTestPartResult(1).type());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo",
+                      gtest_failures.GetTestPartResult(0).message());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message",
+                      gtest_failures.GetTestPartResult(1).message());
+}
+
+// Tests non-string assertions.
+
+// Tests EqFailure(), used for implementing *EQ* assertions.
+TEST(AssertionTest, EqFailure) {
+  const String foo_val("5"), bar_val("6");
+  const String msg1(
+      EqFailure("foo", "bar", foo_val, bar_val, false)
+      .failure_message());
+  EXPECT_STREQ(
+      "Value of: bar\n"
+      "  Actual: 6\n"
+      "Expected: foo\n"
+      "Which is: 5",
+      msg1.c_str());
+
+  const String msg2(
+      EqFailure("foo", "6", foo_val, bar_val, false)
+      .failure_message());
+  EXPECT_STREQ(
+      "Value of: 6\n"
+      "Expected: foo\n"
+      "Which is: 5",
+      msg2.c_str());
+
+  const String msg3(
+      EqFailure("5", "bar", foo_val, bar_val, false)
+      .failure_message());
+  EXPECT_STREQ(
+      "Value of: bar\n"
+      "  Actual: 6\n"
+      "Expected: 5",
+      msg3.c_str());
+
+  const String msg4(
+      EqFailure("5", "6", foo_val, bar_val, false).failure_message());
+  EXPECT_STREQ(
+      "Value of: 6\n"
+      "Expected: 5",
+      msg4.c_str());
+
+  const String msg5(
+      EqFailure("foo", "bar",
+                String("\"x\""), String("\"y\""),
+                true).failure_message());
+  EXPECT_STREQ(
+      "Value of: bar\n"
+      "  Actual: \"y\"\n"
+      "Expected: foo (ignoring case)\n"
+      "Which is: \"x\"",
+      msg5.c_str());
+}
+
+// Tests AppendUserMessage(), used for implementing the *EQ* macros.
+TEST(AssertionTest, AppendUserMessage) {
+  const String foo("foo");
+
+  Message msg;
+  EXPECT_STREQ("foo",
+               AppendUserMessage(foo, msg).c_str());
+
+  msg << "bar";
+  EXPECT_STREQ("foo\nbar",
+               AppendUserMessage(foo, msg).c_str());
+}
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true", "Unreachable code"
+#pragma option push -w-ccc -w-rch
+#endif
+
+// Tests ASSERT_TRUE.
+TEST(AssertionTest, ASSERT_TRUE) {
+  ASSERT_TRUE(2 > 1);  // NOLINT
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1),
+                       "2 < 1");
+}
+
+// Tests ASSERT_FALSE.
+TEST(AssertionTest, ASSERT_FALSE) {
+  ASSERT_FALSE(2 < 1);  // NOLINT
+  EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1),
+                       "Value of: 2 > 1\n"
+                       "  Actual: true\n"
+                       "Expected: false");
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" supressed them
+#pragma option pop
+#endif
+
+// Tests using ASSERT_EQ on double values.  The purpose is to make
+// sure that the specialization we did for integer and anonymous enums
+// isn't used for double arguments.
+TEST(ExpectTest, ASSERT_EQ_Double) {
+  // A success.
+  ASSERT_EQ(5.6, 5.6);
+
+  // A failure.
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2),
+                       "5.1");
+}
+
+// Tests ASSERT_EQ.
+TEST(AssertionTest, ASSERT_EQ) {
+  ASSERT_EQ(5, 2 + 3);
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
+                       "Value of: 2*3\n"
+                       "  Actual: 6\n"
+                       "Expected: 5");
+}
+
+// Tests ASSERT_EQ(NULL, pointer).
+#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.
+TEST(AssertionTest, ASSERT_EQ_NULL) {
+  // A success.
+  const char* p = NULL;
+  // Some older GCC versions may issue a spurious waring in this or the next
+  // assertion statement. This warning should not be suppressed with
+  // static_cast since the test verifies the ability to use bare NULL as the
+  // expected parameter to the macro.
+  ASSERT_EQ(NULL, p);
+
+  // A failure.
+  static int n = 0;
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
+                       "Value of: &n\n");
+}
+#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
+// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as
+// ASSERT_EQ(static_cast<void*>(NULL), non_pointer).
+TEST(ExpectTest, ASSERT_EQ_0) {
+  int n = 0;
+
+  // A success.
+  ASSERT_EQ(0, n);
+
+  // A failure.
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
+                       "Expected: 0");
+}
+
+// Tests ASSERT_NE.
+TEST(AssertionTest, ASSERT_NE) {
+  ASSERT_NE(6, 7);
+  EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'),
+                       "Expected: ('a') != ('a'), "
+                       "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
+}
+
+// Tests ASSERT_LE.
+TEST(AssertionTest, ASSERT_LE) {
+  ASSERT_LE(2, 3);
+  ASSERT_LE(2, 2);
+  EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0),
+                       "Expected: (2) <= (0), actual: 2 vs 0");
+}
+
+// Tests ASSERT_LT.
+TEST(AssertionTest, ASSERT_LT) {
+  ASSERT_LT(2, 3);
+  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2),
+                       "Expected: (2) < (2), actual: 2 vs 2");
+}
+
+// Tests ASSERT_GE.
+TEST(AssertionTest, ASSERT_GE) {
+  ASSERT_GE(2, 1);
+  ASSERT_GE(2, 2);
+  EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3),
+                       "Expected: (2) >= (3), actual: 2 vs 3");
+}
+
+// Tests ASSERT_GT.
+TEST(AssertionTest, ASSERT_GT) {
+  ASSERT_GT(2, 1);
+  EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2),
+                       "Expected: (2) > (2), actual: 2 vs 2");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+void ThrowNothing() {}
+
+// Tests ASSERT_THROW.
+TEST(AssertionTest, ASSERT_THROW) {
+  ASSERT_THROW(ThrowAnInteger(), int);
+#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x600 || defined(_DEBUG)
+  // ICE's in C++Builder 2007 (Release build).
+  EXPECT_FATAL_FAILURE(
+      ASSERT_THROW(ThrowAnInteger(), bool),
+      "Expected: ThrowAnInteger() throws an exception of type bool.\n"
+      "  Actual: it throws a different type.");
+#endif
+  EXPECT_FATAL_FAILURE(
+      ASSERT_THROW(ThrowNothing(), bool),
+      "Expected: ThrowNothing() throws an exception of type bool.\n"
+      "  Actual: it throws nothing.");
+}
+
+// Tests ASSERT_NO_THROW.
+TEST(AssertionTest, ASSERT_NO_THROW) {
+  ASSERT_NO_THROW(ThrowNothing());
+  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),
+                       "Expected: ThrowAnInteger() doesn't throw an exception."
+                       "\n  Actual: it throws.");
+}
+
+// Tests ASSERT_ANY_THROW.
+TEST(AssertionTest, ASSERT_ANY_THROW) {
+  ASSERT_ANY_THROW(ThrowAnInteger());
+  EXPECT_FATAL_FAILURE(
+      ASSERT_ANY_THROW(ThrowNothing()),
+      "Expected: ThrowNothing() throws an exception.\n"
+      "  Actual: it doesn't.");
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Makes sure we deal with the precedence of <<.  This test should
+// compile.
+TEST(AssertionTest, AssertPrecedence) {
+  ASSERT_EQ(1 < 2, true);
+  ASSERT_EQ(true && false, false);
+}
+
+// A subroutine used by the following test.
+void TestEq1(int x) {
+  ASSERT_EQ(1, x);
+}
+
+// Tests calling a test subroutine that's not part of a fixture.
+TEST(AssertionTest, NonFixtureSubroutine) {
+  EXPECT_FATAL_FAILURE(TestEq1(2),
+                       "Value of: x");
+}
+
+// An uncopyable class.
+class Uncopyable {
+ public:
+  explicit Uncopyable(int value) : value_(value) {}
+
+  int value() const { return value_; }
+  bool operator==(const Uncopyable& rhs) const {
+    return value() == rhs.value();
+  }
+ private:
+  // This constructor deliberately has no implementation, as we don't
+  // want this class to be copyable.
+  Uncopyable(const Uncopyable&);  // NOLINT
+
+  int value_;
+};
+
+::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) {
+  return os << value.value();
+}
+
+
+bool IsPositiveUncopyable(const Uncopyable& x) {
+  return x.value() > 0;
+}
+
+// A subroutine used by the following test.
+void TestAssertNonPositive() {
+  Uncopyable y(-1);
+  ASSERT_PRED1(IsPositiveUncopyable, y);
+}
+// A subroutine used by the following test.
+void TestAssertEqualsUncopyable() {
+  Uncopyable x(5);
+  Uncopyable y(-1);
+  ASSERT_EQ(x, y);
+}
+
+// Tests that uncopyable objects can be used in assertions.
+TEST(AssertionTest, AssertWorksWithUncopyableObject) {
+  Uncopyable x(5);
+  ASSERT_PRED1(IsPositiveUncopyable, x);
+  ASSERT_EQ(x, x);
+  EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
+    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
+  EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
+    "Value of: y\n  Actual: -1\nExpected: x\nWhich is: 5");
+}
+
+// Tests that uncopyable objects can be used in expects.
+TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
+  Uncopyable x(5);
+  EXPECT_PRED1(IsPositiveUncopyable, x);
+  Uncopyable y(-1);
+  EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y),
+    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
+  EXPECT_EQ(x, x);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
+    "Value of: y\n  Actual: -1\nExpected: x\nWhich is: 5");
+}
+
+
+// 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 not
+// done on Mac.
+#if !GTEST_OS_MAC
+
+// Tests using assertions with anonymous enums.
+enum {
+  CASE_A = -1,
+#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
+  // (incorrectly) doesn't allow an enum value to exceed the range of
+  // an int, so this has to be conditionally compiled.
+  //
+  // On Linux, CASE_B and CASE_A have the same value when truncated to
+  // int size.  We want to test whether this will confuse the
+  // assertions.
+  CASE_B = testing::internal::kMaxBiggestInt,
+#else
+  CASE_B = INT_MAX,
+#endif  // GTEST_OS_LINUX
+};
+
+TEST(AssertionTest, AnonymousEnum) {
+#if GTEST_OS_LINUX
+  EXPECT_EQ(static_cast<int>(CASE_A), static_cast<int>(CASE_B));
+#endif  // GTEST_OS_LINUX
+
+  EXPECT_EQ(CASE_A, CASE_A);
+  EXPECT_NE(CASE_A, CASE_B);
+  EXPECT_LT(CASE_A, CASE_B);
+  EXPECT_LE(CASE_A, CASE_B);
+  EXPECT_GT(CASE_B, CASE_A);
+  EXPECT_GE(CASE_A, CASE_A);
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(CASE_A, CASE_B),
+                          "(CASE_A) >= (CASE_B)");
+
+  ASSERT_EQ(CASE_A, CASE_A);
+  ASSERT_NE(CASE_A, CASE_B);
+  ASSERT_LT(CASE_A, CASE_B);
+  ASSERT_LE(CASE_A, CASE_B);
+  ASSERT_GT(CASE_B, CASE_A);
+  ASSERT_GE(CASE_A, CASE_A);
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(CASE_A, CASE_B),
+                       "Value of: CASE_B");
+}
+
+#endif  // !GTEST_OS_MAC
+
+#if GTEST_OS_WINDOWS
+
+static HRESULT UnexpectedHRESULTFailure() {
+  return E_UNEXPECTED;
+}
+
+static HRESULT OkHRESULTSuccess() {
+  return S_OK;
+}
+
+static HRESULT FalseHRESULTSuccess() {
+  return S_FALSE;
+}
+
+// HRESULT assertion tests test both zero and non-zero
+// success codes as well as failure message for each.
+//
+// Windows CE doesn't support message texts.
+TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {
+  EXPECT_HRESULT_SUCCEEDED(S_OK);
+  EXPECT_HRESULT_SUCCEEDED(S_FALSE);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
+    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
+    "  Actual: 0x8000FFFF");
+}
+
+TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
+  ASSERT_HRESULT_SUCCEEDED(S_OK);
+  ASSERT_HRESULT_SUCCEEDED(S_FALSE);
+
+  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
+    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
+    "  Actual: 0x8000FFFF");
+}
+
+TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {
+  EXPECT_HRESULT_FAILED(E_UNEXPECTED);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()),
+    "Expected: (OkHRESULTSuccess()) fails.\n"
+    "  Actual: 0x00000000");
+  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()),
+    "Expected: (FalseHRESULTSuccess()) fails.\n"
+    "  Actual: 0x00000001");
+}
+
+TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {
+  ASSERT_HRESULT_FAILED(E_UNEXPECTED);
+
+#ifndef __BORLANDC__
+  // ICE's in C++Builder 2007 and 2009.
+  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()),
+    "Expected: (OkHRESULTSuccess()) fails.\n"
+    "  Actual: 0x00000000");
+#endif
+  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()),
+    "Expected: (FalseHRESULTSuccess()) fails.\n"
+    "  Actual: 0x00000001");
+}
+
+// Tests that streaming to the HRESULT macros works.
+TEST(HRESULTAssertionTest, Streaming) {
+  EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
+  ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
+  EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
+  ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
+
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
+      "expected failure");
+
+#ifndef __BORLANDC__
+  // ICE's in C++Builder 2007 and 2009.
+  EXPECT_FATAL_FAILURE(
+      ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
+      "expected failure");
+#endif
+
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
+      "expected failure");
+
+  EXPECT_FATAL_FAILURE(
+      ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
+      "expected failure");
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true", "Unreachable code"
+#pragma option push -w-ccc -w-rch
+#endif
+
+// Tests that the assertion macros behave like single statements.
+TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
+  if (AlwaysFalse())
+    ASSERT_TRUE(false) << "This should never be executed; "
+                          "It's a compilation test only.";
+
+  if (AlwaysTrue())
+    EXPECT_FALSE(false);
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ASSERT_LT(1, 3);
+
+  if (AlwaysFalse())
+    ;  // NOLINT
+  else
+    EXPECT_GT(3, 2) << "";
+}
+
+#if GTEST_HAS_EXCEPTIONS
+// Tests that the compiler will not complain about unreachable code in the
+// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros.
+TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
+  int n = 0;
+
+  EXPECT_THROW(throw 1, int);
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), "");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), "");
+  EXPECT_NO_THROW(n++);
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), "");
+  EXPECT_ANY_THROW(throw 1);
+  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), "");
+}
+
+TEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) {
+  if (AlwaysFalse())
+    EXPECT_THROW(ThrowNothing(), bool);
+
+  if (AlwaysTrue())
+    EXPECT_THROW(ThrowAnInteger(), int);
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    EXPECT_NO_THROW(ThrowAnInteger());
+
+  if (AlwaysTrue())
+    EXPECT_NO_THROW(ThrowNothing());
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    EXPECT_ANY_THROW(ThrowNothing());
+
+  if (AlwaysTrue())
+    EXPECT_ANY_THROW(ThrowAnInteger());
+  else
+    ;  // NOLINT
+}
+#endif  // GTEST_HAS_EXCEPTIONS
+
+TEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) {
+  if (AlwaysFalse())
+    EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. "
+                                    << "It's a compilation test only.";
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ASSERT_NO_FATAL_FAILURE(FAIL()) << "";
+  else
+    ;  // NOLINT
+
+  if (AlwaysTrue())
+    EXPECT_NO_FATAL_FAILURE(SUCCEED());
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ;  // NOLINT
+  else
+    ASSERT_NO_FATAL_FAILURE(SUCCEED());
+}
+
+// Tests that the assertion macros work well with switch statements.
+TEST(AssertionSyntaxTest, WorksWithSwitch) {
+  switch (0) {
+    case 1:
+      break;
+    default:
+      ASSERT_TRUE(true);
+  }
+
+  switch (0)
+    case 0:
+      EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
+
+  // Binary assertions are implemented using a different code path
+  // than the Boolean assertions.  Hence we test them separately.
+  switch (0) {
+    case 1:
+    default:
+      ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler";
+  }
+
+  switch (0)
+    case 0:
+      EXPECT_NE(1, 2);
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+void ThrowAString() {
+    throw "String";
+}
+
+// Test that the exception assertion macros compile and work with const
+// type qualifier.
+TEST(AssertionSyntaxTest, WorksWithConst) {
+    ASSERT_THROW(ThrowAString(), const char*);
+
+    EXPECT_THROW(ThrowAString(), const char*);
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+}  // namespace
+
+namespace testing {
+
+// Tests that Google Test tracks SUCCEED*.
+TEST(SuccessfulAssertionTest, SUCCEED) {
+  SUCCEED();
+  SUCCEED() << "OK";
+  EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+// Tests that Google Test doesn't track successful EXPECT_*.
+TEST(SuccessfulAssertionTest, EXPECT) {
+  EXPECT_TRUE(true);
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+// Tests that Google Test doesn't track successful EXPECT_STR*.
+TEST(SuccessfulAssertionTest, EXPECT_STR) {
+  EXPECT_STREQ("", "");
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+// Tests that Google Test doesn't track successful ASSERT_*.
+TEST(SuccessfulAssertionTest, ASSERT) {
+  ASSERT_TRUE(true);
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+// Tests that Google Test doesn't track successful ASSERT_STR*.
+TEST(SuccessfulAssertionTest, ASSERT_STR) {
+  ASSERT_STREQ("", "");
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+}  // namespace testing
+
+namespace {
+
+// Tests EXPECT_TRUE.
+TEST(ExpectTest, EXPECT_TRUE) {
+  EXPECT_TRUE(2 > 1);  // NOLINT
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1),
+                          "Value of: 2 < 1\n"
+                          "  Actual: false\n"
+                          "Expected: true");
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3),
+                          "2 > 3");
+}
+
+// Tests EXPECT_FALSE.
+TEST(ExpectTest, EXPECT_FALSE) {
+  EXPECT_FALSE(2 < 1);  // NOLINT
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1),
+                          "Value of: 2 > 1\n"
+                          "  Actual: true\n"
+                          "Expected: false");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3),
+                          "2 < 3");
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" supressed them
+#pragma option pop
+#endif
+
+// Tests EXPECT_EQ.
+TEST(ExpectTest, EXPECT_EQ) {
+  EXPECT_EQ(5, 2 + 3);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
+                          "Value of: 2*3\n"
+                          "  Actual: 6\n"
+                          "Expected: 5");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
+                          "2 - 3");
+}
+
+// Tests using EXPECT_EQ on double values.  The purpose is to make
+// sure that the specialization we did for integer and anonymous enums
+// isn't used for double arguments.
+TEST(ExpectTest, EXPECT_EQ_Double) {
+  // A success.
+  EXPECT_EQ(5.6, 5.6);
+
+  // A failure.
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2),
+                          "5.1");
+}
+
+#if !GTEST_OS_SYMBIAN
+// Tests EXPECT_EQ(NULL, pointer).
+TEST(ExpectTest, EXPECT_EQ_NULL) {
+  // A success.
+  const char* p = NULL;
+  // Some older GCC versions may issue a spurious waring in this or the next
+  // assertion statement. This warning should not be suppressed with
+  // static_cast since the test verifies the ability to use bare NULL as the
+  // expected parameter to the macro.
+  EXPECT_EQ(NULL, p);
+
+  // A failure.
+  int n = 0;
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
+                          "Value of: &n\n");
+}
+#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
+// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as
+// EXPECT_EQ(static_cast<void*>(NULL), non_pointer).
+TEST(ExpectTest, EXPECT_EQ_0) {
+  int n = 0;
+
+  // A success.
+  EXPECT_EQ(0, n);
+
+  // A failure.
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
+                          "Expected: 0");
+}
+
+// Tests EXPECT_NE.
+TEST(ExpectTest, EXPECT_NE) {
+  EXPECT_NE(6, 7);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'),
+                          "Expected: ('a') != ('a'), "
+                          "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2),
+                          "2");
+  char* const p0 = NULL;
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0),
+                          "p0");
+  // Only way to get the Nokia compiler to compile the cast
+  // is to have a separate void* variable first. Putting
+  // the two casts on the same line doesn't work, neither does
+  // a direct C-style to char*.
+  void* pv1 = (void*)0x1234;  // NOLINT
+  char* const p1 = reinterpret_cast<char*>(pv1);
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1),
+                          "p1");
+}
+
+// Tests EXPECT_LE.
+TEST(ExpectTest, EXPECT_LE) {
+  EXPECT_LE(2, 3);
+  EXPECT_LE(2, 2);
+  EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0),
+                          "Expected: (2) <= (0), actual: 2 vs 0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9),
+                          "(1.1) <= (0.9)");
+}
+
+// Tests EXPECT_LT.
+TEST(ExpectTest, EXPECT_LT) {
+  EXPECT_LT(2, 3);
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2),
+                          "Expected: (2) < (2), actual: 2 vs 2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1),
+                          "(2) < (1)");
+}
+
+// Tests EXPECT_GE.
+TEST(ExpectTest, EXPECT_GE) {
+  EXPECT_GE(2, 1);
+  EXPECT_GE(2, 2);
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3),
+                          "Expected: (2) >= (3), actual: 2 vs 3");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1),
+                          "(0.9) >= (1.1)");
+}
+
+// Tests EXPECT_GT.
+TEST(ExpectTest, EXPECT_GT) {
+  EXPECT_GT(2, 1);
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2),
+                          "Expected: (2) > (2), actual: 2 vs 2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3),
+                          "(2) > (3)");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Tests EXPECT_THROW.
+TEST(ExpectTest, EXPECT_THROW) {
+  EXPECT_THROW(ThrowAnInteger(), int);
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
+                          "Expected: ThrowAnInteger() throws an exception of "
+                          "type bool.\n  Actual: it throws a different type.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW(ThrowNothing(), bool),
+      "Expected: ThrowNothing() throws an exception of type bool.\n"
+      "  Actual: it throws nothing.");
+}
+
+// Tests EXPECT_NO_THROW.
+TEST(ExpectTest, EXPECT_NO_THROW) {
+  EXPECT_NO_THROW(ThrowNothing());
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),
+                          "Expected: ThrowAnInteger() doesn't throw an "
+                          "exception.\n  Actual: it throws.");
+}
+
+// Tests EXPECT_ANY_THROW.
+TEST(ExpectTest, EXPECT_ANY_THROW) {
+  EXPECT_ANY_THROW(ThrowAnInteger());
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_ANY_THROW(ThrowNothing()),
+      "Expected: ThrowNothing() throws an exception.\n"
+      "  Actual: it doesn't.");
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Make sure we deal with the precedence of <<.
+TEST(ExpectTest, ExpectPrecedence) {
+  EXPECT_EQ(1 < 2, true);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
+                          "Value of: true && false");
+}
+
+
+// Tests the StreamableToString() function.
+
+// Tests using StreamableToString() on a scalar.
+TEST(StreamableToStringTest, Scalar) {
+  EXPECT_STREQ("5", StreamableToString(5).c_str());
+}
+
+// Tests using StreamableToString() on a non-char pointer.
+TEST(StreamableToStringTest, Pointer) {
+  int n = 0;
+  int* p = &n;
+  EXPECT_STRNE("(null)", StreamableToString(p).c_str());
+}
+
+// Tests using StreamableToString() on a NULL non-char pointer.
+TEST(StreamableToStringTest, NullPointer) {
+  int* p = NULL;
+  EXPECT_STREQ("(null)", StreamableToString(p).c_str());
+}
+
+// Tests using StreamableToString() on a C string.
+TEST(StreamableToStringTest, CString) {
+  EXPECT_STREQ("Foo", StreamableToString("Foo").c_str());
+}
+
+// Tests using StreamableToString() on a NULL C string.
+TEST(StreamableToStringTest, NullCString) {
+  char* p = NULL;
+  EXPECT_STREQ("(null)", StreamableToString(p).c_str());
+}
+
+// Tests using streamable values as assertion messages.
+
+#if GTEST_HAS_STD_STRING
+// Tests using std::string as an assertion message.
+TEST(StreamableTest, string) {
+  static const std::string str(
+      "This failure message is a std::string, and is expected.");
+  EXPECT_FATAL_FAILURE(FAIL() << str,
+                       str.c_str());
+}
+
+// Tests that we can output strings containing embedded NULs.
+// Limited to Linux because we can only do this with std::string's.
+TEST(StreamableTest, stringWithEmbeddedNUL) {
+  static const char char_array_with_nul[] =
+      "Here's a NUL\0 and some more string";
+  static const std::string string_with_nul(char_array_with_nul,
+                                           sizeof(char_array_with_nul)
+                                           - 1);  // drops the trailing NUL
+  EXPECT_FATAL_FAILURE(FAIL() << string_with_nul,
+                       "Here's a NUL\\0 and some more string");
+}
+
+#endif  // GTEST_HAS_STD_STRING
+
+// Tests that we can output a NUL char.
+TEST(StreamableTest, NULChar) {
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    FAIL() << "A NUL" << '\0' << " and some more string";
+  }, "A NUL\\0 and some more string");
+}
+
+// Tests using int as an assertion message.
+TEST(StreamableTest, int) {
+  EXPECT_FATAL_FAILURE(FAIL() << 900913,
+                       "900913");
+}
+
+// Tests using NULL char pointer as an assertion message.
+//
+// In MSVC, streaming a NULL char * causes access violation.  Google Test
+// implemented a workaround (substituting "(null)" for NULL).  This
+// tests whether the workaround works.
+TEST(StreamableTest, NullCharPtr) {
+  EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL),
+                       "(null)");
+}
+
+// Tests that basic IO manipulators (endl, ends, and flush) can be
+// streamed to testing::Message.
+TEST(StreamableTest, BasicIoManip) {
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    FAIL() << "Line 1." << std::endl
+           << "A NUL char " << std::ends << std::flush << " in line 2.";
+  }, "Line 1.\nA NUL char \\0 in line 2.");
+}
+
+// Tests the macros that haven't been covered so far.
+
+void AddFailureHelper(bool* aborted) {
+  *aborted = true;
+  ADD_FAILURE() << "Failure";
+  *aborted = false;
+}
+
+// Tests ADD_FAILURE.
+TEST(MacroTest, ADD_FAILURE) {
+  bool aborted = true;
+  EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted),
+                          "Failure");
+  EXPECT_FALSE(aborted);
+}
+
+// Tests FAIL.
+TEST(MacroTest, FAIL) {
+  EXPECT_FATAL_FAILURE(FAIL(),
+                       "Failed");
+  EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.",
+                       "Intentional failure.");
+}
+
+// Tests SUCCEED
+TEST(MacroTest, SUCCEED) {
+  SUCCEED();
+  SUCCEED() << "Explicit success.";
+}
+
+
+// Tests for EXPECT_EQ() and ASSERT_EQ().
+//
+// These tests fail *intentionally*, s.t. the failure messages can be
+// generated and tested.
+//
+// We have different tests for different argument types.
+
+// Tests using bool values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, Bool) {
+  EXPECT_EQ(true,  true);
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(false, true),
+                       "Value of: true");
+}
+
+// Tests using int values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, Int) {
+  ASSERT_EQ(32, 32);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
+                          "33");
+}
+
+// Tests using time_t values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, Time_T) {
+  EXPECT_EQ(static_cast<time_t>(0),
+            static_cast<time_t>(0));
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0),
+                                 static_cast<time_t>(1234)),
+                       "1234");
+}
+
+// Tests using char values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, Char) {
+  ASSERT_EQ('z', 'z');
+  const char ch = 'b';
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
+                          "ch");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
+                          "ch");
+}
+
+// Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, WideChar) {
+  EXPECT_EQ(L'b', L'b');
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),
+                          "Value of: L'x'\n"
+                          "  Actual: L'x' (120, 0x78)\n"
+                          "Expected: L'\0'\n"
+                          "Which is: L'\0' (0, 0x0)");
+
+  static wchar_t wchar;
+  wchar = L'b';
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),
+                          "wchar");
+  wchar = L'\x8119';
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(L'\x8120', wchar),
+                       "Value of: wchar");
+}
+
+#if GTEST_HAS_STD_STRING
+// Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, StdString) {
+  // Compares a const char* to an std::string that has identical
+  // content.
+  ASSERT_EQ("Test", ::std::string("Test"));
+
+  // Compares two identical std::strings.
+  static const ::std::string str1("A * in the middle");
+  static const ::std::string str2(str1);
+  EXPECT_EQ(str1, str2);
+
+  // Compares a const char* to an std::string that has different
+  // content
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")),
+                          "::std::string(\"test\")");
+
+  // Compares an std::string to a char* that has different content.
+  char* const p1 = const_cast<char*>("foo");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1),
+                          "p1");
+
+  // Compares two std::strings that have different contents, one of
+  // which having a NUL character in the middle.  This should fail.
+  static ::std::string str3(str1);
+  str3.at(2) = '\0';
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
+                       "Value of: str3\n"
+                       "  Actual: \"A \\0 in the middle\"");
+}
+
+#endif  // GTEST_HAS_STD_STRING
+
+#if GTEST_HAS_STD_WSTRING
+
+// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, StdWideString) {
+  // Compares an std::wstring to a const wchar_t* that has identical
+  // content.
+  EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8119");
+
+  // Compares two identical std::wstrings.
+  const ::std::wstring wstr1(L"A * in the middle");
+  const ::std::wstring wstr2(wstr1);
+  ASSERT_EQ(wstr1, wstr2);
+
+  // Compares an std::wstring to a const wchar_t* that has different
+  // content.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8120");
+  }, "L\"Test\\x8120\"");
+
+  // Compares two std::wstrings that have different contents, one of
+  // which having a NUL character in the middle.
+  ::std::wstring wstr3(wstr1);
+  wstr3.at(2) = L'\0';
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3),
+                          "wstr3");
+
+  // Compares a wchar_t* to an std::wstring that has different
+  // content.
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
+  }, "");
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_STRING
+// Tests using ::string values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, GlobalString) {
+  // Compares a const char* to a ::string that has identical content.
+  EXPECT_EQ("Test", ::string("Test"));
+
+  // Compares two identical ::strings.
+  const ::string str1("A * in the middle");
+  const ::string str2(str1);
+  ASSERT_EQ(str1, str2);
+
+  // Compares a ::string to a const char* that has different content.
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"),
+                          "test");
+
+  // Compares two ::strings that have different contents, one of which
+  // having a NUL character in the middle.
+  ::string str3(str1);
+  str3.at(2) = '\0';
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3),
+                          "str3");
+
+  // Compares a ::string to a char* that has different content.
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_EQ(::string("bar"), const_cast<char*>("foo"));
+  }, "");
+}
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+
+// Tests using ::wstring values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, GlobalWideString) {
+  // Compares a const wchar_t* to a ::wstring that has identical content.
+  ASSERT_EQ(L"Test\x8119", ::wstring(L"Test\x8119"));
+
+  // Compares two identical ::wstrings.
+  static const ::wstring wstr1(L"A * in the middle");
+  static const ::wstring wstr2(wstr1);
+  EXPECT_EQ(wstr1, wstr2);
+
+  // Compares a const wchar_t* to a ::wstring that has different
+  // content.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EQ(L"Test\x8120", ::wstring(L"Test\x8119"));
+  }, "Test\\x8119");
+
+  // Compares a wchar_t* to a ::wstring that has different content.
+  wchar_t* const p1 = const_cast<wchar_t*>(L"foo");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")),
+                          "bar");
+
+  // Compares two ::wstrings that have different contents, one of which
+  // having a NUL character in the middle.
+  static ::wstring wstr3;
+  wstr3 = wstr1;
+  wstr3.at(2) = L'\0';
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3),
+                       "wstr3");
+}
+
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// Tests using char pointers in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, CharPointer) {
+  char* const p0 = NULL;
+  // Only way to get the Nokia compiler to compile the cast
+  // is to have a separate void* variable first. Putting
+  // the two casts on the same line doesn't work, neither does
+  // a direct C-style to char*.
+  void* pv1 = (void*)0x1234;  // NOLINT
+  void* pv2 = (void*)0xABC0;  // NOLINT
+  char* const p1 = reinterpret_cast<char*>(pv1);
+  char* const p2 = reinterpret_cast<char*>(pv2);
+  ASSERT_EQ(p1, p1);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
+                          "Value of: p2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
+                          "p2");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
+                                 reinterpret_cast<char*>(0xABC0)),
+                       "ABC0");
+}
+
+// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, WideCharPointer) {
+  wchar_t* const p0 = NULL;
+  // Only way to get the Nokia compiler to compile the cast
+  // is to have a separate void* variable first. Putting
+  // the two casts on the same line doesn't work, neither does
+  // a direct C-style to char*.
+  void* pv1 = (void*)0x1234;  // NOLINT
+  void* pv2 = (void*)0xABC0;  // NOLINT
+  wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1);
+  wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2);
+  EXPECT_EQ(p0, p0);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
+                          "Value of: p2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
+                          "p2");
+  void* pv3 = (void*)0x1234;  // NOLINT
+  void* pv4 = (void*)0xABC0;  // NOLINT
+  const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
+  const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4),
+                          "p4");
+}
+
+// Tests using other types of pointers in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, OtherPointer) {
+  ASSERT_EQ(static_cast<const int*>(NULL),
+            static_cast<const int*>(NULL));
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL),
+                                 reinterpret_cast<const int*>(0x1234)),
+                       "0x1234");
+}
+
+// Tests the FRIEND_TEST macro.
+
+// This class has a private member we want to test.  We will test it
+// both in a TEST and in a TEST_F.
+class Foo {
+ public:
+  Foo() {}
+
+ private:
+  int Bar() const { return 1; }
+
+  // Declares the friend tests that can access the private member
+  // Bar().
+  FRIEND_TEST(FRIEND_TEST_Test, TEST);
+  FRIEND_TEST(FRIEND_TEST_Test2, TEST_F);
+};
+
+// Tests that the FRIEND_TEST declaration allows a TEST to access a
+// class's private members.  This should compile.
+TEST(FRIEND_TEST_Test, TEST) {
+  ASSERT_EQ(1, Foo().Bar());
+}
+
+// The fixture needed to test using FRIEND_TEST with TEST_F.
+class FRIEND_TEST_Test2 : public Test {
+ protected:
+  Foo foo;
+};
+
+// Tests that the FRIEND_TEST declaration allows a TEST_F to access a
+// class's private members.  This should compile.
+TEST_F(FRIEND_TEST_Test2, TEST_F) {
+  ASSERT_EQ(1, foo.Bar());
+}
+
+// Tests the life cycle of Test objects.
+
+// The test fixture for testing the life cycle of Test objects.
+//
+// This class counts the number of live test objects that uses this
+// fixture.
+class TestLifeCycleTest : public Test {
+ protected:
+  // Constructor.  Increments the number of test objects that uses
+  // this fixture.
+  TestLifeCycleTest() { count_++; }
+
+  // Destructor.  Decrements the number of test objects that uses this
+  // fixture.
+  ~TestLifeCycleTest() { count_--; }
+
+  // Returns the number of live test objects that uses this fixture.
+  int count() const { return count_; }
+
+ private:
+  static int count_;
+};
+
+int TestLifeCycleTest::count_ = 0;
+
+// Tests the life cycle of test objects.
+TEST_F(TestLifeCycleTest, Test1) {
+  // There should be only one test object in this test case that's
+  // currently alive.
+  ASSERT_EQ(1, count());
+}
+
+// Tests the life cycle of test objects.
+TEST_F(TestLifeCycleTest, Test2) {
+  // After Test1 is done and Test2 is started, there should still be
+  // only one live test object, as the object for Test1 should've been
+  // deleted.
+  ASSERT_EQ(1, count());
+}
+
+}  // namespace
+
+// Tests streaming a user type whose definition and operator << are
+// both in the global namespace.
+class Base {
+ public:
+  explicit Base(int x) : x_(x) {}
+  int x() const { return x_; }
+ private:
+  int x_;
+};
+std::ostream& operator<<(std::ostream& os,
+                         const Base& val) {
+  return os << val.x();
+}
+std::ostream& operator<<(std::ostream& os,
+                         const Base* pointer) {
+  return os << "(" << pointer->x() << ")";
+}
+
+TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {
+  Message msg;
+  Base a(1);
+
+  msg << a << &a;  // Uses ::operator<<.
+  EXPECT_STREQ("1(1)", msg.GetString().c_str());
+}
+
+// Tests streaming a user type whose definition and operator<< are
+// both in an unnamed namespace.
+namespace {
+class MyTypeInUnnamedNameSpace : public Base {
+ public:
+  explicit MyTypeInUnnamedNameSpace(int x): Base(x) {}
+};
+std::ostream& operator<<(std::ostream& os,
+                         const MyTypeInUnnamedNameSpace& val) {
+  return os << val.x();
+}
+std::ostream& operator<<(std::ostream& os,
+                         const MyTypeInUnnamedNameSpace* pointer) {
+  return os << "(" << pointer->x() << ")";
+}
+}  // namespace
+
+TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {
+  Message msg;
+  MyTypeInUnnamedNameSpace a(1);
+
+  msg << a << &a;  // Uses <unnamed_namespace>::operator<<.
+  EXPECT_STREQ("1(1)", msg.GetString().c_str());
+}
+
+// Tests streaming a user type whose definition and operator<< are
+// both in a user namespace.
+namespace namespace1 {
+class MyTypeInNameSpace1 : public Base {
+ public:
+  explicit MyTypeInNameSpace1(int x): Base(x) {}
+};
+std::ostream& operator<<(std::ostream& os,
+                         const MyTypeInNameSpace1& val) {
+  return os << val.x();
+}
+std::ostream& operator<<(std::ostream& os,
+                         const MyTypeInNameSpace1* pointer) {
+  return os << "(" << pointer->x() << ")";
+}
+}  // namespace namespace1
+
+TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {
+  Message msg;
+  namespace1::MyTypeInNameSpace1 a(1);
+
+  msg << a << &a;  // Uses namespace1::operator<<.
+  EXPECT_STREQ("1(1)", msg.GetString().c_str());
+}
+
+// Tests streaming a user type whose definition is in a user namespace
+// but whose operator<< is in the global namespace.
+namespace namespace2 {
+class MyTypeInNameSpace2 : public ::Base {
+ public:
+  explicit MyTypeInNameSpace2(int x): Base(x) {}
+};
+}  // namespace namespace2
+std::ostream& operator<<(std::ostream& os,
+                         const namespace2::MyTypeInNameSpace2& val) {
+  return os << val.x();
+}
+std::ostream& operator<<(std::ostream& os,
+                         const namespace2::MyTypeInNameSpace2* pointer) {
+  return os << "(" << pointer->x() << ")";
+}
+
+TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) {
+  Message msg;
+  namespace2::MyTypeInNameSpace2 a(1);
+
+  msg << a << &a;  // Uses ::operator<<.
+  EXPECT_STREQ("1(1)", msg.GetString().c_str());
+}
+
+// Tests streaming NULL pointers to testing::Message.
+TEST(MessageTest, NullPointers) {
+  Message msg;
+  char* const p1 = NULL;
+  unsigned char* const p2 = NULL;
+  int* p3 = NULL;
+  double* p4 = NULL;
+  bool* p5 = NULL;
+  Message* p6 = NULL;
+
+  msg << p1 << p2 << p3 << p4 << p5 << p6;
+  ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
+               msg.GetString().c_str());
+}
+
+// Tests streaming wide strings to testing::Message.
+TEST(MessageTest, WideStrings) {
+  // Streams a NULL of type const wchar_t*.
+  const wchar_t* const_wstr = NULL;
+  EXPECT_STREQ("(null)",
+               (Message() << const_wstr).GetString().c_str());
+
+  // Streams a NULL of type wchar_t*.
+  wchar_t* wstr = NULL;
+  EXPECT_STREQ("(null)",
+               (Message() << wstr).GetString().c_str());
+
+  // Streams a non-NULL of type const wchar_t*.
+  const_wstr = L"abc\x8119";
+  EXPECT_STREQ("abc\xe8\x84\x99",
+               (Message() << const_wstr).GetString().c_str());
+
+  // Streams a non-NULL of type wchar_t*.
+  wstr = const_cast<wchar_t*>(const_wstr);
+  EXPECT_STREQ("abc\xe8\x84\x99",
+               (Message() << wstr).GetString().c_str());
+}
+
+
+// This line tests that we can define tests in the testing namespace.
+namespace testing {
+
+// Tests the TestInfo class.
+
+class TestInfoTest : public Test {
+ protected:
+  static const TestInfo* GetTestInfo(const char* test_name) {
+    const TestCase* const test_case = GetUnitTestImpl()->
+        GetTestCase("TestInfoTest", "", NULL, NULL);
+
+    for (int i = 0; i < test_case->total_test_count(); ++i) {
+      const TestInfo* const test_info = test_case->GetTestInfo(i);
+      if (strcmp(test_name, test_info->name()) == 0)
+        return test_info;
+    }
+    return NULL;
+  }
+
+  static const TestResult* GetTestResult(
+      const TestInfo* test_info) {
+    return test_info->result();
+  }
+};
+
+// Tests TestInfo::test_case_name() and TestInfo::name().
+TEST_F(TestInfoTest, Names) {
+  const TestInfo* const test_info = GetTestInfo("Names");
+
+  ASSERT_STREQ("TestInfoTest", test_info->test_case_name());
+  ASSERT_STREQ("Names", test_info->name());
+}
+
+// Tests TestInfo::result().
+TEST_F(TestInfoTest, result) {
+  const TestInfo* const test_info = GetTestInfo("result");
+
+  // Initially, there is no TestPartResult for this test.
+  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
+
+  // After the previous assertion, there is still none.
+  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
+}
+
+// Tests setting up and tearing down a test case.
+
+class SetUpTestCaseTest : public Test {
+ protected:
+  // This will be called once before the first test in this test case
+  // is run.
+  static void SetUpTestCase() {
+    printf("Setting up the test case . . .\n");
+
+    // Initializes some shared resource.  In this simple example, we
+    // just create a C string.  More complex stuff can be done if
+    // desired.
+    shared_resource_ = "123";
+
+    // Increments the number of test cases that have been set up.
+    counter_++;
+
+    // SetUpTestCase() should be called only once.
+    EXPECT_EQ(1, counter_);
+  }
+
+  // This will be called once after the last test in this test case is
+  // run.
+  static void TearDownTestCase() {
+    printf("Tearing down the test case . . .\n");
+
+    // Decrements the number of test cases that have been set up.
+    counter_--;
+
+    // TearDownTestCase() should be called only once.
+    EXPECT_EQ(0, counter_);
+
+    // Cleans up the shared resource.
+    shared_resource_ = NULL;
+  }
+
+  // This will be called before each test in this test case.
+  virtual void SetUp() {
+    // SetUpTestCase() should be called only once, so counter_ should
+    // always be 1.
+    EXPECT_EQ(1, counter_);
+  }
+
+  // Number of test cases that have been set up.
+  static int counter_;
+
+  // Some resource to be shared by all tests in this test case.
+  static const char* shared_resource_;
+};
+
+int SetUpTestCaseTest::counter_ = 0;
+const char* SetUpTestCaseTest::shared_resource_ = NULL;
+
+// A test that uses the shared resource.
+TEST_F(SetUpTestCaseTest, Test1) {
+  EXPECT_STRNE(NULL, shared_resource_);
+}
+
+// Another test that uses the shared resource.
+TEST_F(SetUpTestCaseTest, Test2) {
+  EXPECT_STREQ("123", shared_resource_);
+}
+
+// The InitGoogleTestTest test case tests testing::InitGoogleTest().
+
+// The Flags struct stores a copy of all Google Test flags.
+struct Flags {
+  // Constructs a Flags struct where each flag has its default value.
+  Flags() : also_run_disabled_tests(false),
+            break_on_failure(false),
+            catch_exceptions(false),
+            death_test_use_fork(false),
+            filter(""),
+            list_tests(false),
+            output(""),
+            print_time(true),
+            random_seed(0),
+            repeat(1),
+            shuffle(false),
+            throw_on_failure(false) {}
+
+  // Factory methods.
+
+  // Creates a Flags struct where the gtest_also_run_disabled_tests flag has
+  // the given value.
+  static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
+    Flags flags;
+    flags.also_run_disabled_tests = also_run_disabled_tests;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_break_on_failure flag has
+  // the given value.
+  static Flags BreakOnFailure(bool break_on_failure) {
+    Flags flags;
+    flags.break_on_failure = break_on_failure;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_catch_exceptions flag has
+  // the given value.
+  static Flags CatchExceptions(bool catch_exceptions) {
+    Flags flags;
+    flags.catch_exceptions = catch_exceptions;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_death_test_use_fork flag has
+  // the given value.
+  static Flags DeathTestUseFork(bool death_test_use_fork) {
+    Flags flags;
+    flags.death_test_use_fork = death_test_use_fork;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_filter flag has the given
+  // value.
+  static Flags Filter(const char* filter) {
+    Flags flags;
+    flags.filter = filter;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_list_tests flag has the
+  // given value.
+  static Flags ListTests(bool list_tests) {
+    Flags flags;
+    flags.list_tests = list_tests;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_output flag has the given
+  // value.
+  static Flags Output(const char* output) {
+    Flags flags;
+    flags.output = output;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_print_time flag has the given
+  // value.
+  static Flags PrintTime(bool print_time) {
+    Flags flags;
+    flags.print_time = print_time;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_random_seed flag has
+  // the given value.
+  static Flags RandomSeed(Int32 random_seed) {
+    Flags flags;
+    flags.random_seed = random_seed;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_repeat flag has the given
+  // value.
+  static Flags Repeat(Int32 repeat) {
+    Flags flags;
+    flags.repeat = repeat;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_shuffle flag has
+  // the given value.
+  static Flags Shuffle(bool shuffle) {
+    Flags flags;
+    flags.shuffle = shuffle;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_throw_on_failure flag has
+  // the given value.
+  static Flags ThrowOnFailure(bool throw_on_failure) {
+    Flags flags;
+    flags.throw_on_failure = throw_on_failure;
+    return flags;
+  }
+
+  // These fields store the flag values.
+  bool also_run_disabled_tests;
+  bool break_on_failure;
+  bool catch_exceptions;
+  bool death_test_use_fork;
+  const char* filter;
+  bool list_tests;
+  const char* output;
+  bool print_time;
+  Int32 random_seed;
+  Int32 repeat;
+  bool shuffle;
+  bool throw_on_failure;
+};
+
+// Fixture for testing InitGoogleTest().
+class InitGoogleTestTest : public Test {
+ protected:
+  // Clears the flags before each test.
+  virtual void SetUp() {
+    GTEST_FLAG(also_run_disabled_tests) = false;
+    GTEST_FLAG(break_on_failure) = false;
+    GTEST_FLAG(catch_exceptions) = false;
+    GTEST_FLAG(death_test_use_fork) = false;
+    GTEST_FLAG(filter) = "";
+    GTEST_FLAG(list_tests) = false;
+    GTEST_FLAG(output) = "";
+    GTEST_FLAG(print_time) = true;
+    GTEST_FLAG(random_seed) = 0;
+    GTEST_FLAG(repeat) = 1;
+    GTEST_FLAG(shuffle) = false;
+    GTEST_FLAG(throw_on_failure) = false;
+  }
+
+  // Asserts that two narrow or wide string arrays are equal.
+  template <typename CharType>
+  static void AssertStringArrayEq(size_t size1, CharType** array1,
+                                  size_t size2, CharType** array2) {
+    ASSERT_EQ(size1, size2) << " Array sizes different.";
+
+    for (size_t i = 0; i != size1; i++) {
+      ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i;
+    }
+  }
+
+  // Verifies that the flag values match the expected values.
+  static void CheckFlags(const Flags& expected) {
+    EXPECT_EQ(expected.also_run_disabled_tests,
+              GTEST_FLAG(also_run_disabled_tests));
+    EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
+    EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
+    EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
+    EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
+    EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
+    EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
+    EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));
+    EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));
+    EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));
+    EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));
+    EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));
+  }
+
+  // Parses a command line (specified by argc1 and argv1), then
+  // verifies that the flag values are expected and that the
+  // recognized flags are removed from the command line.
+  template <typename CharType>
+  static void TestParsingFlags(int argc1, const CharType** argv1,
+                               int argc2, const CharType** argv2,
+                               const Flags& expected) {
+    // Parses the command line.
+    internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
+
+    // Verifies the flag values.
+    CheckFlags(expected);
+
+    // Verifies that the recognized flags are removed from the command
+    // line.
+    AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);
+  }
+
+  // This macro wraps TestParsingFlags s.t. the user doesn't need
+  // to specify the array sizes.
+#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected) \
+  TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
+                   sizeof(argv2)/sizeof(*argv2) - 1, argv2, expected)
+};
+
+// Tests parsing an empty command line.
+TEST_F(InitGoogleTestTest, Empty) {
+  const char* argv[] = {
+    NULL
+  };
+
+  const char* argv2[] = {
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());
+}
+
+// Tests parsing a command line that has no flag.
+TEST_F(InitGoogleTestTest, NoFlag) {
+  const char* argv[] = {
+    "foo.exe",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());
+}
+
+// Tests parsing a bad --gtest_filter flag.
+TEST_F(InitGoogleTestTest, FilterBad) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_filter",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    "--gtest_filter",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""));
+}
+
+// Tests parsing an empty --gtest_filter flag.
+TEST_F(InitGoogleTestTest, FilterEmpty) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_filter=",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""));
+}
+
+// Tests parsing a non-empty --gtest_filter flag.
+TEST_F(InitGoogleTestTest, FilterNonEmpty) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_filter=abc",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"));
+}
+
+// Tests parsing --gtest_break_on_failure.
+TEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure",
+    NULL
+};
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true));
+}
+
+// Tests parsing --gtest_break_on_failure=0.
+TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure=0",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));
+}
+
+// Tests parsing --gtest_break_on_failure=f.
+TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure=f",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));
+}
+
+// Tests parsing --gtest_break_on_failure=F.
+TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure=F",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false));
+}
+
+// Tests parsing a --gtest_break_on_failure flag that has a "true"
+// definition.
+TEST_F(InitGoogleTestTest, BreakOnFailureTrue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure=1",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true));
+}
+
+// Tests parsing --gtest_catch_exceptions.
+TEST_F(InitGoogleTestTest, CatchExceptions) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_catch_exceptions",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true));
+}
+
+// Tests parsing --gtest_death_test_use_fork.
+TEST_F(InitGoogleTestTest, DeathTestUseFork) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_death_test_use_fork",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true));
+}
+
+// Tests having the same flag twice with different values.  The
+// expected behavior is that the one coming last takes precedence.
+TEST_F(InitGoogleTestTest, DuplicatedFlags) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_filter=a",
+    "--gtest_filter=b",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"));
+}
+
+// Tests having an unrecognized flag on the command line.
+TEST_F(InitGoogleTestTest, UnrecognizedFlag) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure",
+    "bar",  // Unrecognized by Google Test.
+    "--gtest_filter=b",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    "bar",
+    NULL
+  };
+
+  Flags flags;
+  flags.break_on_failure = true;
+  flags.filter = "b";
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags);
+}
+
+// Tests having a --gtest_list_tests flag
+TEST_F(InitGoogleTestTest, ListTestsFlag) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_list_tests",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true));
+}
+
+// Tests having a --gtest_list_tests flag with a "true" value
+TEST_F(InitGoogleTestTest, ListTestsTrue) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_list_tests=1",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true));
+}
+
+// Tests having a --gtest_list_tests flag with a "false" value
+TEST_F(InitGoogleTestTest, ListTestsFalse) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_list_tests=0",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));
+}
+
+// Tests parsing --gtest_list_tests=f.
+TEST_F(InitGoogleTestTest, ListTestsFalse_f) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_list_tests=f",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));
+}
+
+// Tests parsing --gtest_list_tests=F.
+TEST_F(InitGoogleTestTest, ListTestsFalse_F) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_list_tests=F",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false));
+}
+
+// Tests parsing --gtest_output (invalid).
+TEST_F(InitGoogleTestTest, OutputEmpty) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_output",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    "--gtest_output",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags());
+}
+
+// Tests parsing --gtest_output=xml
+TEST_F(InitGoogleTestTest, OutputXml) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_output=xml",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"));
+}
+
+// Tests parsing --gtest_output=xml:file
+TEST_F(InitGoogleTestTest, OutputXmlFile) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_output=xml:file",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"));
+}
+
+// Tests parsing --gtest_output=xml:directory/path/
+TEST_F(InitGoogleTestTest, OutputXmlDirectory) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_output=xml:directory/path/",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:directory/path/"));
+}
+
+// Tests having a --gtest_print_time flag
+TEST_F(InitGoogleTestTest, PrintTimeFlag) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_print_time",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true));
+}
+
+// Tests having a --gtest_print_time flag with a "true" value
+TEST_F(InitGoogleTestTest, PrintTimeTrue) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_print_time=1",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true));
+}
+
+// Tests having a --gtest_print_time flag with a "false" value
+TEST_F(InitGoogleTestTest, PrintTimeFalse) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_print_time=0",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));
+}
+
+// Tests parsing --gtest_print_time=f.
+TEST_F(InitGoogleTestTest, PrintTimeFalse_f) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_print_time=f",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));
+}
+
+// Tests parsing --gtest_print_time=F.
+TEST_F(InitGoogleTestTest, PrintTimeFalse_F) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_print_time=F",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false));
+}
+
+// Tests parsing --gtest_random_seed=number
+TEST_F(InitGoogleTestTest, RandomSeed) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_random_seed=1000",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000));
+}
+
+// Tests parsing --gtest_repeat=number
+TEST_F(InitGoogleTestTest, Repeat) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_repeat=1000",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000));
+}
+
+// Tests having a --gtest_also_run_disabled_tests flag
+TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_also_run_disabled_tests",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true));
+}
+
+// Tests having a --gtest_also_run_disabled_tests flag with a "true" value
+TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_also_run_disabled_tests=1",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true));
+}
+
+// Tests having a --gtest_also_run_disabled_tests flag with a "false" value
+TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_also_run_disabled_tests=0",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(false));
+}
+
+// Tests parsing --gtest_shuffle.
+TEST_F(InitGoogleTestTest, ShuffleWithoutValue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_shuffle",
+    NULL
+};
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true));
+}
+
+// Tests parsing --gtest_shuffle=0.
+TEST_F(InitGoogleTestTest, ShuffleFalse_0) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_shuffle=0",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false));
+}
+
+// Tests parsing a --gtest_shuffle flag that has a "true"
+// definition.
+TEST_F(InitGoogleTestTest, ShuffleTrue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_shuffle=1",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true));
+}
+
+// Tests parsing --gtest_throw_on_failure.
+TEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_throw_on_failure",
+    NULL
+};
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true));
+}
+
+// Tests parsing --gtest_throw_on_failure=0.
+TEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_throw_on_failure=0",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false));
+}
+
+// Tests parsing a --gtest_throw_on_failure flag that has a "true"
+// definition.
+TEST_F(InitGoogleTestTest, ThrowOnFailureTrue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_throw_on_failure=1",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true));
+}
+
+#if GTEST_OS_WINDOWS
+// Tests parsing wide strings.
+TEST_F(InitGoogleTestTest, WideStrings) {
+  const wchar_t* argv[] = {
+    L"foo.exe",
+    L"--gtest_filter=Foo*",
+    L"--gtest_list_tests=1",
+    L"--gtest_break_on_failure",
+    L"--non_gtest_flag",
+    NULL
+  };
+
+  const wchar_t* argv2[] = {
+    L"foo.exe",
+    L"--non_gtest_flag",
+    NULL
+  };
+
+  Flags expected_flags;
+  expected_flags.break_on_failure = true;
+  expected_flags.filter = "Foo*";
+  expected_flags.list_tests = true;
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags);
+}
+#endif  // GTEST_OS_WINDOWS
+
+// Tests current_test_info() in UnitTest.
+class CurrentTestInfoTest : public Test {
+ protected:
+  // Tests that current_test_info() returns NULL before the first test in
+  // the test case is run.
+  static void SetUpTestCase() {
+    // There should be no tests running at this point.
+    const TestInfo* test_info =
+      UnitTest::GetInstance()->current_test_info();
+    EXPECT_TRUE(test_info == NULL)
+        << "There should be no tests running at this point.";
+  }
+
+  // Tests that current_test_info() returns NULL after the last test in
+  // the test case has run.
+  static void TearDownTestCase() {
+    const TestInfo* test_info =
+      UnitTest::GetInstance()->current_test_info();
+    EXPECT_TRUE(test_info == NULL)
+        << "There should be no tests running at this point.";
+  }
+};
+
+// Tests that current_test_info() returns TestInfo for currently running
+// test by checking the expected test name against the actual one.
+TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) {
+  const TestInfo* test_info =
+    UnitTest::GetInstance()->current_test_info();
+  ASSERT_TRUE(NULL != test_info)
+      << "There is a test running so we should have a valid TestInfo.";
+  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
+      << "Expected the name of the currently running test case.";
+  EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name())
+      << "Expected the name of the currently running test.";
+}
+
+// Tests that current_test_info() returns TestInfo for currently running
+// test by checking the expected test name against the actual one.  We
+// use this test to see that the TestInfo object actually changed from
+// the previous invocation.
+TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) {
+  const TestInfo* test_info =
+    UnitTest::GetInstance()->current_test_info();
+  ASSERT_TRUE(NULL != test_info)
+      << "There is a test running so we should have a valid TestInfo.";
+  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
+      << "Expected the name of the currently running test case.";
+  EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name())
+      << "Expected the name of the currently running test.";
+}
+
+}  // namespace testing
+
+// These two lines test that we can define tests in a namespace that
+// has the name "testing" and is nested in another namespace.
+namespace my_namespace {
+namespace testing {
+
+// Makes sure that TEST knows to use ::testing::Test instead of
+// ::my_namespace::testing::Test.
+class Test {};
+
+// Makes sure that an assertion knows to use ::testing::Message instead of
+// ::my_namespace::testing::Message.
+class Message {};
+
+// Makes sure that an assertion knows to use
+// ::testing::AssertionResult instead of
+// ::my_namespace::testing::AssertionResult.
+class AssertionResult {};
+
+// Tests that an assertion that should succeed works as expected.
+TEST(NestedTestingNamespaceTest, Success) {
+  EXPECT_EQ(1, 1) << "This shouldn't fail.";
+}
+
+// Tests that an assertion that should fail works as expected.
+TEST(NestedTestingNamespaceTest, Failure) {
+  EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.",
+                       "This failure is expected.");
+}
+
+}  // namespace testing
+}  // namespace my_namespace
+
+// Tests that one can call superclass SetUp and TearDown methods--
+// that is, that they are not private.
+// No tests are based on this fixture; the test "passes" if it compiles
+// successfully.
+class ProtectedFixtureMethodsTest : public Test {
+ protected:
+  virtual void SetUp() {
+    Test::SetUp();
+  }
+  virtual void TearDown() {
+    Test::TearDown();
+  }
+};
+
+// StreamingAssertionsTest tests the streaming versions of a representative
+// sample of assertions.
+TEST(StreamingAssertionsTest, Unconditional) {
+  SUCCEED() << "expected success";
+  EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(FAIL() << "expected failure",
+                       "expected failure");
+}
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true", "Unreachable code"
+#pragma option push -w-ccc -w-rch
+#endif
+
+TEST(StreamingAssertionsTest, Truth) {
+  EXPECT_TRUE(true) << "unexpected failure";
+  ASSERT_TRUE(true) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, Truth2) {
+  EXPECT_FALSE(false) << "unexpected failure";
+  ASSERT_FALSE(false) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure",
+                       "expected failure");
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" supressed them
+#pragma option pop
+#endif
+
+TEST(StreamingAssertionsTest, IntegerEquals) {
+  EXPECT_EQ(1, 1) << "unexpected failure";
+  ASSERT_EQ(1, 1) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, IntegerLessThan) {
+  EXPECT_LT(1, 2) << "unexpected failure";
+  ASSERT_LT(1, 2) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, StringsEqual) {
+  EXPECT_STREQ("foo", "foo") << "unexpected failure";
+  ASSERT_STREQ("foo", "foo") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, StringsNotEqual) {
+  EXPECT_STRNE("foo", "bar") << "unexpected failure";
+  ASSERT_STRNE("foo", "bar") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, StringsEqualIgnoringCase) {
+  EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure";
+  ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) {
+  EXPECT_STRCASENE("foo", "bar") << "unexpected failure";
+  ASSERT_STRCASENE("foo", "bar") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, FloatingPointEquals) {
+  EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
+  ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure",
+                       "expected failure");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+TEST(StreamingAssertionsTest, Throw) {
+  EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";
+  ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<
+                          "expected failure", "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<
+                       "expected failure", "expected failure");
+}
+
+TEST(StreamingAssertionsTest, NoThrow) {
+  EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure";
+  ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<
+                          "expected failure", "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<
+                       "expected failure", "expected failure");
+}
+
+TEST(StreamingAssertionsTest, AnyThrow) {
+  EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
+  ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) <<
+                          "expected failure", "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) <<
+                       "expected failure", "expected failure");
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Tests that Google Test correctly decides whether to use colors in the output.
+
+TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
+  GTEST_FLAG(color) = "yes";
+
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+
+  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+}
+
+TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
+  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+
+  GTEST_FLAG(color) = "True";
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+
+  GTEST_FLAG(color) = "t";
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+
+  GTEST_FLAG(color) = "1";
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+}
+
+TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
+  GTEST_FLAG(color) = "no";
+
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
+
+  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
+}
+
+TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+
+  GTEST_FLAG(color) = "F";
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  GTEST_FLAG(color) = "0";
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  GTEST_FLAG(color) = "unknown";
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+}
+
+TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
+  GTEST_FLAG(color) = "auto";
+
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
+  EXPECT_TRUE(ShouldUseColor(true));    // Stdout is a TTY.
+}
+
+TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
+  GTEST_FLAG(color) = "auto";
+
+#if GTEST_OS_WINDOWS
+  // On Windows, we ignore the TERM variable as it's usually not set.
+
+  SetEnv("TERM", "dumb");
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "");
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm");
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+#else
+  // On non-Windows platforms, we rely on TERM to determine if the
+  // terminal supports colors.
+
+  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "emacs");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "vt100");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm-mono");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm-color");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "linux");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+#endif  // GTEST_OS_WINDOWS
+}
+
+// Verifies that StaticAssertTypeEq works in a namespace scope.
+
+static bool dummy1 = StaticAssertTypeEq<bool, bool>();
+static bool dummy2 = StaticAssertTypeEq<const int, const int>();
+
+// Verifies that StaticAssertTypeEq works in a class.
+
+template <typename T>
+class StaticAssertTypeEqTestHelper {
+ public:
+  StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); }
+};
+
+TEST(StaticAssertTypeEqTest, WorksInClass) {
+  StaticAssertTypeEqTestHelper<bool>();
+}
+
+// Verifies that StaticAssertTypeEq works inside a function.
+
+typedef int IntAlias;
+
+TEST(StaticAssertTypeEqTest, CompilesForEqualTypes) {
+  StaticAssertTypeEq<int, IntAlias>();
+  StaticAssertTypeEq<int*, IntAlias*>();
+}
+
+TEST(ThreadLocalTest, DefaultConstructor) {
+  ThreadLocal<int> t1;
+  EXPECT_EQ(0, t1.get());
+
+  ThreadLocal<void*> t2;
+  EXPECT_TRUE(t2.get() == NULL);
+}
+
+TEST(ThreadLocalTest, Init) {
+  ThreadLocal<int> t1(123);
+  EXPECT_EQ(123, t1.get());
+
+  int i = 0;
+  ThreadLocal<int*> t2(&i);
+  EXPECT_EQ(&i, t2.get());
+}
+
+TEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) {
+  testing::UnitTest* const unit_test = testing::UnitTest::GetInstance();
+
+  // We don't have a stack walker in Google Test yet.
+  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str());
+  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str());
+}
+
+TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {
+  EXPECT_FALSE(HasNonfatalFailure());
+}
+
+static void FailFatally() { FAIL(); }
+
+TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) {
+  FailFatally();
+  const bool has_nonfatal_failure = HasNonfatalFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_FALSE(has_nonfatal_failure);
+}
+
+TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
+  ADD_FAILURE();
+  const bool has_nonfatal_failure = HasNonfatalFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_nonfatal_failure);
+}
+
+TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
+  FailFatally();
+  ADD_FAILURE();
+  const bool has_nonfatal_failure = HasNonfatalFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_nonfatal_failure);
+}
+
+// A wrapper for calling HasNonfatalFailure outside of a test body.
+static bool HasNonfatalFailureHelper() {
+  return testing::Test::HasNonfatalFailure();
+}
+
+TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) {
+  EXPECT_FALSE(HasNonfatalFailureHelper());
+}
+
+TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) {
+  ADD_FAILURE();
+  const bool has_nonfatal_failure = HasNonfatalFailureHelper();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_nonfatal_failure);
+}
+
+TEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) {
+  EXPECT_FALSE(HasFailure());
+}
+
+TEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) {
+  FailFatally();
+  const bool has_failure = HasFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_failure);
+}
+
+TEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
+  ADD_FAILURE();
+  const bool has_failure = HasFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_failure);
+}
+
+TEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
+  FailFatally();
+  ADD_FAILURE();
+  const bool has_failure = HasFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_failure);
+}
+
+// A wrapper for calling HasFailure outside of a test body.
+static bool HasFailureHelper() { return testing::Test::HasFailure(); }
+
+TEST(HasFailureTest, WorksOutsideOfTestBody) {
+  EXPECT_FALSE(HasFailureHelper());
+}
+
+TEST(HasFailureTest, WorksOutsideOfTestBody2) {
+  ADD_FAILURE();
+  const bool has_failure = HasFailureHelper();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_failure);
+}
+
+class TestListener : public EmptyTestEventListener {
+ public:
+  TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {}
+  TestListener(int* on_start_counter, bool* is_destroyed)
+      : on_start_counter_(on_start_counter),
+        is_destroyed_(is_destroyed) {}
+
+  virtual ~TestListener() {
+    if (is_destroyed_)
+      *is_destroyed_ = true;
+  }
+
+ protected:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
+    if (on_start_counter_ != NULL)
+      (*on_start_counter_)++;
+  }
+
+ private:
+  int* on_start_counter_;
+  bool* is_destroyed_;
+};
+
+// Tests the constructor.
+TEST(TestEventListenersTest, ConstructionWorks) {
+  TestEventListeners listeners;
+
+  EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL);
+  EXPECT_TRUE(listeners.default_result_printer() == NULL);
+  EXPECT_TRUE(listeners.default_xml_generator() == NULL);
+}
+
+// Tests that the TestEventListeners destructor deletes all the listeners it
+// owns.
+TEST(TestEventListenersTest, DestructionWorks) {
+  bool default_result_printer_is_destroyed = false;
+  bool default_xml_printer_is_destroyed = false;
+  bool extra_listener_is_destroyed = false;
+  TestListener* default_result_printer = new TestListener(
+      NULL, &default_result_printer_is_destroyed);
+  TestListener* default_xml_printer = new TestListener(
+      NULL, &default_xml_printer_is_destroyed);
+  TestListener* extra_listener = new TestListener(
+      NULL, &extra_listener_is_destroyed);
+
+  {
+    TestEventListeners listeners;
+    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners,
+                                                        default_result_printer);
+    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners,
+                                                       default_xml_printer);
+    listeners.Append(extra_listener);
+  }
+  EXPECT_TRUE(default_result_printer_is_destroyed);
+  EXPECT_TRUE(default_xml_printer_is_destroyed);
+  EXPECT_TRUE(extra_listener_is_destroyed);
+}
+
+// Tests that a listener Append'ed to a TestEventListeners list starts
+// receiving events.
+TEST(TestEventListenersTest, Append) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+  {
+    TestEventListeners listeners;
+    listeners.Append(listener);
+    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+        *UnitTest::GetInstance());
+    EXPECT_EQ(1, on_start_counter);
+  }
+  EXPECT_TRUE(is_destroyed);
+}
+
+// Tests that listeners receive events in the order they were appended to
+// the list, except for *End requests, which must be received in the reverse
+// order.
+class SequenceTestingListener : public EmptyTestEventListener {
+ public:
+  SequenceTestingListener(Vector<String>* vector, const char* id)
+      : vector_(vector), id_(id) {}
+
+ protected:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
+    vector_->PushBack(GetEventDescription("OnTestProgramStart"));
+  }
+
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
+    vector_->PushBack(GetEventDescription("OnTestProgramEnd"));
+  }
+
+  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                                    int /*iteration*/) {
+    vector_->PushBack(GetEventDescription("OnTestIterationStart"));
+  }
+
+  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                                  int /*iteration*/) {
+    vector_->PushBack(GetEventDescription("OnTestIterationEnd"));
+  }
+
+ private:
+  String GetEventDescription(const char* method) {
+    Message message;
+    message << id_ << "." << method;
+    return message.GetString();
+  }
+
+  Vector<String>* vector_;
+  const char* const id_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);
+};
+
+TEST(EventListenerTest, AppendKeepsOrder) {
+  Vector<String> vec;
+  TestEventListeners listeners;
+  listeners.Append(new SequenceTestingListener(&vec, "1st"));
+  listeners.Append(new SequenceTestingListener(&vec, "2nd"));
+  listeners.Append(new SequenceTestingListener(&vec, "3rd"));
+
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+  ASSERT_EQ(3, vec.size());
+  EXPECT_STREQ("1st.OnTestProgramStart", vec.GetElement(0).c_str());
+  EXPECT_STREQ("2nd.OnTestProgramStart", vec.GetElement(1).c_str());
+  EXPECT_STREQ("3rd.OnTestProgramStart", vec.GetElement(2).c_str());
+
+  vec.Clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
+      *UnitTest::GetInstance());
+  ASSERT_EQ(3, vec.size());
+  EXPECT_STREQ("3rd.OnTestProgramEnd", vec.GetElement(0).c_str());
+  EXPECT_STREQ("2nd.OnTestProgramEnd", vec.GetElement(1).c_str());
+  EXPECT_STREQ("1st.OnTestProgramEnd", vec.GetElement(2).c_str());
+
+  vec.Clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
+      *UnitTest::GetInstance(), 0);
+  ASSERT_EQ(3, vec.size());
+  EXPECT_STREQ("1st.OnTestIterationStart", vec.GetElement(0).c_str());
+  EXPECT_STREQ("2nd.OnTestIterationStart", vec.GetElement(1).c_str());
+  EXPECT_STREQ("3rd.OnTestIterationStart", vec.GetElement(2).c_str());
+
+  vec.Clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
+      *UnitTest::GetInstance(), 0);
+  ASSERT_EQ(3, vec.size());
+  EXPECT_STREQ("3rd.OnTestIterationEnd", vec.GetElement(0).c_str());
+  EXPECT_STREQ("2nd.OnTestIterationEnd", vec.GetElement(1).c_str());
+  EXPECT_STREQ("1st.OnTestIterationEnd", vec.GetElement(2).c_str());
+}
+
+// Tests that a listener removed from a TestEventListeners list stops receiving
+// events and is not deleted when the list is destroyed.
+TEST(TestEventListenersTest, Release) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  // Although Append passes the ownership of this object to the list,
+  // the following calls release it, and we need to delete it before the
+  // test ends.
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+  {
+    TestEventListeners listeners;
+    listeners.Append(listener);
+    EXPECT_EQ(listener, listeners.Release(listener));
+    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+        *UnitTest::GetInstance());
+    EXPECT_TRUE(listeners.Release(listener) == NULL);
+  }
+  EXPECT_EQ(0, on_start_counter);
+  EXPECT_FALSE(is_destroyed);
+  delete listener;
+}
+
+// Tests that no events are forwarded when event forwarding is disabled.
+TEST(EventListenerTest, SuppressEventForwarding) {
+  int on_start_counter = 0;
+  TestListener* listener = new TestListener(&on_start_counter, NULL);
+
+  TestEventListeners listeners;
+  listeners.Append(listener);
+  ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
+  TestEventListenersAccessor::SuppressEventForwarding(&listeners);
+  ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+  EXPECT_EQ(0, on_start_counter);
+}
+
+// Tests that events generated by Google Test are not forwarded in
+// death test subprocesses.
+TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) {
+  EXPECT_DEATH_IF_SUPPORTED({
+      GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
+          *GetUnitTestImpl()->listeners())) << "expected failure";},
+      "expected failure");
+}
+
+// Tests that a listener installed via SetDefaultResultPrinter() starts
+// receiving events and is returned via default_result_printer() and that
+// the previous default_result_printer is removed from the list and deleted.
+TEST(EventListenerTest, default_result_printer) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+
+  TestEventListeners listeners;
+  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
+
+  EXPECT_EQ(listener, listeners.default_result_printer());
+
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+
+  EXPECT_EQ(1, on_start_counter);
+
+  // Replacing default_result_printer with something else should remove it
+  // from the list and destroy it.
+  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL);
+
+  EXPECT_TRUE(listeners.default_result_printer() == NULL);
+  EXPECT_TRUE(is_destroyed);
+
+  // After broadcasting an event the counter is still the same, indicating
+  // the listener is not in the list anymore.
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+  EXPECT_EQ(1, on_start_counter);
+}
+
+// Tests that the default_result_printer listener stops receiving events
+// when removed via Release and that is not owned by the list anymore.
+TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  // Although Append passes the ownership of this object to the list,
+  // the following calls release it, and we need to delete it before the
+  // test ends.
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+  {
+    TestEventListeners listeners;
+    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
+
+    EXPECT_EQ(listener, listeners.Release(listener));
+    EXPECT_TRUE(listeners.default_result_printer() == NULL);
+    EXPECT_FALSE(is_destroyed);
+
+    // Broadcasting events now should not affect default_result_printer.
+    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+        *UnitTest::GetInstance());
+    EXPECT_EQ(0, on_start_counter);
+  }
+  // Destroying the list should not affect the listener now, too.
+  EXPECT_FALSE(is_destroyed);
+  delete listener;
+}
+
+// Tests that a listener installed via SetDefaultXmlGenerator() starts
+// receiving events and is returned via default_xml_generator() and that
+// the previous default_xml_generator is removed from the list and deleted.
+TEST(EventListenerTest, default_xml_generator) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+
+  TestEventListeners listeners;
+  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
+
+  EXPECT_EQ(listener, listeners.default_xml_generator());
+
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+
+  EXPECT_EQ(1, on_start_counter);
+
+  // Replacing default_xml_generator with something else should remove it
+  // from the list and destroy it.
+  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL);
+
+  EXPECT_TRUE(listeners.default_xml_generator() == NULL);
+  EXPECT_TRUE(is_destroyed);
+
+  // After broadcasting an event the counter is still the same, indicating
+  // the listener is not in the list anymore.
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+  EXPECT_EQ(1, on_start_counter);
+}
+
+// Tests that the default_xml_generator listener stops receiving events
+// when removed via Release and that is not owned by the list anymore.
+TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  // Although Append passes the ownership of this object to the list,
+  // the following calls release it, and we need to delete it before the
+  // test ends.
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+  {
+    TestEventListeners listeners;
+    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
+
+    EXPECT_EQ(listener, listeners.Release(listener));
+    EXPECT_TRUE(listeners.default_xml_generator() == NULL);
+    EXPECT_FALSE(is_destroyed);
+
+    // Broadcasting events now should not affect default_xml_generator.
+    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+        *UnitTest::GetInstance());
+    EXPECT_EQ(0, on_start_counter);
+  }
+  // Destroying the list should not affect the listener now, too.
+  EXPECT_FALSE(is_destroyed);
+  delete listener;
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_outfile1_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_outfile1_test_.cc
index 77800828..664baad2 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_outfile1_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_outfile1_test_.cc
@@ -1,49 +1,49 @@
-// Copyright 2008, 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: [email protected] (Keith Ray)

-//

-// gtest_xml_outfile1_test_ writes some xml via TestProperty used by

-// gtest_xml_outfiles_test.py

-

-#include <gtest/gtest.h>

-

-class PropertyOne : public testing::Test {

- protected:

-  virtual void SetUp() {

-    RecordProperty("SetUpProp", 1);

-  }

-  virtual void TearDown() {

-    RecordProperty("TearDownProp", 1);

-  }

-};

-

-TEST_F(PropertyOne, TestSomeProperties) {

-  RecordProperty("TestSomeProperty", 1);

-}

+// Copyright 2008, 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: [email protected] (Keith Ray)
+//
+// gtest_xml_outfile1_test_ writes some xml via TestProperty used by
+// gtest_xml_outfiles_test.py
+
+#include <gtest/gtest.h>
+
+class PropertyOne : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    RecordProperty("SetUpProp", 1);
+  }
+  virtual void TearDown() {
+    RecordProperty("TearDownProp", 1);
+  }
+};
+
+TEST_F(PropertyOne, TestSomeProperties) {
+  RecordProperty("TestSomeProperty", 1);
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_outfile2_test_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_outfile2_test_.cc
index 1efe6c67..3411a3d3 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_outfile2_test_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_outfile2_test_.cc
@@ -1,49 +1,49 @@
-// Copyright 2008, 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: [email protected] (Keith Ray)

-//

-// gtest_xml_outfile2_test_ writes some xml via TestProperty used by

-// gtest_xml_outfiles_test.py

-

-#include <gtest/gtest.h>

-

-class PropertyTwo : public testing::Test {

- protected:

-  virtual void SetUp() {

-    RecordProperty("SetUpProp", 2);

-  }

-  virtual void TearDown() {

-    RecordProperty("TearDownProp", 2);

-  }

-};

-

-TEST_F(PropertyTwo, TestSomeProperties) {

-  RecordProperty("TestSomeProperty", 2);

-}

+// Copyright 2008, 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: [email protected] (Keith Ray)
+//
+// gtest_xml_outfile2_test_ writes some xml via TestProperty used by
+// gtest_xml_outfiles_test.py
+
+#include <gtest/gtest.h>
+
+class PropertyTwo : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    RecordProperty("SetUpProp", 2);
+  }
+  virtual void TearDown() {
+    RecordProperty("TearDownProp", 2);
+  }
+};
+
+TEST_F(PropertyTwo, TestSomeProperties) {
+  RecordProperty("TestSomeProperty", 2);
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_output_unittest_.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_output_unittest_.cc
index bd53a22a..fc07ef46 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_output_unittest_.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/gtest_xml_output_unittest_.cc
@@ -1,145 +1,145 @@
-// Copyright 2006, 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: [email protected] (Sean Mcafee)

-

-// Unit test for Google Test XML output.

-//

-// A user can specify XML output in a Google Test program to run via

-// either the GTEST_OUTPUT environment variable or the --gtest_output

-// flag.  This is used for testing such functionality.

-//

-// This program will be invoked from a Python unit test.  Don't run it

-// directly.

-

-#include <gtest/gtest.h>

-

-using ::testing::InitGoogleTest;

-using ::testing::TestEventListeners;

-using ::testing::UnitTest;

-

-class SuccessfulTest : public testing::Test {

-};

-

-TEST_F(SuccessfulTest, Succeeds) {

-  SUCCEED() << "This is a success.";

-  ASSERT_EQ(1, 1);

-}

-

-class FailedTest : public testing::Test {

-};

-

-TEST_F(FailedTest, Fails) {

-  ASSERT_EQ(1, 2);

-}

-

-class DisabledTest : public testing::Test {

-};

-

-TEST_F(DisabledTest, DISABLED_test_not_run) {

-  FAIL() << "Unexpected failure: Disabled test should not be run";

-}

-

-TEST(MixedResultTest, Succeeds) {

-  EXPECT_EQ(1, 1);

-  ASSERT_EQ(1, 1);

-}

-

-TEST(MixedResultTest, Fails) {

-  EXPECT_EQ(1, 2);

-  ASSERT_EQ(2, 3);

-}

-

-TEST(MixedResultTest, DISABLED_test) {

-  FAIL() << "Unexpected failure: Disabled test should not be run";

-}

-

-TEST(XmlQuotingTest, OutputsCData) {

-  FAIL() << "XML output: "

-            "<?xml encoding=\"utf-8\"><top><![CDATA[cdata text]]></top>";

-}

-

-// Helps to test that invalid characters produced by test code do not make

-// it into the XML file.

-TEST(InvalidCharactersTest, InvalidCharactersInMessage) {

-  FAIL() << "Invalid characters in brackets [\x1\x2]";

-}

-

-class PropertyRecordingTest : public testing::Test {

-};

-

-TEST_F(PropertyRecordingTest, OneProperty) {

-  RecordProperty("key_1", "1");

-}

-

-TEST_F(PropertyRecordingTest, IntValuedProperty) {

-  RecordProperty("key_int", 1);

-}

-

-TEST_F(PropertyRecordingTest, ThreeProperties) {

-  RecordProperty("key_1", "1");

-  RecordProperty("key_2", "2");

-  RecordProperty("key_3", "3");

-}

-

-TEST_F(PropertyRecordingTest, TwoValuesForOneKeyUsesLastValue) {

-  RecordProperty("key_1", "1");

-  RecordProperty("key_1", "2");

-}

-

-TEST(NoFixtureTest, RecordProperty) {

-  RecordProperty("key", "1");

-}

-

-void ExternalUtilityThatCallsRecordProperty(const char* key, int value) {

-  testing::Test::RecordProperty(key, value);

-}

-

-void ExternalUtilityThatCallsRecordProperty(const char* key,

-                                            const char* value) {

-  testing::Test::RecordProperty(key, value);

-}

-

-TEST(NoFixtureTest, ExternalUtilityThatCallsRecordIntValuedProperty) {

-  ExternalUtilityThatCallsRecordProperty("key_for_utility_int", 1);

-}

-

-TEST(NoFixtureTest, ExternalUtilityThatCallsRecordStringValuedProperty) {

-  ExternalUtilityThatCallsRecordProperty("key_for_utility_string", "1");

-}

-

-int main(int argc, char** argv) {

-  InitGoogleTest(&argc, argv);

-

-  if (argc > 1 && strcmp(argv[1], "--shut_down_xml") == 0) {

-    TestEventListeners& listeners = UnitTest::GetInstance()->listeners();

-    delete listeners.Release(listeners.default_xml_generator());

-  }

-  return RUN_ALL_TESTS();

-}

+// Copyright 2006, 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: [email protected] (Sean Mcafee)
+
+// Unit test for Google Test XML output.
+//
+// A user can specify XML output in a Google Test program to run via
+// either the GTEST_OUTPUT environment variable or the --gtest_output
+// flag.  This is used for testing such functionality.
+//
+// This program will be invoked from a Python unit test.  Don't run it
+// directly.
+
+#include <gtest/gtest.h>
+
+using ::testing::InitGoogleTest;
+using ::testing::TestEventListeners;
+using ::testing::UnitTest;
+
+class SuccessfulTest : public testing::Test {
+};
+
+TEST_F(SuccessfulTest, Succeeds) {
+  SUCCEED() << "This is a success.";
+  ASSERT_EQ(1, 1);
+}
+
+class FailedTest : public testing::Test {
+};
+
+TEST_F(FailedTest, Fails) {
+  ASSERT_EQ(1, 2);
+}
+
+class DisabledTest : public testing::Test {
+};
+
+TEST_F(DisabledTest, DISABLED_test_not_run) {
+  FAIL() << "Unexpected failure: Disabled test should not be run";
+}
+
+TEST(MixedResultTest, Succeeds) {
+  EXPECT_EQ(1, 1);
+  ASSERT_EQ(1, 1);
+}
+
+TEST(MixedResultTest, Fails) {
+  EXPECT_EQ(1, 2);
+  ASSERT_EQ(2, 3);
+}
+
+TEST(MixedResultTest, DISABLED_test) {
+  FAIL() << "Unexpected failure: Disabled test should not be run";
+}
+
+TEST(XmlQuotingTest, OutputsCData) {
+  FAIL() << "XML output: "
+            "<?xml encoding=\"utf-8\"><top><![CDATA[cdata text]]></top>";
+}
+
+// Helps to test that invalid characters produced by test code do not make
+// it into the XML file.
+TEST(InvalidCharactersTest, InvalidCharactersInMessage) {
+  FAIL() << "Invalid characters in brackets [\x1\x2]";
+}
+
+class PropertyRecordingTest : public testing::Test {
+};
+
+TEST_F(PropertyRecordingTest, OneProperty) {
+  RecordProperty("key_1", "1");
+}
+
+TEST_F(PropertyRecordingTest, IntValuedProperty) {
+  RecordProperty("key_int", 1);
+}
+
+TEST_F(PropertyRecordingTest, ThreeProperties) {
+  RecordProperty("key_1", "1");
+  RecordProperty("key_2", "2");
+  RecordProperty("key_3", "3");
+}
+
+TEST_F(PropertyRecordingTest, TwoValuesForOneKeyUsesLastValue) {
+  RecordProperty("key_1", "1");
+  RecordProperty("key_1", "2");
+}
+
+TEST(NoFixtureTest, RecordProperty) {
+  RecordProperty("key", "1");
+}
+
+void ExternalUtilityThatCallsRecordProperty(const char* key, int value) {
+  testing::Test::RecordProperty(key, value);
+}
+
+void ExternalUtilityThatCallsRecordProperty(const char* key,
+                                            const char* value) {
+  testing::Test::RecordProperty(key, value);
+}
+
+TEST(NoFixtureTest, ExternalUtilityThatCallsRecordIntValuedProperty) {
+  ExternalUtilityThatCallsRecordProperty("key_for_utility_int", 1);
+}
+
+TEST(NoFixtureTest, ExternalUtilityThatCallsRecordStringValuedProperty) {
+  ExternalUtilityThatCallsRecordProperty("key_for_utility_string", "1");
+}
+
+int main(int argc, char** argv) {
+  InitGoogleTest(&argc, argv);
+
+  if (argc > 1 && strcmp(argv[1], "--shut_down_xml") == 0) {
+    TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
+    delete listeners.Release(listeners.default_xml_generator());
+  }
+  return RUN_ALL_TESTS();
+}
diff --git a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/production.cc b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/production.cc
index dd80aa91..8b8a40b4 100644
--- a/sp/src/thirdparty/protobuf-2.3.0/gtest/test/production.cc
+++ b/sp/src/thirdparty/protobuf-2.3.0/gtest/test/production.cc
@@ -1,36 +1,36 @@
-// Copyright 2006, 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: [email protected] (Zhanyong Wan)

-//

-// This is part of the unit test for include/gtest/gtest_prod.h.

-

-#include "production.h"

-

-PrivateCode::PrivateCode() : x_(0) {}

+// Copyright 2006, 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: [email protected] (Zhanyong Wan)
+//
+// This is part of the unit test for include/gtest/gtest_prod.h.
+
+#include "production.h"
+
+PrivateCode::PrivateCode() : x_(0) {}