Normalize line endings

59 files changed, 19523 insertions, 19523 deletions

diff --git a/gtest-1.6.0/test/gtest_break_on_failure_unittest.py b/gtest-1.6.0/test/gtest_break_on_failure_unittest.py
index d034c0a..c819183 100755
--- a/gtest-1.6.0/test/gtest_break_on_failure_unittest.py
+++ b/gtest-1.6.0/test/gtest_break_on_failure_unittest.py
@@ -1,218 +1,218 @@
-#!/usr/bin/env python

-#

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

-

-"""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 script tests such functionality

-by invoking gtest_break_on_failure_unittest_ (a program written with

-Google Test) with different environments and command line flags.

-"""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import gtest_test_utils

-import os

-import sys

-

-

-# Constants.

-

-IS_WINDOWS = os.name == 'nt'

-

-# The environment variable for enabling/disabling the break-on-failure mode.

-BREAK_ON_FAILURE_ENV_VAR = 'GTEST_BREAK_ON_FAILURE'

-

-# The command line flag for enabling/disabling the break-on-failure mode.

-BREAK_ON_FAILURE_FLAG = 'gtest_break_on_failure'

-

-# The environment variable for enabling/disabling the throw-on-failure mode.

-THROW_ON_FAILURE_ENV_VAR = 'GTEST_THROW_ON_FAILURE'

-

-# The environment variable for enabling/disabling the catch-exceptions mode.

-CATCH_EXCEPTIONS_ENV_VAR = 'GTEST_CATCH_EXCEPTIONS'

-

-# Path to the gtest_break_on_failure_unittest_ program.

-EXE_PATH = gtest_test_utils.GetTestExecutablePath(

-    'gtest_break_on_failure_unittest_')

-

-

-# Utilities.

-

-

-environ = os.environ.copy()

-

-

-def SetEnvVar(env_var, value):

-  """Sets an environment variable to a given value; unsets it when the

-  given value is None.

-  """

-

-  if value is not None:

-    environ[env_var] = value

-  elif env_var in environ:

-    del environ[env_var]

-

-

-def Run(command):

-  """Runs a command; returns 1 if it was killed by a signal, or 0 otherwise."""

-

-  p = gtest_test_utils.Subprocess(command, env=environ)

-  if p.terminated_by_signal:

-    return 1

-  else:

-    return 0

-

-

-# The tests.

-

-

-class GTestBreakOnFailureUnitTest(gtest_test_utils.TestCase):

-  """Tests using the GTEST_BREAK_ON_FAILURE environment variable or

-  the --gtest_break_on_failure flag to turn assertion failures into

-  segmentation faults.

-  """

-

-  def RunAndVerify(self, env_var_value, flag_value, expect_seg_fault):

-    """Runs gtest_break_on_failure_unittest_ and verifies that it does

-    (or does not) have a seg-fault.

-

-    Args:

-      env_var_value:    value of the GTEST_BREAK_ON_FAILURE environment

-                        variable; None if the variable should be unset.

-      flag_value:       value of the --gtest_break_on_failure flag;

-                        None if the flag should not be present.

-      expect_seg_fault: 1 if the program is expected to generate a seg-fault;

-                        0 otherwise.

-    """

-

-    SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, env_var_value)

-

-    if env_var_value is None:

-      env_var_value_msg = ' is not set'

-    else:

-      env_var_value_msg = '=' + env_var_value

-

-    if flag_value is None:

-      flag = ''

-    elif flag_value == '0':

-      flag = '--%s=0' % BREAK_ON_FAILURE_FLAG

-    else:

-      flag = '--%s' % BREAK_ON_FAILURE_FLAG

-

-    command = [EXE_PATH]

-    if flag:

-      command.append(flag)

-

-    if expect_seg_fault:

-      should_or_not = 'should'

-    else:

-      should_or_not = 'should not'

-

-    has_seg_fault = Run(command)

-

-    SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, None)

-

-    msg = ('when %s%s, an assertion failure in "%s" %s cause a seg-fault.' %

-           (BREAK_ON_FAILURE_ENV_VAR, env_var_value_msg, ' '.join(command),

-            should_or_not))

-    self.assert_(has_seg_fault == expect_seg_fault, msg)

-

-  def testDefaultBehavior(self):

-    """Tests the behavior of the default mode."""

-

-    self.RunAndVerify(env_var_value=None,

-                      flag_value=None,

-                      expect_seg_fault=0)

-

-  def testEnvVar(self):

-    """Tests using the GTEST_BREAK_ON_FAILURE environment variable."""

-

-    self.RunAndVerify(env_var_value='0',

-                      flag_value=None,

-                      expect_seg_fault=0)

-    self.RunAndVerify(env_var_value='1',

-                      flag_value=None,

-                      expect_seg_fault=1)

-

-  def testFlag(self):

-    """Tests using the --gtest_break_on_failure flag."""

-

-    self.RunAndVerify(env_var_value=None,

-                      flag_value='0',

-                      expect_seg_fault=0)

-    self.RunAndVerify(env_var_value=None,

-                      flag_value='1',

-                      expect_seg_fault=1)

-

-  def testFlagOverridesEnvVar(self):

-    """Tests that the flag overrides the environment variable."""

-

-    self.RunAndVerify(env_var_value='0',

-                      flag_value='0',

-                      expect_seg_fault=0)

-    self.RunAndVerify(env_var_value='0',

-                      flag_value='1',

-                      expect_seg_fault=1)

-    self.RunAndVerify(env_var_value='1',

-                      flag_value='0',

-                      expect_seg_fault=0)

-    self.RunAndVerify(env_var_value='1',

-                      flag_value='1',

-                      expect_seg_fault=1)

-

-  def testBreakOnFailureOverridesThrowOnFailure(self):

-    """Tests that gtest_break_on_failure overrides gtest_throw_on_failure."""

-

-    SetEnvVar(THROW_ON_FAILURE_ENV_VAR, '1')

-    try:

-      self.RunAndVerify(env_var_value=None,

-                        flag_value='1',

-                        expect_seg_fault=1)

-    finally:

-      SetEnvVar(THROW_ON_FAILURE_ENV_VAR, None)

-

-  if IS_WINDOWS:

-    def testCatchExceptionsDoesNotInterfere(self):

-      """Tests that gtest_catch_exceptions doesn't interfere."""

-

-      SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, '1')

-      try:

-        self.RunAndVerify(env_var_value='1',

-                          flag_value='1',

-                          expect_seg_fault=1)

-      finally:

-        SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, None)

-

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""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 script tests such functionality
+by invoking gtest_break_on_failure_unittest_ (a program written with
+Google Test) with different environments and command line flags.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import gtest_test_utils
+import os
+import sys
+
+
+# Constants.
+
+IS_WINDOWS = os.name == 'nt'
+
+# The environment variable for enabling/disabling the break-on-failure mode.
+BREAK_ON_FAILURE_ENV_VAR = 'GTEST_BREAK_ON_FAILURE'
+
+# The command line flag for enabling/disabling the break-on-failure mode.
+BREAK_ON_FAILURE_FLAG = 'gtest_break_on_failure'
+
+# The environment variable for enabling/disabling the throw-on-failure mode.
+THROW_ON_FAILURE_ENV_VAR = 'GTEST_THROW_ON_FAILURE'
+
+# The environment variable for enabling/disabling the catch-exceptions mode.
+CATCH_EXCEPTIONS_ENV_VAR = 'GTEST_CATCH_EXCEPTIONS'
+
+# Path to the gtest_break_on_failure_unittest_ program.
+EXE_PATH = gtest_test_utils.GetTestExecutablePath(
+    'gtest_break_on_failure_unittest_')
+
+
+# Utilities.
+
+
+environ = os.environ.copy()
+
+
+def SetEnvVar(env_var, value):
+  """Sets an environment variable to a given value; unsets it when the
+  given value is None.
+  """
+
+  if value is not None:
+    environ[env_var] = value
+  elif env_var in environ:
+    del environ[env_var]
+
+
+def Run(command):
+  """Runs a command; returns 1 if it was killed by a signal, or 0 otherwise."""
+
+  p = gtest_test_utils.Subprocess(command, env=environ)
+  if p.terminated_by_signal:
+    return 1
+  else:
+    return 0
+
+
+# The tests.
+
+
+class GTestBreakOnFailureUnitTest(gtest_test_utils.TestCase):
+  """Tests using the GTEST_BREAK_ON_FAILURE environment variable or
+  the --gtest_break_on_failure flag to turn assertion failures into
+  segmentation faults.
+  """
+
+  def RunAndVerify(self, env_var_value, flag_value, expect_seg_fault):
+    """Runs gtest_break_on_failure_unittest_ and verifies that it does
+    (or does not) have a seg-fault.
+
+    Args:
+      env_var_value:    value of the GTEST_BREAK_ON_FAILURE environment
+                        variable; None if the variable should be unset.
+      flag_value:       value of the --gtest_break_on_failure flag;
+                        None if the flag should not be present.
+      expect_seg_fault: 1 if the program is expected to generate a seg-fault;
+                        0 otherwise.
+    """
+
+    SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, env_var_value)
+
+    if env_var_value is None:
+      env_var_value_msg = ' is not set'
+    else:
+      env_var_value_msg = '=' + env_var_value
+
+    if flag_value is None:
+      flag = ''
+    elif flag_value == '0':
+      flag = '--%s=0' % BREAK_ON_FAILURE_FLAG
+    else:
+      flag = '--%s' % BREAK_ON_FAILURE_FLAG
+
+    command = [EXE_PATH]
+    if flag:
+      command.append(flag)
+
+    if expect_seg_fault:
+      should_or_not = 'should'
+    else:
+      should_or_not = 'should not'
+
+    has_seg_fault = Run(command)
+
+    SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, None)
+
+    msg = ('when %s%s, an assertion failure in "%s" %s cause a seg-fault.' %
+           (BREAK_ON_FAILURE_ENV_VAR, env_var_value_msg, ' '.join(command),
+            should_or_not))
+    self.assert_(has_seg_fault == expect_seg_fault, msg)
+
+  def testDefaultBehavior(self):
+    """Tests the behavior of the default mode."""
+
+    self.RunAndVerify(env_var_value=None,
+                      flag_value=None,
+                      expect_seg_fault=0)
+
+  def testEnvVar(self):
+    """Tests using the GTEST_BREAK_ON_FAILURE environment variable."""
+
+    self.RunAndVerify(env_var_value='0',
+                      flag_value=None,
+                      expect_seg_fault=0)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value=None,
+                      expect_seg_fault=1)
+
+  def testFlag(self):
+    """Tests using the --gtest_break_on_failure flag."""
+
+    self.RunAndVerify(env_var_value=None,
+                      flag_value='0',
+                      expect_seg_fault=0)
+    self.RunAndVerify(env_var_value=None,
+                      flag_value='1',
+                      expect_seg_fault=1)
+
+  def testFlagOverridesEnvVar(self):
+    """Tests that the flag overrides the environment variable."""
+
+    self.RunAndVerify(env_var_value='0',
+                      flag_value='0',
+                      expect_seg_fault=0)
+    self.RunAndVerify(env_var_value='0',
+                      flag_value='1',
+                      expect_seg_fault=1)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value='0',
+                      expect_seg_fault=0)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value='1',
+                      expect_seg_fault=1)
+
+  def testBreakOnFailureOverridesThrowOnFailure(self):
+    """Tests that gtest_break_on_failure overrides gtest_throw_on_failure."""
+
+    SetEnvVar(THROW_ON_FAILURE_ENV_VAR, '1')
+    try:
+      self.RunAndVerify(env_var_value=None,
+                        flag_value='1',
+                        expect_seg_fault=1)
+    finally:
+      SetEnvVar(THROW_ON_FAILURE_ENV_VAR, None)
+
+  if IS_WINDOWS:
+    def testCatchExceptionsDoesNotInterfere(self):
+      """Tests that gtest_catch_exceptions doesn't interfere."""
+
+      SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, '1')
+      try:
+        self.RunAndVerify(env_var_value='1',
+                          flag_value='1',
+                          expect_seg_fault=1)
+      finally:
+        SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, None)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_break_on_failure_unittest_.cc b/gtest-1.6.0/test/gtest_break_on_failure_unittest_.cc
index 98be0e5..dd07478 100644
--- a/gtest-1.6.0/test/gtest_break_on_failure_unittest_.cc
+++ b/gtest-1.6.0/test/gtest_break_on_failure_unittest_.cc
@@ -1,88 +1,88 @@
-// 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: wan@google.com (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>

-# include <stdlib.h>

-#endif

-

-namespace {

-

-// A test that's expected to fail.

-TEST(Foo, Bar) {

-  EXPECT_EQ(2, 3);

-}

-

-#if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE

-// On Windows Mobile global exception handlers are not supported.

-LONG WINAPI ExitWithExceptionCode(

-    struct _EXCEPTION_POINTERS* exception_pointers) {

-  exit(exception_pointers->ExceptionRecord->ExceptionCode);

-}

-#endif

-

-}  // 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);

-

-# if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE

-

-  // The default unhandled exception filter does not always exit

-  // with the exception code as exit code - for example it exits with

-  // 0 for EXCEPTION_ACCESS_VIOLATION and 1 for EXCEPTION_BREAKPOINT

-  // if the application is compiled in debug mode. Thus we use our own

-  // filter which always exits with the exception code for unhandled

-  // exceptions.

-  SetUnhandledExceptionFilter(ExitWithExceptionCode);

-

-# endif

-#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: wan@google.com (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>
+# include <stdlib.h>
+#endif
+
+namespace {
+
+// A test that's expected to fail.
+TEST(Foo, Bar) {
+  EXPECT_EQ(2, 3);
+}
+
+#if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
+// On Windows Mobile global exception handlers are not supported.
+LONG WINAPI ExitWithExceptionCode(
+    struct _EXCEPTION_POINTERS* exception_pointers) {
+  exit(exception_pointers->ExceptionRecord->ExceptionCode);
+}
+#endif
+
+}  // 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);
+
+# if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
+
+  // The default unhandled exception filter does not always exit
+  // with the exception code as exit code - for example it exits with
+  // 0 for EXCEPTION_ACCESS_VIOLATION and 1 for EXCEPTION_BREAKPOINT
+  // if the application is compiled in debug mode. Thus we use our own
+  // filter which always exits with the exception code for unhandled
+  // exceptions.
+  SetUnhandledExceptionFilter(ExitWithExceptionCode);
+
+# endif
+#endif
+
+  testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/gtest-1.6.0/test/gtest_catch_exceptions_test.py b/gtest-1.6.0/test/gtest_catch_exceptions_test.py
index 32a398d..7fd7dba 100755
--- a/gtest-1.6.0/test/gtest_catch_exceptions_test.py
+++ b/gtest-1.6.0/test/gtest_catch_exceptions_test.py
@@ -1,220 +1,220 @@
-#!/usr/bin/env python

-#

-# Copyright 2010 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 Google Test's exception catching behavior.

-

-This script invokes gtest_catch_exceptions_test_ and

-gtest_catch_exceptions_ex_test_ (programs written with

-Google Test) and verifies their output.

-"""

-

-__author__ = 'vladl@google.com (Vlad Losev)'

-

-import os

-

-import gtest_test_utils

-

-# Constants.

-FLAG_PREFIX = '--gtest_'

-LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'

-NO_CATCH_EXCEPTIONS_FLAG = FLAG_PREFIX + 'catch_exceptions=0'

-FILTER_FLAG = FLAG_PREFIX + 'filter'

-

-# Path to the gtest_catch_exceptions_ex_test_ binary, compiled with

-# exceptions enabled.

-EX_EXE_PATH = gtest_test_utils.GetTestExecutablePath(

-    'gtest_catch_exceptions_ex_test_')

-

-# Path to the gtest_catch_exceptions_test_ binary, compiled with

-# exceptions disabled.

-EXE_PATH = gtest_test_utils.GetTestExecutablePath(

-    'gtest_catch_exceptions_no_ex_test_')

-

-TEST_LIST = gtest_test_utils.Subprocess([EXE_PATH, LIST_TESTS_FLAG]).output

-

-SUPPORTS_SEH_EXCEPTIONS = 'ThrowsSehException' in TEST_LIST

-

-if SUPPORTS_SEH_EXCEPTIONS:

-  BINARY_OUTPUT = gtest_test_utils.Subprocess([EXE_PATH]).output

-

-EX_BINARY_OUTPUT = gtest_test_utils.Subprocess([EX_EXE_PATH]).output

-

-# The tests.

-if SUPPORTS_SEH_EXCEPTIONS:

-  # pylint:disable-msg=C6302

-  class CatchSehExceptionsTest(gtest_test_utils.TestCase):

-    """Tests exception-catching behavior."""

-

-

-    def TestSehExceptions(self, test_output):

-      self.assert_('SEH exception with code 0x2a thrown '

-                   'in the test fixture\'s constructor'

-                   in test_output)

-      self.assert_('SEH exception with code 0x2a thrown '

-                   'in the test fixture\'s destructor'

-                   in test_output)

-      self.assert_('SEH exception with code 0x2a thrown in SetUpTestCase()'

-                   in test_output)

-      self.assert_('SEH exception with code 0x2a thrown in TearDownTestCase()'

-                   in test_output)

-      self.assert_('SEH exception with code 0x2a thrown in SetUp()'

-                   in test_output)

-      self.assert_('SEH exception with code 0x2a thrown in TearDown()'

-                   in test_output)

-      self.assert_('SEH exception with code 0x2a thrown in the test body'

-                   in test_output)

-

-    def testCatchesSehExceptionsWithCxxExceptionsEnabled(self):

-      self.TestSehExceptions(EX_BINARY_OUTPUT)

-

-    def testCatchesSehExceptionsWithCxxExceptionsDisabled(self):

-      self.TestSehExceptions(BINARY_OUTPUT)

-

-

-class CatchCxxExceptionsTest(gtest_test_utils.TestCase):

-  """Tests C++ exception-catching behavior.

-

-     Tests in this test case verify that:

-     * C++ exceptions are caught and logged as C++ (not SEH) exceptions

-     * Exception thrown affect the remainder of the test work flow in the

-       expected manner.

-  """

-

-  def testCatchesCxxExceptionsInFixtureConstructor(self):

-    self.assert_('C++ exception with description '

-                 '"Standard C++ exception" thrown '

-                 'in the test fixture\'s constructor'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('unexpected' not in EX_BINARY_OUTPUT,

-                 'This failure belongs in this test only if '

-                 '"CxxExceptionInConstructorTest" (no quotes) '

-                 'appears on the same line as words "called unexpectedly"')

-

-  def testCatchesCxxExceptionsInFixtureDestructor(self):

-    self.assert_('C++ exception with description '

-                 '"Standard C++ exception" thrown '

-                 'in the test fixture\'s destructor'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInDestructorTest::TearDownTestCase() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-

-  def testCatchesCxxExceptionsInSetUpTestCase(self):

-    self.assert_('C++ exception with description "Standard C++ exception"'

-                 ' thrown in SetUpTestCase()'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInConstructorTest::TearDownTestCase() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInSetUpTestCaseTest constructor '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInSetUpTestCaseTest destructor '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInSetUpTestCaseTest::SetUp() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInSetUpTestCaseTest::TearDown() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInSetUpTestCaseTest test body '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-

-  def testCatchesCxxExceptionsInTearDownTestCase(self):

-    self.assert_('C++ exception with description "Standard C++ exception"'

-                 ' thrown in TearDownTestCase()'

-                 in EX_BINARY_OUTPUT)

-

-  def testCatchesCxxExceptionsInSetUp(self):

-    self.assert_('C++ exception with description "Standard C++ exception"'

-                 ' thrown in SetUp()'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInSetUpTest::TearDownTestCase() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInSetUpTest destructor '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInSetUpTest::TearDown() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('unexpected' not in EX_BINARY_OUTPUT,

-                 'This failure belongs in this test only if '

-                 '"CxxExceptionInSetUpTest" (no quotes) '

-                 'appears on the same line as words "called unexpectedly"')

-

-  def testCatchesCxxExceptionsInTearDown(self):

-    self.assert_('C++ exception with description "Standard C++ exception"'

-                 ' thrown in TearDown()'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInTearDownTest::TearDownTestCase() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInTearDownTest destructor '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-

-  def testCatchesCxxExceptionsInTestBody(self):

-    self.assert_('C++ exception with description "Standard C++ exception"'

-                 ' thrown in the test body'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInTestBodyTest::TearDownTestCase() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInTestBodyTest destructor '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-    self.assert_('CxxExceptionInTestBodyTest::TearDown() '

-                 'called as expected.'

-                 in EX_BINARY_OUTPUT)

-

-  def testCatchesNonStdCxxExceptions(self):

-    self.assert_('Unknown C++ exception thrown in the test body'

-                 in EX_BINARY_OUTPUT)

-

-  def testUnhandledCxxExceptionsAbortTheProgram(self):

-    # Filters out SEH exception tests on Windows. Unhandled SEH exceptions

-    # cause tests to show pop-up windows there.

-    FITLER_OUT_SEH_TESTS_FLAG = FILTER_FLAG + '=-*Seh*'

-    # By default, Google Test doesn't catch the exceptions.

-    uncaught_exceptions_ex_binary_output = gtest_test_utils.Subprocess(

-        [EX_EXE_PATH,

-         NO_CATCH_EXCEPTIONS_FLAG,

-         FITLER_OUT_SEH_TESTS_FLAG]).output

-

-    self.assert_('Unhandled C++ exception terminating the program'

-                 in uncaught_exceptions_ex_binary_output)

-    self.assert_('unexpected' not in uncaught_exceptions_ex_binary_output)

-

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# Copyright 2010 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 Google Test's exception catching behavior.
+
+This script invokes gtest_catch_exceptions_test_ and
+gtest_catch_exceptions_ex_test_ (programs written with
+Google Test) and verifies their output.
+"""
+
+__author__ = 'vladl@google.com (Vlad Losev)'
+
+import os
+
+import gtest_test_utils
+
+# Constants.
+FLAG_PREFIX = '--gtest_'
+LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
+NO_CATCH_EXCEPTIONS_FLAG = FLAG_PREFIX + 'catch_exceptions=0'
+FILTER_FLAG = FLAG_PREFIX + 'filter'
+
+# Path to the gtest_catch_exceptions_ex_test_ binary, compiled with
+# exceptions enabled.
+EX_EXE_PATH = gtest_test_utils.GetTestExecutablePath(
+    'gtest_catch_exceptions_ex_test_')
+
+# Path to the gtest_catch_exceptions_test_ binary, compiled with
+# exceptions disabled.
+EXE_PATH = gtest_test_utils.GetTestExecutablePath(
+    'gtest_catch_exceptions_no_ex_test_')
+
+TEST_LIST = gtest_test_utils.Subprocess([EXE_PATH, LIST_TESTS_FLAG]).output
+
+SUPPORTS_SEH_EXCEPTIONS = 'ThrowsSehException' in TEST_LIST
+
+if SUPPORTS_SEH_EXCEPTIONS:
+  BINARY_OUTPUT = gtest_test_utils.Subprocess([EXE_PATH]).output
+
+EX_BINARY_OUTPUT = gtest_test_utils.Subprocess([EX_EXE_PATH]).output
+
+# The tests.
+if SUPPORTS_SEH_EXCEPTIONS:
+  # pylint:disable-msg=C6302
+  class CatchSehExceptionsTest(gtest_test_utils.TestCase):
+    """Tests exception-catching behavior."""
+
+
+    def TestSehExceptions(self, test_output):
+      self.assert_('SEH exception with code 0x2a thrown '
+                   'in the test fixture\'s constructor'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown '
+                   'in the test fixture\'s destructor'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in SetUpTestCase()'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in TearDownTestCase()'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in SetUp()'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in TearDown()'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in the test body'
+                   in test_output)
+
+    def testCatchesSehExceptionsWithCxxExceptionsEnabled(self):
+      self.TestSehExceptions(EX_BINARY_OUTPUT)
+
+    def testCatchesSehExceptionsWithCxxExceptionsDisabled(self):
+      self.TestSehExceptions(BINARY_OUTPUT)
+
+
+class CatchCxxExceptionsTest(gtest_test_utils.TestCase):
+  """Tests C++ exception-catching behavior.
+
+     Tests in this test case verify that:
+     * C++ exceptions are caught and logged as C++ (not SEH) exceptions
+     * Exception thrown affect the remainder of the test work flow in the
+       expected manner.
+  """
+
+  def testCatchesCxxExceptionsInFixtureConstructor(self):
+    self.assert_('C++ exception with description '
+                 '"Standard C++ exception" thrown '
+                 'in the test fixture\'s constructor'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('unexpected' not in EX_BINARY_OUTPUT,
+                 'This failure belongs in this test only if '
+                 '"CxxExceptionInConstructorTest" (no quotes) '
+                 'appears on the same line as words "called unexpectedly"')
+
+  def testCatchesCxxExceptionsInFixtureDestructor(self):
+    self.assert_('C++ exception with description '
+                 '"Standard C++ exception" thrown '
+                 'in the test fixture\'s destructor'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInDestructorTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesCxxExceptionsInSetUpTestCase(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in SetUpTestCase()'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInConstructorTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest constructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest destructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest::SetUp() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest::TearDown() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest test body '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesCxxExceptionsInTearDownTestCase(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in TearDownTestCase()'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesCxxExceptionsInSetUp(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in SetUp()'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTest destructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTest::TearDown() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('unexpected' not in EX_BINARY_OUTPUT,
+                 'This failure belongs in this test only if '
+                 '"CxxExceptionInSetUpTest" (no quotes) '
+                 'appears on the same line as words "called unexpectedly"')
+
+  def testCatchesCxxExceptionsInTearDown(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in TearDown()'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTearDownTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTearDownTest destructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesCxxExceptionsInTestBody(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in the test body'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTestBodyTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTestBodyTest destructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTestBodyTest::TearDown() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesNonStdCxxExceptions(self):
+    self.assert_('Unknown C++ exception thrown in the test body'
+                 in EX_BINARY_OUTPUT)
+
+  def testUnhandledCxxExceptionsAbortTheProgram(self):
+    # Filters out SEH exception tests on Windows. Unhandled SEH exceptions
+    # cause tests to show pop-up windows there.
+    FITLER_OUT_SEH_TESTS_FLAG = FILTER_FLAG + '=-*Seh*'
+    # By default, Google Test doesn't catch the exceptions.
+    uncaught_exceptions_ex_binary_output = gtest_test_utils.Subprocess(
+        [EX_EXE_PATH,
+         NO_CATCH_EXCEPTIONS_FLAG,
+         FITLER_OUT_SEH_TESTS_FLAG]).output
+
+    self.assert_('Unhandled C++ exception terminating the program'
+                 in uncaught_exceptions_ex_binary_output)
+    self.assert_('unexpected' not in uncaught_exceptions_ex_binary_output)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_catch_exceptions_test_.cc b/gtest-1.6.0/test/gtest_catch_exceptions_test_.cc
index d1b58f6..a35103f 100644
--- a/gtest-1.6.0/test/gtest_catch_exceptions_test_.cc
+++ b/gtest-1.6.0/test/gtest_catch_exceptions_test_.cc
@@ -1,308 +1,308 @@
-// Copyright 2010, Google Inc.

-// All rights reserved.

-//

-// Redistribution and use in source and binary forms, with or without

-// modification, are permitted provided that the following conditions are

-// met:

-//

-//     * Redistributions of source code must retain the above copyright

-// notice, this list of conditions and the following disclaimer.

-//     * Redistributions in binary form must reproduce the above

-// copyright notice, this list of conditions and the following disclaimer

-// in the documentation and/or other materials provided with the

-// distribution.

-//     * Neither the name of Google Inc. nor the names of its

-// contributors may be used to endorse or promote products derived from

-// this software without specific prior written permission.

-//

-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-//

-// Author: vladl@google.com (Vlad Losev)

-//

-// Tests for Google Test itself. Tests in this file throw C++ or SEH

-// exceptions, and the output is verified by gtest_catch_exceptions_test.py.

-

-#include "gtest/gtest.h"

-

-#include <stdio.h>  // NOLINT

-#include <stdlib.h>  // For exit().

-

-#if GTEST_HAS_SEH

-# include <windows.h>

-#endif

-

-#if GTEST_HAS_EXCEPTIONS

-# include <exception>  // For set_terminate().

-# include <stdexcept>

-#endif

-

-using testing::Test;

-

-#if GTEST_HAS_SEH

-

-class SehExceptionInConstructorTest : public Test {

- public:

-  SehExceptionInConstructorTest() { RaiseException(42, 0, 0, NULL); }

-};

-

-TEST_F(SehExceptionInConstructorTest, ThrowsExceptionInConstructor) {}

-

-class SehExceptionInDestructorTest : public Test {

- public:

-  ~SehExceptionInDestructorTest() { RaiseException(42, 0, 0, NULL); }

-};

-

-TEST_F(SehExceptionInDestructorTest, ThrowsExceptionInDestructor) {}

-

-class SehExceptionInSetUpTestCaseTest : public Test {

- public:

-  static void SetUpTestCase() { RaiseException(42, 0, 0, NULL); }

-};

-

-TEST_F(SehExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {}

-

-class SehExceptionInTearDownTestCaseTest : public Test {

- public:

-  static void TearDownTestCase() { RaiseException(42, 0, 0, NULL); }

-};

-

-TEST_F(SehExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}

-

-class SehExceptionInSetUpTest : public Test {

- protected:

-  virtual void SetUp() { RaiseException(42, 0, 0, NULL); }

-};

-

-TEST_F(SehExceptionInSetUpTest, ThrowsExceptionInSetUp) {}

-

-class SehExceptionInTearDownTest : public Test {

- protected:

-  virtual void TearDown() { RaiseException(42, 0, 0, NULL); }

-};

-

-TEST_F(SehExceptionInTearDownTest, ThrowsExceptionInTearDown) {}

-

-TEST(SehExceptionTest, ThrowsSehException) {

-  RaiseException(42, 0, 0, NULL);

-}

-

-#endif  // GTEST_HAS_SEH

-

-#if GTEST_HAS_EXCEPTIONS

-

-class CxxExceptionInConstructorTest : public Test {

- public:

-  CxxExceptionInConstructorTest() {

-    // Without this macro VC++ complains about unreachable code at the end of

-    // the constructor.

-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(

-        throw std::runtime_error("Standard C++ exception"));

-  }

-

-  static void TearDownTestCase() {

-    printf("%s",

-           "CxxExceptionInConstructorTest::TearDownTestCase() "

-           "called as expected.\n");

-  }

-

- protected:

-  ~CxxExceptionInConstructorTest() {

-    ADD_FAILURE() << "CxxExceptionInConstructorTest destructor "

-                  << "called unexpectedly.";

-  }

-

-  virtual void SetUp() {

-    ADD_FAILURE() << "CxxExceptionInConstructorTest::SetUp() "

-                  << "called unexpectedly.";

-  }

-

-  virtual void TearDown() {

-    ADD_FAILURE() << "CxxExceptionInConstructorTest::TearDown() "

-                  << "called unexpectedly.";

-  }

-};

-

-TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) {

-  ADD_FAILURE() << "CxxExceptionInConstructorTest test body "

-                << "called unexpectedly.";

-}

-

-class CxxExceptionInDestructorTest : public Test {

- public:

-  static void TearDownTestCase() {

-    printf("%s",

-           "CxxExceptionInDestructorTest::TearDownTestCase() "

-           "called as expected.\n");

-  }

-

- protected:

-  ~CxxExceptionInDestructorTest() {

-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(

-        throw std::runtime_error("Standard C++ exception"));

-  }

-};

-

-TEST_F(CxxExceptionInDestructorTest, ThrowsExceptionInDestructor) {}

-

-class CxxExceptionInSetUpTestCaseTest : public Test {

- public:

-  CxxExceptionInSetUpTestCaseTest() {

-    printf("%s",

-           "CxxExceptionInSetUpTestCaseTest constructor "

-           "called as expected.\n");

-  }

-

-  static void SetUpTestCase() {

-    throw std::runtime_error("Standard C++ exception");

-  }

-

-  static void TearDownTestCase() {

-    printf("%s",

-           "CxxExceptionInSetUpTestCaseTest::TearDownTestCase() "

-           "called as expected.\n");

-  }

-

- protected:

-  ~CxxExceptionInSetUpTestCaseTest() {

-    printf("%s",

-           "CxxExceptionInSetUpTestCaseTest destructor "

-           "called as expected.\n");

-  }

-

-  virtual void SetUp() {

-    printf("%s",

-           "CxxExceptionInSetUpTestCaseTest::SetUp() "

-           "called as expected.\n");

-  }

-

-  virtual void TearDown() {

-    printf("%s",

-           "CxxExceptionInSetUpTestCaseTest::TearDown() "

-           "called as expected.\n");

-  }

-};

-

-TEST_F(CxxExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {

-  printf("%s",

-         "CxxExceptionInSetUpTestCaseTest test body "

-         "called as expected.\n");

-}

-

-class CxxExceptionInTearDownTestCaseTest : public Test {

- public:

-  static void TearDownTestCase() {

-    throw std::runtime_error("Standard C++ exception");

-  }

-};

-

-TEST_F(CxxExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}

-

-class CxxExceptionInSetUpTest : public Test {

- public:

-  static void TearDownTestCase() {

-    printf("%s",

-           "CxxExceptionInSetUpTest::TearDownTestCase() "

-           "called as expected.\n");

-  }

-

- protected:

-  ~CxxExceptionInSetUpTest() {

-    printf("%s",

-           "CxxExceptionInSetUpTest destructor "

-           "called as expected.\n");

-  }

-

-  virtual void SetUp() { throw std::runtime_error("Standard C++ exception"); }

-

-  virtual void TearDown() {

-    printf("%s",

-           "CxxExceptionInSetUpTest::TearDown() "

-           "called as expected.\n");

-  }

-};

-

-TEST_F(CxxExceptionInSetUpTest, ThrowsExceptionInSetUp) {

-  ADD_FAILURE() << "CxxExceptionInSetUpTest test body "

-                << "called unexpectedly.";

-}

-

-class CxxExceptionInTearDownTest : public Test {

- public:

-  static void TearDownTestCase() {

-    printf("%s",

-           "CxxExceptionInTearDownTest::TearDownTestCase() "

-           "called as expected.\n");

-  }

-

- protected:

-  ~CxxExceptionInTearDownTest() {

-    printf("%s",

-           "CxxExceptionInTearDownTest destructor "

-           "called as expected.\n");

-  }

-

-  virtual void TearDown() {

-    throw std::runtime_error("Standard C++ exception");

-  }

-};

-

-TEST_F(CxxExceptionInTearDownTest, ThrowsExceptionInTearDown) {}

-

-class CxxExceptionInTestBodyTest : public Test {

- public:

-  static void TearDownTestCase() {

-    printf("%s",

-           "CxxExceptionInTestBodyTest::TearDownTestCase() "

-           "called as expected.\n");

-  }

-

- protected:

-  ~CxxExceptionInTestBodyTest() {

-    printf("%s",

-           "CxxExceptionInTestBodyTest destructor "

-           "called as expected.\n");

-  }

-

-  virtual void TearDown() {

-    printf("%s",

-           "CxxExceptionInTestBodyTest::TearDown() "

-           "called as expected.\n");

-  }

-};

-

-TEST_F(CxxExceptionInTestBodyTest, ThrowsStdCxxException) {

-  throw std::runtime_error("Standard C++ exception");

-}

-

-TEST(CxxExceptionTest, ThrowsNonStdCxxException) {

-  throw "C-string";

-}

-

-// This terminate handler aborts the program using exit() rather than abort().

-// This avoids showing pop-ups on Windows systems and core dumps on Unix-like

-// ones.

-void TerminateHandler() {

-  fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");

-  fflush(NULL);

-  exit(3);

-}

-

-#endif  // GTEST_HAS_EXCEPTIONS

-

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

-#if GTEST_HAS_EXCEPTIONS

-  std::set_terminate(&TerminateHandler);

-#endif

-  testing::InitGoogleTest(&argc, argv);

-  return RUN_ALL_TESTS();

-}

+// Copyright 2010, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: vladl@google.com (Vlad Losev)
+//
+// Tests for Google Test itself. Tests in this file throw C++ or SEH
+// exceptions, and the output is verified by gtest_catch_exceptions_test.py.
+
+#include "gtest/gtest.h"
+
+#include <stdio.h>  // NOLINT
+#include <stdlib.h>  // For exit().
+
+#if GTEST_HAS_SEH
+# include <windows.h>
+#endif
+
+#if GTEST_HAS_EXCEPTIONS
+# include <exception>  // For set_terminate().
+# include <stdexcept>
+#endif
+
+using testing::Test;
+
+#if GTEST_HAS_SEH
+
+class SehExceptionInConstructorTest : public Test {
+ public:
+  SehExceptionInConstructorTest() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInConstructorTest, ThrowsExceptionInConstructor) {}
+
+class SehExceptionInDestructorTest : public Test {
+ public:
+  ~SehExceptionInDestructorTest() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
+
+class SehExceptionInSetUpTestCaseTest : public Test {
+ public:
+  static void SetUpTestCase() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {}
+
+class SehExceptionInTearDownTestCaseTest : public Test {
+ public:
+  static void TearDownTestCase() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}
+
+class SehExceptionInSetUpTest : public Test {
+ protected:
+  virtual void SetUp() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInSetUpTest, ThrowsExceptionInSetUp) {}
+
+class SehExceptionInTearDownTest : public Test {
+ protected:
+  virtual void TearDown() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
+
+TEST(SehExceptionTest, ThrowsSehException) {
+  RaiseException(42, 0, 0, NULL);
+}
+
+#endif  // GTEST_HAS_SEH
+
+#if GTEST_HAS_EXCEPTIONS
+
+class CxxExceptionInConstructorTest : public Test {
+ public:
+  CxxExceptionInConstructorTest() {
+    // Without this macro VC++ complains about unreachable code at the end of
+    // the constructor.
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        throw std::runtime_error("Standard C++ exception"));
+  }
+
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInConstructorTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInConstructorTest() {
+    ADD_FAILURE() << "CxxExceptionInConstructorTest destructor "
+                  << "called unexpectedly.";
+  }
+
+  virtual void SetUp() {
+    ADD_FAILURE() << "CxxExceptionInConstructorTest::SetUp() "
+                  << "called unexpectedly.";
+  }
+
+  virtual void TearDown() {
+    ADD_FAILURE() << "CxxExceptionInConstructorTest::TearDown() "
+                  << "called unexpectedly.";
+  }
+};
+
+TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) {
+  ADD_FAILURE() << "CxxExceptionInConstructorTest test body "
+                << "called unexpectedly.";
+}
+
+class CxxExceptionInDestructorTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInDestructorTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInDestructorTest() {
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        throw std::runtime_error("Standard C++ exception"));
+  }
+};
+
+TEST_F(CxxExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
+
+class CxxExceptionInSetUpTestCaseTest : public Test {
+ public:
+  CxxExceptionInSetUpTestCaseTest() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest constructor "
+           "called as expected.\n");
+  }
+
+  static void SetUpTestCase() {
+    throw std::runtime_error("Standard C++ exception");
+  }
+
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInSetUpTestCaseTest() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest destructor "
+           "called as expected.\n");
+  }
+
+  virtual void SetUp() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest::SetUp() "
+           "called as expected.\n");
+  }
+
+  virtual void TearDown() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest::TearDown() "
+           "called as expected.\n");
+  }
+};
+
+TEST_F(CxxExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {
+  printf("%s",
+         "CxxExceptionInSetUpTestCaseTest test body "
+         "called as expected.\n");
+}
+
+class CxxExceptionInTearDownTestCaseTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    throw std::runtime_error("Standard C++ exception");
+  }
+};
+
+TEST_F(CxxExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}
+
+class CxxExceptionInSetUpTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInSetUpTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInSetUpTest() {
+    printf("%s",
+           "CxxExceptionInSetUpTest destructor "
+           "called as expected.\n");
+  }
+
+  virtual void SetUp() { throw std::runtime_error("Standard C++ exception"); }
+
+  virtual void TearDown() {
+    printf("%s",
+           "CxxExceptionInSetUpTest::TearDown() "
+           "called as expected.\n");
+  }
+};
+
+TEST_F(CxxExceptionInSetUpTest, ThrowsExceptionInSetUp) {
+  ADD_FAILURE() << "CxxExceptionInSetUpTest test body "
+                << "called unexpectedly.";
+}
+
+class CxxExceptionInTearDownTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInTearDownTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInTearDownTest() {
+    printf("%s",
+           "CxxExceptionInTearDownTest destructor "
+           "called as expected.\n");
+  }
+
+  virtual void TearDown() {
+    throw std::runtime_error("Standard C++ exception");
+  }
+};
+
+TEST_F(CxxExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
+
+class CxxExceptionInTestBodyTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInTestBodyTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInTestBodyTest() {
+    printf("%s",
+           "CxxExceptionInTestBodyTest destructor "
+           "called as expected.\n");
+  }
+
+  virtual void TearDown() {
+    printf("%s",
+           "CxxExceptionInTestBodyTest::TearDown() "
+           "called as expected.\n");
+  }
+};
+
+TEST_F(CxxExceptionInTestBodyTest, ThrowsStdCxxException) {
+  throw std::runtime_error("Standard C++ exception");
+}
+
+TEST(CxxExceptionTest, ThrowsNonStdCxxException) {
+  throw "C-string";
+}
+
+// This terminate handler aborts the program using exit() rather than abort().
+// This avoids showing pop-ups on Windows systems and core dumps on Unix-like
+// ones.
+void TerminateHandler() {
+  fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");
+  fflush(NULL);
+  exit(3);
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+int main(int argc, char** argv) {
+#if GTEST_HAS_EXCEPTIONS
+  std::set_terminate(&TerminateHandler);
+#endif
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/gtest-1.6.0/test/gtest_color_test.py b/gtest-1.6.0/test/gtest_color_test.py
index 8fce245..d02a53e 100755
--- a/gtest-1.6.0/test/gtest_color_test.py
+++ b/gtest-1.6.0/test/gtest_color_test.py
@@ -1,130 +1,130 @@
-#!/usr/bin/env python

-#

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

-

-"""Verifies that Google Test correctly determines whether to use colors."""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import os

-import gtest_test_utils

-

-

-IS_WINDOWS = os.name = 'nt'

-

-COLOR_ENV_VAR = 'GTEST_COLOR'

-COLOR_FLAG = 'gtest_color'

-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_color_test_')

-

-

-def SetEnvVar(env_var, value):

-  """Sets the env variable to 'value'; unsets it when 'value' is None."""

-

-  if value is not None:

-    os.environ[env_var] = value

-  elif env_var in os.environ:

-    del os.environ[env_var]

-

-

-def UsesColor(term, color_env_var, color_flag):

-  """Runs gtest_color_test_ and returns its exit code."""

-

-  SetEnvVar('TERM', term)

-  SetEnvVar(COLOR_ENV_VAR, color_env_var)

-

-  if color_flag is None:

-    args = []

-  else:

-    args = ['--%s=%s' % (COLOR_FLAG, color_flag)]

-  p = gtest_test_utils.Subprocess([COMMAND] + args)

-  return not p.exited or p.exit_code

-

-

-class GTestColorTest(gtest_test_utils.TestCase):

-  def testNoEnvVarNoFlag(self):

-    """Tests the case when there's neither GTEST_COLOR nor --gtest_color."""

-

-    if not IS_WINDOWS:

-      self.assert_(not UsesColor('dumb', None, None))

-      self.assert_(not UsesColor('emacs', None, None))

-      self.assert_(not UsesColor('xterm-mono', None, None))

-      self.assert_(not UsesColor('unknown', None, None))

-      self.assert_(not UsesColor(None, None, None))

-    self.assert_(UsesColor('linux', None, None))

-    self.assert_(UsesColor('cygwin', None, None))

-    self.assert_(UsesColor('xterm', None, None))

-    self.assert_(UsesColor('xterm-color', None, None))

-    self.assert_(UsesColor('xterm-256color', None, None))

-

-  def testFlagOnly(self):

-    """Tests the case when there's --gtest_color but not GTEST_COLOR."""

-

-    self.assert_(not UsesColor('dumb', None, 'no'))

-    self.assert_(not UsesColor('xterm-color', None, 'no'))

-    if not IS_WINDOWS:

-      self.assert_(not UsesColor('emacs', None, 'auto'))

-    self.assert_(UsesColor('xterm', None, 'auto'))

-    self.assert_(UsesColor('dumb', None, 'yes'))

-    self.assert_(UsesColor('xterm', None, 'yes'))

-

-  def testEnvVarOnly(self):

-    """Tests the case when there's GTEST_COLOR but not --gtest_color."""

-

-    self.assert_(not UsesColor('dumb', 'no', None))

-    self.assert_(not UsesColor('xterm-color', 'no', None))

-    if not IS_WINDOWS:

-      self.assert_(not UsesColor('dumb', 'auto', None))

-    self.assert_(UsesColor('xterm-color', 'auto', None))

-    self.assert_(UsesColor('dumb', 'yes', None))

-    self.assert_(UsesColor('xterm-color', 'yes', None))

-

-  def testEnvVarAndFlag(self):

-    """Tests the case when there are both GTEST_COLOR and --gtest_color."""

-

-    self.assert_(not UsesColor('xterm-color', 'no', 'no'))

-    self.assert_(UsesColor('dumb', 'no', 'yes'))

-    self.assert_(UsesColor('xterm-color', 'no', 'auto'))

-

-  def testAliasesOfYesAndNo(self):

-    """Tests using aliases in specifying --gtest_color."""

-

-    self.assert_(UsesColor('dumb', None, 'true'))

-    self.assert_(UsesColor('dumb', None, 'YES'))

-    self.assert_(UsesColor('dumb', None, 'T'))

-    self.assert_(UsesColor('dumb', None, '1'))

-

-    self.assert_(not UsesColor('xterm', None, 'f'))

-    self.assert_(not UsesColor('xterm', None, 'false'))

-    self.assert_(not UsesColor('xterm', None, '0'))

-    self.assert_(not UsesColor('xterm', None, 'unknown'))

-

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Verifies that Google Test correctly determines whether to use colors."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import gtest_test_utils
+
+
+IS_WINDOWS = os.name = 'nt'
+
+COLOR_ENV_VAR = 'GTEST_COLOR'
+COLOR_FLAG = 'gtest_color'
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_color_test_')
+
+
+def SetEnvVar(env_var, value):
+  """Sets the env variable to 'value'; unsets it when 'value' is None."""
+
+  if value is not None:
+    os.environ[env_var] = value
+  elif env_var in os.environ:
+    del os.environ[env_var]
+
+
+def UsesColor(term, color_env_var, color_flag):
+  """Runs gtest_color_test_ and returns its exit code."""
+
+  SetEnvVar('TERM', term)
+  SetEnvVar(COLOR_ENV_VAR, color_env_var)
+
+  if color_flag is None:
+    args = []
+  else:
+    args = ['--%s=%s' % (COLOR_FLAG, color_flag)]
+  p = gtest_test_utils.Subprocess([COMMAND] + args)
+  return not p.exited or p.exit_code
+
+
+class GTestColorTest(gtest_test_utils.TestCase):
+  def testNoEnvVarNoFlag(self):
+    """Tests the case when there's neither GTEST_COLOR nor --gtest_color."""
+
+    if not IS_WINDOWS:
+      self.assert_(not UsesColor('dumb', None, None))
+      self.assert_(not UsesColor('emacs', None, None))
+      self.assert_(not UsesColor('xterm-mono', None, None))
+      self.assert_(not UsesColor('unknown', None, None))
+      self.assert_(not UsesColor(None, None, None))
+    self.assert_(UsesColor('linux', None, None))
+    self.assert_(UsesColor('cygwin', None, None))
+    self.assert_(UsesColor('xterm', None, None))
+    self.assert_(UsesColor('xterm-color', None, None))
+    self.assert_(UsesColor('xterm-256color', None, None))
+
+  def testFlagOnly(self):
+    """Tests the case when there's --gtest_color but not GTEST_COLOR."""
+
+    self.assert_(not UsesColor('dumb', None, 'no'))
+    self.assert_(not UsesColor('xterm-color', None, 'no'))
+    if not IS_WINDOWS:
+      self.assert_(not UsesColor('emacs', None, 'auto'))
+    self.assert_(UsesColor('xterm', None, 'auto'))
+    self.assert_(UsesColor('dumb', None, 'yes'))
+    self.assert_(UsesColor('xterm', None, 'yes'))
+
+  def testEnvVarOnly(self):
+    """Tests the case when there's GTEST_COLOR but not --gtest_color."""
+
+    self.assert_(not UsesColor('dumb', 'no', None))
+    self.assert_(not UsesColor('xterm-color', 'no', None))
+    if not IS_WINDOWS:
+      self.assert_(not UsesColor('dumb', 'auto', None))
+    self.assert_(UsesColor('xterm-color', 'auto', None))
+    self.assert_(UsesColor('dumb', 'yes', None))
+    self.assert_(UsesColor('xterm-color', 'yes', None))
+
+  def testEnvVarAndFlag(self):
+    """Tests the case when there are both GTEST_COLOR and --gtest_color."""
+
+    self.assert_(not UsesColor('xterm-color', 'no', 'no'))
+    self.assert_(UsesColor('dumb', 'no', 'yes'))
+    self.assert_(UsesColor('xterm-color', 'no', 'auto'))
+
+  def testAliasesOfYesAndNo(self):
+    """Tests using aliases in specifying --gtest_color."""
+
+    self.assert_(UsesColor('dumb', None, 'true'))
+    self.assert_(UsesColor('dumb', None, 'YES'))
+    self.assert_(UsesColor('dumb', None, 'T'))
+    self.assert_(UsesColor('dumb', None, '1'))
+
+    self.assert_(not UsesColor('xterm', None, 'f'))
+    self.assert_(not UsesColor('xterm', None, 'false'))
+    self.assert_(not UsesColor('xterm', None, '0'))
+    self.assert_(not UsesColor('xterm', None, 'unknown'))
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_color_test_.cc b/gtest-1.6.0/test/gtest_color_test_.cc
index 9e1b3f5..f61ebb8 100644
--- a/gtest-1.6.0/test/gtest_color_test_.cc
+++ b/gtest-1.6.0/test/gtest_color_test_.cc
@@ -1,71 +1,71 @@
-// 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: wan@google.com (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"

-

-// Indicates that this translation unit is part of Google Test's

-// implementation.  It must come before gtest-internal-inl.h is

-// included, or there will be a compiler error.  This trick is to

-// prevent a user from accidentally including gtest-internal-inl.h in

-// his code.

-#define GTEST_IMPLEMENTATION_ 1

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

-#undef GTEST_IMPLEMENTATION_

-

-using testing::internal::ShouldUseColor;

-

-// 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: wan@google.com (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"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+using testing::internal::ShouldUseColor;
+
+// 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/gtest-1.6.0/test/gtest_env_var_test.py b/gtest-1.6.0/test/gtest_env_var_test.py
index 09589e2..ac24337 100755
--- a/gtest-1.6.0/test/gtest_env_var_test.py
+++ b/gtest-1.6.0/test/gtest_env_var_test.py
@@ -1,103 +1,103 @@
-#!/usr/bin/env python

-#

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

-

-"""Verifies that Google Test correctly parses environment variables."""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import os

-import gtest_test_utils

-

-

-IS_WINDOWS = os.name == 'nt'

-IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'

-

-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_env_var_test_')

-

-environ = os.environ.copy()

-

-

-def AssertEq(expected, actual):

-  if expected != actual:

-    print 'Expected: %s' % (expected,)

-    print '  Actual: %s' % (actual,)

-    raise AssertionError

-

-

-def SetEnvVar(env_var, value):

-  """Sets the env variable to 'value'; unsets it when 'value' is None."""

-

-  if value is not None:

-    environ[env_var] = value

-  elif env_var in environ:

-    del environ[env_var]

-

-

-def GetFlag(flag):

-  """Runs gtest_env_var_test_ and returns its output."""

-

-  args = [COMMAND]

-  if flag is not None:

-    args += [flag]

-  return gtest_test_utils.Subprocess(args, env=environ).output

-

-

-def TestFlag(flag, test_val, default_val):

-  """Verifies that the given flag is affected by the corresponding env var."""

-

-  env_var = 'GTEST_' + flag.upper()

-  SetEnvVar(env_var, test_val)

-  AssertEq(test_val, GetFlag(flag))

-  SetEnvVar(env_var, None)

-  AssertEq(default_val, GetFlag(flag))

-

-

-class GTestEnvVarTest(gtest_test_utils.TestCase):

-  def testEnvVarAffectsFlag(self):

-    """Tests that environment variable should affect the corresponding flag."""

-

-    TestFlag('break_on_failure', '1', '0')

-    TestFlag('color', 'yes', 'auto')

-    TestFlag('filter', 'FooTest.Bar', '*')

-    TestFlag('output', 'xml:tmp/foo.xml', '')

-    TestFlag('print_time', '0', '1')

-    TestFlag('repeat', '999', '1')

-    TestFlag('throw_on_failure', '1', '0')

-    TestFlag('death_test_style', 'threadsafe', 'fast')

-    TestFlag('catch_exceptions', '0', '1')

-

-    if IS_LINUX:

-      TestFlag('death_test_use_fork', '1', '0')

-      TestFlag('stack_trace_depth', '0', '100')

-

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Verifies that Google Test correctly parses environment variables."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import gtest_test_utils
+
+
+IS_WINDOWS = os.name == 'nt'
+IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
+
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_env_var_test_')
+
+environ = os.environ.copy()
+
+
+def AssertEq(expected, actual):
+  if expected != actual:
+    print 'Expected: %s' % (expected,)
+    print '  Actual: %s' % (actual,)
+    raise AssertionError
+
+
+def SetEnvVar(env_var, value):
+  """Sets the env variable to 'value'; unsets it when 'value' is None."""
+
+  if value is not None:
+    environ[env_var] = value
+  elif env_var in environ:
+    del environ[env_var]
+
+
+def GetFlag(flag):
+  """Runs gtest_env_var_test_ and returns its output."""
+
+  args = [COMMAND]
+  if flag is not None:
+    args += [flag]
+  return gtest_test_utils.Subprocess(args, env=environ).output
+
+
+def TestFlag(flag, test_val, default_val):
+  """Verifies that the given flag is affected by the corresponding env var."""
+
+  env_var = 'GTEST_' + flag.upper()
+  SetEnvVar(env_var, test_val)
+  AssertEq(test_val, GetFlag(flag))
+  SetEnvVar(env_var, None)
+  AssertEq(default_val, GetFlag(flag))
+
+
+class GTestEnvVarTest(gtest_test_utils.TestCase):
+  def testEnvVarAffectsFlag(self):
+    """Tests that environment variable should affect the corresponding flag."""
+
+    TestFlag('break_on_failure', '1', '0')
+    TestFlag('color', 'yes', 'auto')
+    TestFlag('filter', 'FooTest.Bar', '*')
+    TestFlag('output', 'xml:tmp/foo.xml', '')
+    TestFlag('print_time', '0', '1')
+    TestFlag('repeat', '999', '1')
+    TestFlag('throw_on_failure', '1', '0')
+    TestFlag('death_test_style', 'threadsafe', 'fast')
+    TestFlag('catch_exceptions', '0', '1')
+
+    if IS_LINUX:
+      TestFlag('death_test_use_fork', '1', '0')
+      TestFlag('stack_trace_depth', '0', '100')
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_env_var_test_.cc b/gtest-1.6.0/test/gtest_env_var_test_.cc
index 0eccddd..539afc9 100644
--- a/gtest-1.6.0/test/gtest_env_var_test_.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (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/gtest-1.6.0/test/gtest_environment_test.cc b/gtest-1.6.0/test/gtest_environment_test.cc
index 53c7b8c..ec9aa2c 100644
--- a/gtest-1.6.0/test/gtest_environment_test.cc
+++ b/gtest-1.6.0/test/gtest_environment_test.cc
@@ -1,191 +1,191 @@
-// 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: wan@google.com (Zhanyong Wan)

-//

-// Tests using global test environments.

-

-#include <stdlib.h>

-#include <stdio.h>

-#include "gtest/gtest.h"

-

-#define GTEST_IMPLEMENTATION_ 1  // Required for the next #include.

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

-#undef GTEST_IMPLEMENTATION_

-

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

-    testing::internal::posix::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;

-  testing::internal::GetUnitTestImpl()->ClearAdHocTestResult();

-  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: wan@google.com (Zhanyong Wan)
+//
+// Tests using global test environments.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "gtest/gtest.h"
+
+#define GTEST_IMPLEMENTATION_ 1  // Required for the next #include.
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+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);
+    testing::internal::posix::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;
+  testing::internal::GetUnitTestImpl()->ClearAdHocTestResult();
+  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/gtest-1.6.0/test/gtest_filter_unittest.py b/gtest-1.6.0/test/gtest_filter_unittest.py
index b30b3db..0d1a770 100755
--- a/gtest-1.6.0/test/gtest_filter_unittest.py
+++ b/gtest-1.6.0/test/gtest_filter_unittest.py
@@ -1,633 +1,633 @@
-#!/usr/bin/env python

-#

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

-

-"""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 script tests such functionality by invoking

-gtest_filter_unittest_ (a program written with Google Test) with different

-environments and command line flags.

-

-Note that test sharding may also influence which tests are filtered. Therefore,

-we test that here also.

-"""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import os

-import re

-import sets

-import sys

-

-import gtest_test_utils

-

-# Constants.

-

-# Checks if this platform can pass empty environment variables to child

-# processes.  We set an env variable to an empty string and invoke a python

-# script in a subprocess to print whether the variable is STILL in

-# os.environ.  We then use 'eval' to parse the child's output so that an

-# exception is thrown if the input is anything other than 'True' nor 'False'.

-os.environ['EMPTY_VAR'] = ''

-child = gtest_test_utils.Subprocess(

-    [sys.executable, '-c', 'import os; print \'EMPTY_VAR\' in os.environ'])

-CAN_PASS_EMPTY_ENV = eval(child.output)

-

-

-# Check if this platform can unset environment variables in child processes.

-# We set an env variable to a non-empty string, unset it, and invoke

-# a python script in a subprocess to print whether the variable

-# is NO LONGER in os.environ.

-# We use 'eval' to parse the child's output so that an exception

-# is thrown if the input is neither 'True' nor 'False'.

-os.environ['UNSET_VAR'] = 'X'

-del os.environ['UNSET_VAR']

-child = gtest_test_utils.Subprocess(

-    [sys.executable, '-c', 'import os; print \'UNSET_VAR\' not in os.environ'])

-CAN_UNSET_ENV = eval(child.output)

-

-

-# Checks if we should test with an empty filter. This doesn't

-# make sense on platforms that cannot pass empty env variables (Win32)

-# and on platforms that cannot unset variables (since we cannot tell

-# the difference between "" and NULL -- Borland and Solaris < 5.10)

-CAN_TEST_EMPTY_FILTER = (CAN_PASS_EMPTY_ENV and CAN_UNSET_ENV)

-

-

-# The environment variable for specifying the test filters.

-FILTER_ENV_VAR = 'GTEST_FILTER'

-

-# The environment variables for test sharding.

-TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'

-SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'

-SHARD_STATUS_FILE_ENV_VAR = 'GTEST_SHARD_STATUS_FILE'

-

-# The command line flag for specifying the test filters.

-FILTER_FLAG = 'gtest_filter'

-

-# The command line flag for including disabled tests.

-ALSO_RUN_DISABED_TESTS_FLAG = 'gtest_also_run_disabled_tests'

-

-# Command to run the gtest_filter_unittest_ program.

-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_filter_unittest_')

-

-# Regex for determining whether parameterized tests are enabled in the binary.

-PARAM_TEST_REGEX = re.compile(r'/ParamTest')

-

-# Regex for parsing test case names from Google Test's output.

-TEST_CASE_REGEX = re.compile(r'^\[\-+\] \d+ tests? from (\w+(/\w+)?)')

-

-# Regex for parsing test names from Google Test's output.

-TEST_REGEX = re.compile(r'^\[\s*RUN\s*\].*\.(\w+(/\w+)?)')

-

-# The command line flag to tell Google Test to output the list of tests it

-# will run.

-LIST_TESTS_FLAG = '--gtest_list_tests'

-

-# Indicates whether Google Test supports death tests.

-SUPPORTS_DEATH_TESTS = 'HasDeathTest' in gtest_test_utils.Subprocess(

-    [COMMAND, LIST_TESTS_FLAG]).output

-

-# Full names of all tests in gtest_filter_unittests_.

-PARAM_TESTS = [

-    'SeqP/ParamTest.TestX/0',

-    'SeqP/ParamTest.TestX/1',

-    'SeqP/ParamTest.TestY/0',

-    'SeqP/ParamTest.TestY/1',

-    'SeqQ/ParamTest.TestX/0',

-    'SeqQ/ParamTest.TestX/1',

-    'SeqQ/ParamTest.TestY/0',

-    'SeqQ/ParamTest.TestY/1',

-    ]

-

-DISABLED_TESTS = [

-    'BarTest.DISABLED_TestFour',

-    'BarTest.DISABLED_TestFive',

-    'BazTest.DISABLED_TestC',

-    'DISABLED_FoobarTest.Test1',

-    'DISABLED_FoobarTest.DISABLED_Test2',

-    'DISABLED_FoobarbazTest.TestA',

-    ]

-

-if SUPPORTS_DEATH_TESTS:

-  DEATH_TESTS = [

-    'HasDeathTest.Test1',

-    'HasDeathTest.Test2',

-    ]

-else:

-  DEATH_TESTS = []

-

-# All the non-disabled tests.

-ACTIVE_TESTS = [

-    'FooTest.Abc',

-    'FooTest.Xyz',

-

-    'BarTest.TestOne',

-    'BarTest.TestTwo',

-    'BarTest.TestThree',

-

-    'BazTest.TestOne',

-    'BazTest.TestA',

-    'BazTest.TestB',

-    ] + DEATH_TESTS + PARAM_TESTS

-

-param_tests_present = None

-

-# Utilities.

-

-environ = os.environ.copy()

-

-

-def SetEnvVar(env_var, value):

-  """Sets the env variable to 'value'; unsets it when 'value' is None."""

-

-  if value is not None:

-    environ[env_var] = value

-  elif env_var in environ:

-    del environ[env_var]

-

-

-def RunAndReturnOutput(args = None):

-  """Runs the test program and returns its output."""

-

-  return gtest_test_utils.Subprocess([COMMAND] + (args or []),

-                                     env=environ).output

-

-

-def RunAndExtractTestList(args = None):

-  """Runs the test program and returns its exit code and a list of tests run."""

-

-  p = gtest_test_utils.Subprocess([COMMAND] + (args or []), env=environ)

-  tests_run = []

-  test_case = ''

-  test = ''

-  for line in p.output.split('\n'):

-    match = TEST_CASE_REGEX.match(line)

-    if match is not None:

-      test_case = match.group(1)

-    else:

-      match = TEST_REGEX.match(line)

-      if match is not None:

-        test = match.group(1)

-        tests_run.append(test_case + '.' + test)

-  return (tests_run, p.exit_code)

-

-

-def InvokeWithModifiedEnv(extra_env, function, *args, **kwargs):

-  """Runs the given function and arguments in a modified environment."""

-  try:

-    original_env = environ.copy()

-    environ.update(extra_env)

-    return function(*args, **kwargs)

-  finally:

-    environ.clear()

-    environ.update(original_env)

-

-

-def RunWithSharding(total_shards, shard_index, command):

-  """Runs a test program shard and returns exit code and a list of tests run."""

-

-  extra_env = {SHARD_INDEX_ENV_VAR: str(shard_index),

-               TOTAL_SHARDS_ENV_VAR: str(total_shards)}

-  return InvokeWithModifiedEnv(extra_env, RunAndExtractTestList, command)

-

-# The unit test.

-

-

-class GTestFilterUnitTest(gtest_test_utils.TestCase):

-  """Tests the env variable or the command line flag to filter tests."""

-

-  # Utilities.

-

-  def AssertSetEqual(self, lhs, rhs):

-    """Asserts that two sets are equal."""

-

-    for elem in lhs:

-      self.assert_(elem in rhs, '%s in %s' % (elem, rhs))

-

-    for elem in rhs:

-      self.assert_(elem in lhs, '%s in %s' % (elem, lhs))

-

-  def AssertPartitionIsValid(self, set_var, list_of_sets):

-    """Asserts that list_of_sets is a valid partition of set_var."""

-

-    full_partition = []

-    for slice_var in list_of_sets:

-      full_partition.extend(slice_var)

-    self.assertEqual(len(set_var), len(full_partition))

-    self.assertEqual(sets.Set(set_var), sets.Set(full_partition))

-

-  def AdjustForParameterizedTests(self, tests_to_run):

-    """Adjust tests_to_run in case value parameterized tests are disabled."""

-

-    global param_tests_present

-    if not param_tests_present:

-      return list(sets.Set(tests_to_run) - sets.Set(PARAM_TESTS))

-    else:

-      return tests_to_run

-

-  def RunAndVerify(self, gtest_filter, tests_to_run):

-    """Checks that the binary runs correct set of tests for a given filter."""

-

-    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)

-

-    # First, tests using the environment variable.

-

-    # Windows removes empty variables from the environment when passing it

-    # to a new process.  This means it is impossible to pass an empty filter

-    # into a process using the environment variable.  However, we can still

-    # test the case when the variable is not supplied (i.e., gtest_filter is

-    # None).

-    # pylint: disable-msg=C6403

-    if CAN_TEST_EMPTY_FILTER or gtest_filter != '':

-      SetEnvVar(FILTER_ENV_VAR, gtest_filter)

-      tests_run = RunAndExtractTestList()[0]

-      SetEnvVar(FILTER_ENV_VAR, None)

-      self.AssertSetEqual(tests_run, tests_to_run)

-    # pylint: enable-msg=C6403

-

-    # Next, tests using the command line flag.

-

-    if gtest_filter is None:

-      args = []

-    else:

-      args = ['--%s=%s' % (FILTER_FLAG, gtest_filter)]

-

-    tests_run = RunAndExtractTestList(args)[0]

-    self.AssertSetEqual(tests_run, tests_to_run)

-

-  def RunAndVerifyWithSharding(self, gtest_filter, total_shards, tests_to_run,

-                               args=None, check_exit_0=False):

-    """Checks that binary runs correct tests for the given filter and shard.

-

-    Runs all shards of gtest_filter_unittest_ with the given filter, and

-    verifies that the right set of tests were run. The union of tests run

-    on each shard should be identical to tests_to_run, without duplicates.

-

-    Args:

-      gtest_filter: A filter to apply to the tests.

-      total_shards: A total number of shards to split test run into.

-      tests_to_run: A set of tests expected to run.

-      args   :      Arguments to pass to the to the test binary.

-      check_exit_0: When set to a true value, make sure that all shards

-                    return 0.

-    """

-

-    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)

-

-    # Windows removes empty variables from the environment when passing it

-    # to a new process.  This means it is impossible to pass an empty filter

-    # into a process using the environment variable.  However, we can still

-    # test the case when the variable is not supplied (i.e., gtest_filter is

-    # None).

-    # pylint: disable-msg=C6403

-    if CAN_TEST_EMPTY_FILTER or gtest_filter != '':

-      SetEnvVar(FILTER_ENV_VAR, gtest_filter)

-      partition = []

-      for i in range(0, total_shards):

-        (tests_run, exit_code) = RunWithSharding(total_shards, i, args)

-        if check_exit_0:

-          self.assertEqual(0, exit_code)

-        partition.append(tests_run)

-

-      self.AssertPartitionIsValid(tests_to_run, partition)

-      SetEnvVar(FILTER_ENV_VAR, None)

-    # pylint: enable-msg=C6403

-

-  def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):

-    """Checks that the binary runs correct set of tests for the given filter.

-

-    Runs gtest_filter_unittest_ with the given filter, and enables

-    disabled tests. Verifies that the right set of tests were run.

-

-    Args:

-      gtest_filter: A filter to apply to the tests.

-      tests_to_run: A set of tests expected to run.

-    """

-

-    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)

-

-    # Construct the command line.

-    args = ['--%s' % ALSO_RUN_DISABED_TESTS_FLAG]

-    if gtest_filter is not None:

-      args.append('--%s=%s' % (FILTER_FLAG, gtest_filter))

-

-    tests_run = RunAndExtractTestList(args)[0]

-    self.AssertSetEqual(tests_run, tests_to_run)

-

-  def setUp(self):

-    """Sets up test case.

-

-    Determines whether value-parameterized tests are enabled in the binary and

-    sets the flags accordingly.

-    """

-

-    global param_tests_present

-    if param_tests_present is None:

-      param_tests_present = PARAM_TEST_REGEX.search(

-          RunAndReturnOutput()) is not None

-

-  def testDefaultBehavior(self):

-    """Tests the behavior of not specifying the filter."""

-

-    self.RunAndVerify(None, ACTIVE_TESTS)

-

-  def testDefaultBehaviorWithShards(self):

-    """Tests the behavior without the filter, with sharding enabled."""

-

-    self.RunAndVerifyWithSharding(None, 1, ACTIVE_TESTS)

-    self.RunAndVerifyWithSharding(None, 2, ACTIVE_TESTS)

-    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) - 1, ACTIVE_TESTS)

-    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS), ACTIVE_TESTS)

-    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) + 1, ACTIVE_TESTS)

-

-  def testEmptyFilter(self):

-    """Tests an empty filter."""

-

-    self.RunAndVerify('', [])

-    self.RunAndVerifyWithSharding('', 1, [])

-    self.RunAndVerifyWithSharding('', 2, [])

-

-  def testBadFilter(self):

-    """Tests a filter that matches nothing."""

-

-    self.RunAndVerify('BadFilter', [])

-    self.RunAndVerifyAllowingDisabled('BadFilter', [])

-

-  def testFullName(self):

-    """Tests filtering by full name."""

-

-    self.RunAndVerify('FooTest.Xyz', ['FooTest.Xyz'])

-    self.RunAndVerifyAllowingDisabled('FooTest.Xyz', ['FooTest.Xyz'])

-    self.RunAndVerifyWithSharding('FooTest.Xyz', 5, ['FooTest.Xyz'])

-

-  def testUniversalFilters(self):

-    """Tests filters that match everything."""

-

-    self.RunAndVerify('*', ACTIVE_TESTS)

-    self.RunAndVerify('*.*', ACTIVE_TESTS)

-    self.RunAndVerifyWithSharding('*.*', len(ACTIVE_TESTS) - 3, ACTIVE_TESTS)

-    self.RunAndVerifyAllowingDisabled('*', ACTIVE_TESTS + DISABLED_TESTS)

-    self.RunAndVerifyAllowingDisabled('*.*', ACTIVE_TESTS + DISABLED_TESTS)

-

-  def testFilterByTestCase(self):

-    """Tests filtering by test case name."""

-

-    self.RunAndVerify('FooTest.*', ['FooTest.Abc', 'FooTest.Xyz'])

-

-    BAZ_TESTS = ['BazTest.TestOne', 'BazTest.TestA', 'BazTest.TestB']

-    self.RunAndVerify('BazTest.*', BAZ_TESTS)

-    self.RunAndVerifyAllowingDisabled('BazTest.*',

-                                      BAZ_TESTS + ['BazTest.DISABLED_TestC'])

-

-  def testFilterByTest(self):

-    """Tests filtering by test name."""

-

-    self.RunAndVerify('*.TestOne', ['BarTest.TestOne', 'BazTest.TestOne'])

-

-  def testFilterDisabledTests(self):

-    """Select only the disabled tests to run."""

-

-    self.RunAndVerify('DISABLED_FoobarTest.Test1', [])

-    self.RunAndVerifyAllowingDisabled('DISABLED_FoobarTest.Test1',

-                                      ['DISABLED_FoobarTest.Test1'])

-

-    self.RunAndVerify('*DISABLED_*', [])

-    self.RunAndVerifyAllowingDisabled('*DISABLED_*', DISABLED_TESTS)

-

-    self.RunAndVerify('*.DISABLED_*', [])

-    self.RunAndVerifyAllowingDisabled('*.DISABLED_*', [

-        'BarTest.DISABLED_TestFour',

-        'BarTest.DISABLED_TestFive',

-        'BazTest.DISABLED_TestC',

-        'DISABLED_FoobarTest.DISABLED_Test2',

-        ])

-

-    self.RunAndVerify('DISABLED_*', [])

-    self.RunAndVerifyAllowingDisabled('DISABLED_*', [

-        'DISABLED_FoobarTest.Test1',

-        'DISABLED_FoobarTest.DISABLED_Test2',

-        'DISABLED_FoobarbazTest.TestA',

-        ])

-

-  def testWildcardInTestCaseName(self):

-    """Tests using wildcard in the test case name."""

-

-    self.RunAndVerify('*a*.*', [

-        'BarTest.TestOne',

-        'BarTest.TestTwo',

-        'BarTest.TestThree',

-

-        'BazTest.TestOne',

-        'BazTest.TestA',

-        'BazTest.TestB', ] + DEATH_TESTS + PARAM_TESTS)

-

-  def testWildcardInTestName(self):

-    """Tests using wildcard in the test name."""

-

-    self.RunAndVerify('*.*A*', ['FooTest.Abc', 'BazTest.TestA'])

-

-  def testFilterWithoutDot(self):

-    """Tests a filter that has no '.' in it."""

-

-    self.RunAndVerify('*z*', [

-        'FooTest.Xyz',

-

-        'BazTest.TestOne',

-        'BazTest.TestA',

-        'BazTest.TestB',

-        ])

-

-  def testTwoPatterns(self):

-    """Tests filters that consist of two patterns."""

-

-    self.RunAndVerify('Foo*.*:*A*', [

-        'FooTest.Abc',

-        'FooTest.Xyz',

-

-        'BazTest.TestA',

-        ])

-

-    # An empty pattern + a non-empty one

-    self.RunAndVerify(':*A*', ['FooTest.Abc', 'BazTest.TestA'])

-

-  def testThreePatterns(self):

-    """Tests filters that consist of three patterns."""

-

-    self.RunAndVerify('*oo*:*A*:*One', [

-        'FooTest.Abc',

-        'FooTest.Xyz',

-

-        'BarTest.TestOne',

-

-        'BazTest.TestOne',

-        'BazTest.TestA',

-        ])

-

-    # The 2nd pattern is empty.

-    self.RunAndVerify('*oo*::*One', [

-        'FooTest.Abc',

-        'FooTest.Xyz',

-

-        'BarTest.TestOne',

-

-        'BazTest.TestOne',

-        ])

-

-    # The last 2 patterns are empty.

-    self.RunAndVerify('*oo*::', [

-        'FooTest.Abc',

-        'FooTest.Xyz',

-        ])

-

-  def testNegativeFilters(self):

-    self.RunAndVerify('*-BazTest.TestOne', [

-        'FooTest.Abc',

-        'FooTest.Xyz',

-

-        'BarTest.TestOne',

-        'BarTest.TestTwo',

-        'BarTest.TestThree',

-

-        'BazTest.TestA',

-        'BazTest.TestB',

-        ] + DEATH_TESTS + PARAM_TESTS)

-

-    self.RunAndVerify('*-FooTest.Abc:BazTest.*', [

-        'FooTest.Xyz',

-

-        'BarTest.TestOne',

-        'BarTest.TestTwo',

-        'BarTest.TestThree',

-        ] + DEATH_TESTS + PARAM_TESTS)

-

-    self.RunAndVerify('BarTest.*-BarTest.TestOne', [

-        'BarTest.TestTwo',

-        'BarTest.TestThree',

-        ])

-

-    # Tests without leading '*'.

-    self.RunAndVerify('-FooTest.Abc:FooTest.Xyz:BazTest.*', [

-        'BarTest.TestOne',

-        'BarTest.TestTwo',

-        'BarTest.TestThree',

-        ] + DEATH_TESTS + PARAM_TESTS)

-

-    # Value parameterized tests.

-    self.RunAndVerify('*/*', PARAM_TESTS)

-

-    # Value parameterized tests filtering by the sequence name.

-    self.RunAndVerify('SeqP/*', [

-        'SeqP/ParamTest.TestX/0',

-        'SeqP/ParamTest.TestX/1',

-        'SeqP/ParamTest.TestY/0',

-        'SeqP/ParamTest.TestY/1',

-        ])

-

-    # Value parameterized tests filtering by the test name.

-    self.RunAndVerify('*/0', [

-        'SeqP/ParamTest.TestX/0',

-        'SeqP/ParamTest.TestY/0',

-        'SeqQ/ParamTest.TestX/0',

-        'SeqQ/ParamTest.TestY/0',

-        ])

-

-  def testFlagOverridesEnvVar(self):

-    """Tests that the filter flag overrides the filtering env. variable."""

-

-    SetEnvVar(FILTER_ENV_VAR, 'Foo*')

-    args = ['--%s=%s' % (FILTER_FLAG, '*One')]

-    tests_run = RunAndExtractTestList(args)[0]

-    SetEnvVar(FILTER_ENV_VAR, None)

-

-    self.AssertSetEqual(tests_run, ['BarTest.TestOne', 'BazTest.TestOne'])

-

-  def testShardStatusFileIsCreated(self):

-    """Tests that the shard file is created if specified in the environment."""

-

-    shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),

-                                     'shard_status_file')

-    self.assert_(not os.path.exists(shard_status_file))

-

-    extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}

-    try:

-      InvokeWithModifiedEnv(extra_env, RunAndReturnOutput)

-    finally:

-      self.assert_(os.path.exists(shard_status_file))

-      os.remove(shard_status_file)

-

-  def testShardStatusFileIsCreatedWithListTests(self):

-    """Tests that the shard file is created with the "list_tests" flag."""

-

-    shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),

-                                     'shard_status_file2')

-    self.assert_(not os.path.exists(shard_status_file))

-

-    extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}

-    try:

-      output = InvokeWithModifiedEnv(extra_env,

-                                     RunAndReturnOutput,

-                                     [LIST_TESTS_FLAG])

-    finally:

-      # This assertion ensures that Google Test enumerated the tests as

-      # opposed to running them.

-      self.assert_('[==========]' not in output,

-                   'Unexpected output during test enumeration.\n'

-                   'Please ensure that LIST_TESTS_FLAG is assigned the\n'

-                   'correct flag value for listing Google Test tests.')

-

-      self.assert_(os.path.exists(shard_status_file))

-      os.remove(shard_status_file)

-

-  if SUPPORTS_DEATH_TESTS:

-    def testShardingWorksWithDeathTests(self):

-      """Tests integration with death tests and sharding."""

-

-      gtest_filter = 'HasDeathTest.*:SeqP/*'

-      expected_tests = [

-          'HasDeathTest.Test1',

-          'HasDeathTest.Test2',

-

-          'SeqP/ParamTest.TestX/0',

-          'SeqP/ParamTest.TestX/1',

-          'SeqP/ParamTest.TestY/0',

-          'SeqP/ParamTest.TestY/1',

-          ]

-

-      for flag in ['--gtest_death_test_style=threadsafe',

-                   '--gtest_death_test_style=fast']:

-        self.RunAndVerifyWithSharding(gtest_filter, 3, expected_tests,

-                                      check_exit_0=True, args=[flag])

-        self.RunAndVerifyWithSharding(gtest_filter, 5, expected_tests,

-                                      check_exit_0=True, args=[flag])

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""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 script tests such functionality by invoking
+gtest_filter_unittest_ (a program written with Google Test) with different
+environments and command line flags.
+
+Note that test sharding may also influence which tests are filtered. Therefore,
+we test that here also.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+import sets
+import sys
+
+import gtest_test_utils
+
+# Constants.
+
+# Checks if this platform can pass empty environment variables to child
+# processes.  We set an env variable to an empty string and invoke a python
+# script in a subprocess to print whether the variable is STILL in
+# os.environ.  We then use 'eval' to parse the child's output so that an
+# exception is thrown if the input is anything other than 'True' nor 'False'.
+os.environ['EMPTY_VAR'] = ''
+child = gtest_test_utils.Subprocess(
+    [sys.executable, '-c', 'import os; print \'EMPTY_VAR\' in os.environ'])
+CAN_PASS_EMPTY_ENV = eval(child.output)
+
+
+# Check if this platform can unset environment variables in child processes.
+# We set an env variable to a non-empty string, unset it, and invoke
+# a python script in a subprocess to print whether the variable
+# is NO LONGER in os.environ.
+# We use 'eval' to parse the child's output so that an exception
+# is thrown if the input is neither 'True' nor 'False'.
+os.environ['UNSET_VAR'] = 'X'
+del os.environ['UNSET_VAR']
+child = gtest_test_utils.Subprocess(
+    [sys.executable, '-c', 'import os; print \'UNSET_VAR\' not in os.environ'])
+CAN_UNSET_ENV = eval(child.output)
+
+
+# Checks if we should test with an empty filter. This doesn't
+# make sense on platforms that cannot pass empty env variables (Win32)
+# and on platforms that cannot unset variables (since we cannot tell
+# the difference between "" and NULL -- Borland and Solaris < 5.10)
+CAN_TEST_EMPTY_FILTER = (CAN_PASS_EMPTY_ENV and CAN_UNSET_ENV)
+
+
+# The environment variable for specifying the test filters.
+FILTER_ENV_VAR = 'GTEST_FILTER'
+
+# The environment variables for test sharding.
+TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
+SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
+SHARD_STATUS_FILE_ENV_VAR = 'GTEST_SHARD_STATUS_FILE'
+
+# The command line flag for specifying the test filters.
+FILTER_FLAG = 'gtest_filter'
+
+# The command line flag for including disabled tests.
+ALSO_RUN_DISABED_TESTS_FLAG = 'gtest_also_run_disabled_tests'
+
+# Command to run the gtest_filter_unittest_ program.
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_filter_unittest_')
+
+# Regex for determining whether parameterized tests are enabled in the binary.
+PARAM_TEST_REGEX = re.compile(r'/ParamTest')
+
+# Regex for parsing test case names from Google Test's output.
+TEST_CASE_REGEX = re.compile(r'^\[\-+\] \d+ tests? from (\w+(/\w+)?)')
+
+# Regex for parsing test names from Google Test's output.
+TEST_REGEX = re.compile(r'^\[\s*RUN\s*\].*\.(\w+(/\w+)?)')
+
+# The command line flag to tell Google Test to output the list of tests it
+# will run.
+LIST_TESTS_FLAG = '--gtest_list_tests'
+
+# Indicates whether Google Test supports death tests.
+SUPPORTS_DEATH_TESTS = 'HasDeathTest' in gtest_test_utils.Subprocess(
+    [COMMAND, LIST_TESTS_FLAG]).output
+
+# Full names of all tests in gtest_filter_unittests_.
+PARAM_TESTS = [
+    'SeqP/ParamTest.TestX/0',
+    'SeqP/ParamTest.TestX/1',
+    'SeqP/ParamTest.TestY/0',
+    'SeqP/ParamTest.TestY/1',
+    'SeqQ/ParamTest.TestX/0',
+    'SeqQ/ParamTest.TestX/1',
+    'SeqQ/ParamTest.TestY/0',
+    'SeqQ/ParamTest.TestY/1',
+    ]
+
+DISABLED_TESTS = [
+    'BarTest.DISABLED_TestFour',
+    'BarTest.DISABLED_TestFive',
+    'BazTest.DISABLED_TestC',
+    'DISABLED_FoobarTest.Test1',
+    'DISABLED_FoobarTest.DISABLED_Test2',
+    'DISABLED_FoobarbazTest.TestA',
+    ]
+
+if SUPPORTS_DEATH_TESTS:
+  DEATH_TESTS = [
+    'HasDeathTest.Test1',
+    'HasDeathTest.Test2',
+    ]
+else:
+  DEATH_TESTS = []
+
+# All the non-disabled tests.
+ACTIVE_TESTS = [
+    'FooTest.Abc',
+    'FooTest.Xyz',
+
+    'BarTest.TestOne',
+    'BarTest.TestTwo',
+    'BarTest.TestThree',
+
+    'BazTest.TestOne',
+    'BazTest.TestA',
+    'BazTest.TestB',
+    ] + DEATH_TESTS + PARAM_TESTS
+
+param_tests_present = None
+
+# Utilities.
+
+environ = os.environ.copy()
+
+
+def SetEnvVar(env_var, value):
+  """Sets the env variable to 'value'; unsets it when 'value' is None."""
+
+  if value is not None:
+    environ[env_var] = value
+  elif env_var in environ:
+    del environ[env_var]
+
+
+def RunAndReturnOutput(args = None):
+  """Runs the test program and returns its output."""
+
+  return gtest_test_utils.Subprocess([COMMAND] + (args or []),
+                                     env=environ).output
+
+
+def RunAndExtractTestList(args = None):
+  """Runs the test program and returns its exit code and a list of tests run."""
+
+  p = gtest_test_utils.Subprocess([COMMAND] + (args or []), env=environ)
+  tests_run = []
+  test_case = ''
+  test = ''
+  for line in p.output.split('\n'):
+    match = TEST_CASE_REGEX.match(line)
+    if match is not None:
+      test_case = match.group(1)
+    else:
+      match = TEST_REGEX.match(line)
+      if match is not None:
+        test = match.group(1)
+        tests_run.append(test_case + '.' + test)
+  return (tests_run, p.exit_code)
+
+
+def InvokeWithModifiedEnv(extra_env, function, *args, **kwargs):
+  """Runs the given function and arguments in a modified environment."""
+  try:
+    original_env = environ.copy()
+    environ.update(extra_env)
+    return function(*args, **kwargs)
+  finally:
+    environ.clear()
+    environ.update(original_env)
+
+
+def RunWithSharding(total_shards, shard_index, command):
+  """Runs a test program shard and returns exit code and a list of tests run."""
+
+  extra_env = {SHARD_INDEX_ENV_VAR: str(shard_index),
+               TOTAL_SHARDS_ENV_VAR: str(total_shards)}
+  return InvokeWithModifiedEnv(extra_env, RunAndExtractTestList, command)
+
+# The unit test.
+
+
+class GTestFilterUnitTest(gtest_test_utils.TestCase):
+  """Tests the env variable or the command line flag to filter tests."""
+
+  # Utilities.
+
+  def AssertSetEqual(self, lhs, rhs):
+    """Asserts that two sets are equal."""
+
+    for elem in lhs:
+      self.assert_(elem in rhs, '%s in %s' % (elem, rhs))
+
+    for elem in rhs:
+      self.assert_(elem in lhs, '%s in %s' % (elem, lhs))
+
+  def AssertPartitionIsValid(self, set_var, list_of_sets):
+    """Asserts that list_of_sets is a valid partition of set_var."""
+
+    full_partition = []
+    for slice_var in list_of_sets:
+      full_partition.extend(slice_var)
+    self.assertEqual(len(set_var), len(full_partition))
+    self.assertEqual(sets.Set(set_var), sets.Set(full_partition))
+
+  def AdjustForParameterizedTests(self, tests_to_run):
+    """Adjust tests_to_run in case value parameterized tests are disabled."""
+
+    global param_tests_present
+    if not param_tests_present:
+      return list(sets.Set(tests_to_run) - sets.Set(PARAM_TESTS))
+    else:
+      return tests_to_run
+
+  def RunAndVerify(self, gtest_filter, tests_to_run):
+    """Checks that the binary runs correct set of tests for a given filter."""
+
+    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
+
+    # First, tests using the environment variable.
+
+    # Windows removes empty variables from the environment when passing it
+    # to a new process.  This means it is impossible to pass an empty filter
+    # into a process using the environment variable.  However, we can still
+    # test the case when the variable is not supplied (i.e., gtest_filter is
+    # None).
+    # pylint: disable-msg=C6403
+    if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
+      SetEnvVar(FILTER_ENV_VAR, gtest_filter)
+      tests_run = RunAndExtractTestList()[0]
+      SetEnvVar(FILTER_ENV_VAR, None)
+      self.AssertSetEqual(tests_run, tests_to_run)
+    # pylint: enable-msg=C6403
+
+    # Next, tests using the command line flag.
+
+    if gtest_filter is None:
+      args = []
+    else:
+      args = ['--%s=%s' % (FILTER_FLAG, gtest_filter)]
+
+    tests_run = RunAndExtractTestList(args)[0]
+    self.AssertSetEqual(tests_run, tests_to_run)
+
+  def RunAndVerifyWithSharding(self, gtest_filter, total_shards, tests_to_run,
+                               args=None, check_exit_0=False):
+    """Checks that binary runs correct tests for the given filter and shard.
+
+    Runs all shards of gtest_filter_unittest_ with the given filter, and
+    verifies that the right set of tests were run. The union of tests run
+    on each shard should be identical to tests_to_run, without duplicates.
+
+    Args:
+      gtest_filter: A filter to apply to the tests.
+      total_shards: A total number of shards to split test run into.
+      tests_to_run: A set of tests expected to run.
+      args   :      Arguments to pass to the to the test binary.
+      check_exit_0: When set to a true value, make sure that all shards
+                    return 0.
+    """
+
+    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
+
+    # Windows removes empty variables from the environment when passing it
+    # to a new process.  This means it is impossible to pass an empty filter
+    # into a process using the environment variable.  However, we can still
+    # test the case when the variable is not supplied (i.e., gtest_filter is
+    # None).
+    # pylint: disable-msg=C6403
+    if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
+      SetEnvVar(FILTER_ENV_VAR, gtest_filter)
+      partition = []
+      for i in range(0, total_shards):
+        (tests_run, exit_code) = RunWithSharding(total_shards, i, args)
+        if check_exit_0:
+          self.assertEqual(0, exit_code)
+        partition.append(tests_run)
+
+      self.AssertPartitionIsValid(tests_to_run, partition)
+      SetEnvVar(FILTER_ENV_VAR, None)
+    # pylint: enable-msg=C6403
+
+  def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):
+    """Checks that the binary runs correct set of tests for the given filter.
+
+    Runs gtest_filter_unittest_ with the given filter, and enables
+    disabled tests. Verifies that the right set of tests were run.
+
+    Args:
+      gtest_filter: A filter to apply to the tests.
+      tests_to_run: A set of tests expected to run.
+    """
+
+    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
+
+    # Construct the command line.
+    args = ['--%s' % ALSO_RUN_DISABED_TESTS_FLAG]
+    if gtest_filter is not None:
+      args.append('--%s=%s' % (FILTER_FLAG, gtest_filter))
+
+    tests_run = RunAndExtractTestList(args)[0]
+    self.AssertSetEqual(tests_run, tests_to_run)
+
+  def setUp(self):
+    """Sets up test case.
+
+    Determines whether value-parameterized tests are enabled in the binary and
+    sets the flags accordingly.
+    """
+
+    global param_tests_present
+    if param_tests_present is None:
+      param_tests_present = PARAM_TEST_REGEX.search(
+          RunAndReturnOutput()) is not None
+
+  def testDefaultBehavior(self):
+    """Tests the behavior of not specifying the filter."""
+
+    self.RunAndVerify(None, ACTIVE_TESTS)
+
+  def testDefaultBehaviorWithShards(self):
+    """Tests the behavior without the filter, with sharding enabled."""
+
+    self.RunAndVerifyWithSharding(None, 1, ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding(None, 2, ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) - 1, ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS), ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) + 1, ACTIVE_TESTS)
+
+  def testEmptyFilter(self):
+    """Tests an empty filter."""
+
+    self.RunAndVerify('', [])
+    self.RunAndVerifyWithSharding('', 1, [])
+    self.RunAndVerifyWithSharding('', 2, [])
+
+  def testBadFilter(self):
+    """Tests a filter that matches nothing."""
+
+    self.RunAndVerify('BadFilter', [])
+    self.RunAndVerifyAllowingDisabled('BadFilter', [])
+
+  def testFullName(self):
+    """Tests filtering by full name."""
+
+    self.RunAndVerify('FooTest.Xyz', ['FooTest.Xyz'])
+    self.RunAndVerifyAllowingDisabled('FooTest.Xyz', ['FooTest.Xyz'])
+    self.RunAndVerifyWithSharding('FooTest.Xyz', 5, ['FooTest.Xyz'])
+
+  def testUniversalFilters(self):
+    """Tests filters that match everything."""
+
+    self.RunAndVerify('*', ACTIVE_TESTS)
+    self.RunAndVerify('*.*', ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding('*.*', len(ACTIVE_TESTS) - 3, ACTIVE_TESTS)
+    self.RunAndVerifyAllowingDisabled('*', ACTIVE_TESTS + DISABLED_TESTS)
+    self.RunAndVerifyAllowingDisabled('*.*', ACTIVE_TESTS + DISABLED_TESTS)
+
+  def testFilterByTestCase(self):
+    """Tests filtering by test case name."""
+
+    self.RunAndVerify('FooTest.*', ['FooTest.Abc', 'FooTest.Xyz'])
+
+    BAZ_TESTS = ['BazTest.TestOne', 'BazTest.TestA', 'BazTest.TestB']
+    self.RunAndVerify('BazTest.*', BAZ_TESTS)
+    self.RunAndVerifyAllowingDisabled('BazTest.*',
+                                      BAZ_TESTS + ['BazTest.DISABLED_TestC'])
+
+  def testFilterByTest(self):
+    """Tests filtering by test name."""
+
+    self.RunAndVerify('*.TestOne', ['BarTest.TestOne', 'BazTest.TestOne'])
+
+  def testFilterDisabledTests(self):
+    """Select only the disabled tests to run."""
+
+    self.RunAndVerify('DISABLED_FoobarTest.Test1', [])
+    self.RunAndVerifyAllowingDisabled('DISABLED_FoobarTest.Test1',
+                                      ['DISABLED_FoobarTest.Test1'])
+
+    self.RunAndVerify('*DISABLED_*', [])
+    self.RunAndVerifyAllowingDisabled('*DISABLED_*', DISABLED_TESTS)
+
+    self.RunAndVerify('*.DISABLED_*', [])
+    self.RunAndVerifyAllowingDisabled('*.DISABLED_*', [
+        'BarTest.DISABLED_TestFour',
+        'BarTest.DISABLED_TestFive',
+        'BazTest.DISABLED_TestC',
+        'DISABLED_FoobarTest.DISABLED_Test2',
+        ])
+
+    self.RunAndVerify('DISABLED_*', [])
+    self.RunAndVerifyAllowingDisabled('DISABLED_*', [
+        'DISABLED_FoobarTest.Test1',
+        'DISABLED_FoobarTest.DISABLED_Test2',
+        'DISABLED_FoobarbazTest.TestA',
+        ])
+
+  def testWildcardInTestCaseName(self):
+    """Tests using wildcard in the test case name."""
+
+    self.RunAndVerify('*a*.*', [
+        'BarTest.TestOne',
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+
+        'BazTest.TestOne',
+        'BazTest.TestA',
+        'BazTest.TestB', ] + DEATH_TESTS + PARAM_TESTS)
+
+  def testWildcardInTestName(self):
+    """Tests using wildcard in the test name."""
+
+    self.RunAndVerify('*.*A*', ['FooTest.Abc', 'BazTest.TestA'])
+
+  def testFilterWithoutDot(self):
+    """Tests a filter that has no '.' in it."""
+
+    self.RunAndVerify('*z*', [
+        'FooTest.Xyz',
+
+        'BazTest.TestOne',
+        'BazTest.TestA',
+        'BazTest.TestB',
+        ])
+
+  def testTwoPatterns(self):
+    """Tests filters that consist of two patterns."""
+
+    self.RunAndVerify('Foo*.*:*A*', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+
+        'BazTest.TestA',
+        ])
+
+    # An empty pattern + a non-empty one
+    self.RunAndVerify(':*A*', ['FooTest.Abc', 'BazTest.TestA'])
+
+  def testThreePatterns(self):
+    """Tests filters that consist of three patterns."""
+
+    self.RunAndVerify('*oo*:*A*:*One', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+
+        'BarTest.TestOne',
+
+        'BazTest.TestOne',
+        'BazTest.TestA',
+        ])
+
+    # The 2nd pattern is empty.
+    self.RunAndVerify('*oo*::*One', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+
+        'BarTest.TestOne',
+
+        'BazTest.TestOne',
+        ])
+
+    # The last 2 patterns are empty.
+    self.RunAndVerify('*oo*::', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+        ])
+
+  def testNegativeFilters(self):
+    self.RunAndVerify('*-BazTest.TestOne', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+
+        'BarTest.TestOne',
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+
+        'BazTest.TestA',
+        'BazTest.TestB',
+        ] + DEATH_TESTS + PARAM_TESTS)
+
+    self.RunAndVerify('*-FooTest.Abc:BazTest.*', [
+        'FooTest.Xyz',
+
+        'BarTest.TestOne',
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+        ] + DEATH_TESTS + PARAM_TESTS)
+
+    self.RunAndVerify('BarTest.*-BarTest.TestOne', [
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+        ])
+
+    # Tests without leading '*'.
+    self.RunAndVerify('-FooTest.Abc:FooTest.Xyz:BazTest.*', [
+        'BarTest.TestOne',
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+        ] + DEATH_TESTS + PARAM_TESTS)
+
+    # Value parameterized tests.
+    self.RunAndVerify('*/*', PARAM_TESTS)
+
+    # Value parameterized tests filtering by the sequence name.
+    self.RunAndVerify('SeqP/*', [
+        'SeqP/ParamTest.TestX/0',
+        'SeqP/ParamTest.TestX/1',
+        'SeqP/ParamTest.TestY/0',
+        'SeqP/ParamTest.TestY/1',
+        ])
+
+    # Value parameterized tests filtering by the test name.
+    self.RunAndVerify('*/0', [
+        'SeqP/ParamTest.TestX/0',
+        'SeqP/ParamTest.TestY/0',
+        'SeqQ/ParamTest.TestX/0',
+        'SeqQ/ParamTest.TestY/0',
+        ])
+
+  def testFlagOverridesEnvVar(self):
+    """Tests that the filter flag overrides the filtering env. variable."""
+
+    SetEnvVar(FILTER_ENV_VAR, 'Foo*')
+    args = ['--%s=%s' % (FILTER_FLAG, '*One')]
+    tests_run = RunAndExtractTestList(args)[0]
+    SetEnvVar(FILTER_ENV_VAR, None)
+
+    self.AssertSetEqual(tests_run, ['BarTest.TestOne', 'BazTest.TestOne'])
+
+  def testShardStatusFileIsCreated(self):
+    """Tests that the shard file is created if specified in the environment."""
+
+    shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
+                                     'shard_status_file')
+    self.assert_(not os.path.exists(shard_status_file))
+
+    extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
+    try:
+      InvokeWithModifiedEnv(extra_env, RunAndReturnOutput)
+    finally:
+      self.assert_(os.path.exists(shard_status_file))
+      os.remove(shard_status_file)
+
+  def testShardStatusFileIsCreatedWithListTests(self):
+    """Tests that the shard file is created with the "list_tests" flag."""
+
+    shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
+                                     'shard_status_file2')
+    self.assert_(not os.path.exists(shard_status_file))
+
+    extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
+    try:
+      output = InvokeWithModifiedEnv(extra_env,
+                                     RunAndReturnOutput,
+                                     [LIST_TESTS_FLAG])
+    finally:
+      # This assertion ensures that Google Test enumerated the tests as
+      # opposed to running them.
+      self.assert_('[==========]' not in output,
+                   'Unexpected output during test enumeration.\n'
+                   'Please ensure that LIST_TESTS_FLAG is assigned the\n'
+                   'correct flag value for listing Google Test tests.')
+
+      self.assert_(os.path.exists(shard_status_file))
+      os.remove(shard_status_file)
+
+  if SUPPORTS_DEATH_TESTS:
+    def testShardingWorksWithDeathTests(self):
+      """Tests integration with death tests and sharding."""
+
+      gtest_filter = 'HasDeathTest.*:SeqP/*'
+      expected_tests = [
+          'HasDeathTest.Test1',
+          'HasDeathTest.Test2',
+
+          'SeqP/ParamTest.TestX/0',
+          'SeqP/ParamTest.TestX/1',
+          'SeqP/ParamTest.TestY/0',
+          'SeqP/ParamTest.TestY/1',
+          ]
+
+      for flag in ['--gtest_death_test_style=threadsafe',
+                   '--gtest_death_test_style=fast']:
+        self.RunAndVerifyWithSharding(gtest_filter, 3, expected_tests,
+                                      check_exit_0=True, args=[flag])
+        self.RunAndVerifyWithSharding(gtest_filter, 5, expected_tests,
+                                      check_exit_0=True, args=[flag])
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_filter_unittest_.cc b/gtest-1.6.0/test/gtest_filter_unittest_.cc
index d5f6ef7..77deffc 100644
--- a/gtest-1.6.0/test/gtest_filter_unittest_.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (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/gtest-1.6.0/test/gtest_help_test.py b/gtest-1.6.0/test/gtest_help_test.py
index 6c5ae15..093c838 100755
--- a/gtest-1.6.0/test/gtest_help_test.py
+++ b/gtest-1.6.0/test/gtest_help_test.py
@@ -1,172 +1,172 @@
-#!/usr/bin/env python

-#

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

-

-"""Tests the --help flag of Google C++ Testing Framework.

-

-SYNOPSIS

-       gtest_help_test.py --build_dir=BUILD/DIR

-         # where BUILD/DIR contains the built gtest_help_test_ file.

-       gtest_help_test.py

-"""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import os

-import re

-import gtest_test_utils

-

-

-IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'

-IS_WINDOWS = os.name == 'nt'

-

-PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_help_test_')

-FLAG_PREFIX = '--gtest_'

-DEATH_TEST_STYLE_FLAG = FLAG_PREFIX + 'death_test_style'

-STREAM_RESULT_TO_FLAG = FLAG_PREFIX + 'stream_result_to'

-UNKNOWN_FLAG = FLAG_PREFIX + 'unknown_flag_for_testing'

-LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'

-INCORRECT_FLAG_VARIANTS = [re.sub('^--', '-', LIST_TESTS_FLAG),

-                           re.sub('^--', '/', LIST_TESTS_FLAG),

-                           re.sub('_', '-', LIST_TESTS_FLAG)]

-INTERNAL_FLAG_FOR_TESTING = FLAG_PREFIX + 'internal_flag_for_testing'

-

-SUPPORTS_DEATH_TESTS = "DeathTest" in gtest_test_utils.Subprocess(

-    [PROGRAM_PATH, LIST_TESTS_FLAG]).output

-

-# The help message must match this regex.

-HELP_REGEX = re.compile(

-    FLAG_PREFIX + r'list_tests.*' +

-    FLAG_PREFIX + r'filter=.*' +

-    FLAG_PREFIX + r'also_run_disabled_tests.*' +

-    FLAG_PREFIX + r'repeat=.*' +

-    FLAG_PREFIX + r'shuffle.*' +

-    FLAG_PREFIX + r'random_seed=.*' +

-    FLAG_PREFIX + r'color=.*' +

-    FLAG_PREFIX + r'print_time.*' +

-    FLAG_PREFIX + r'output=.*' +

-    FLAG_PREFIX + r'break_on_failure.*' +

-    FLAG_PREFIX + r'throw_on_failure.*' +

-    FLAG_PREFIX + r'catch_exceptions=0.*',

-    re.DOTALL)

-

-

-def RunWithFlag(flag):

-  """Runs gtest_help_test_ with the given flag.

-

-  Returns:

-    the exit code and the text output as a tuple.

-  Args:

-    flag: the command-line flag to pass to gtest_help_test_, or None.

-  """

-

-  if flag is None:

-    command = [PROGRAM_PATH]

-  else:

-    command = [PROGRAM_PATH, flag]

-  child = gtest_test_utils.Subprocess(command)

-  return child.exit_code, child.output

-

-

-class GTestHelpTest(gtest_test_utils.TestCase):

-  """Tests the --help flag and its equivalent forms."""

-

-  def TestHelpFlag(self, flag):

-    """Verifies correct behavior when help flag is specified.

-

-    The right message must be printed and the tests must

-    skipped when the given flag is specified.

-

-    Args:

-      flag:  A flag to pass to the binary or None.

-    """

-

-    exit_code, output = RunWithFlag(flag)

-    self.assertEquals(0, exit_code)

-    self.assert_(HELP_REGEX.search(output), output)

-

-    if IS_LINUX:

-      self.assert_(STREAM_RESULT_TO_FLAG in output, output)

-    else:

-      self.assert_(STREAM_RESULT_TO_FLAG not in output, output)

-

-    if SUPPORTS_DEATH_TESTS and not IS_WINDOWS:

-      self.assert_(DEATH_TEST_STYLE_FLAG in output, output)

-    else:

-      self.assert_(DEATH_TEST_STYLE_FLAG not in output, output)

-

-  def TestNonHelpFlag(self, flag):

-    """Verifies correct behavior when no help flag is specified.

-

-    Verifies that when no help flag is specified, the tests are run

-    and the help message is not printed.

-

-    Args:

-      flag:  A flag to pass to the binary or None.

-    """

-

-    exit_code, output = RunWithFlag(flag)

-    self.assert_(exit_code != 0)

-    self.assert_(not HELP_REGEX.search(output), output)

-

-  def testPrintsHelpWithFullFlag(self):

-    self.TestHelpFlag('--help')

-

-  def testPrintsHelpWithShortFlag(self):

-    self.TestHelpFlag('-h')

-

-  def testPrintsHelpWithQuestionFlag(self):

-    self.TestHelpFlag('-?')

-

-  def testPrintsHelpWithWindowsStyleQuestionFlag(self):

-    self.TestHelpFlag('/?')

-

-  def testPrintsHelpWithUnrecognizedGoogleTestFlag(self):

-    self.TestHelpFlag(UNKNOWN_FLAG)

-

-  def testPrintsHelpWithIncorrectFlagStyle(self):

-    for incorrect_flag in INCORRECT_FLAG_VARIANTS:

-      self.TestHelpFlag(incorrect_flag)

-

-  def testRunsTestsWithoutHelpFlag(self):

-    """Verifies that when no help flag is specified, the tests are run

-    and the help message is not printed."""

-

-    self.TestNonHelpFlag(None)

-

-  def testRunsTestsWithGtestInternalFlag(self):

-    """Verifies that the tests are run and no help message is printed when

-    a flag starting with Google Test prefix and 'internal_' is supplied."""

-

-    self.TestNonHelpFlag(INTERNAL_FLAG_FOR_TESTING)

-

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Tests the --help flag of Google C++ Testing Framework.
+
+SYNOPSIS
+       gtest_help_test.py --build_dir=BUILD/DIR
+         # where BUILD/DIR contains the built gtest_help_test_ file.
+       gtest_help_test.py
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+import gtest_test_utils
+
+
+IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
+IS_WINDOWS = os.name == 'nt'
+
+PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_help_test_')
+FLAG_PREFIX = '--gtest_'
+DEATH_TEST_STYLE_FLAG = FLAG_PREFIX + 'death_test_style'
+STREAM_RESULT_TO_FLAG = FLAG_PREFIX + 'stream_result_to'
+UNKNOWN_FLAG = FLAG_PREFIX + 'unknown_flag_for_testing'
+LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
+INCORRECT_FLAG_VARIANTS = [re.sub('^--', '-', LIST_TESTS_FLAG),
+                           re.sub('^--', '/', LIST_TESTS_FLAG),
+                           re.sub('_', '-', LIST_TESTS_FLAG)]
+INTERNAL_FLAG_FOR_TESTING = FLAG_PREFIX + 'internal_flag_for_testing'
+
+SUPPORTS_DEATH_TESTS = "DeathTest" in gtest_test_utils.Subprocess(
+    [PROGRAM_PATH, LIST_TESTS_FLAG]).output
+
+# The help message must match this regex.
+HELP_REGEX = re.compile(
+    FLAG_PREFIX + r'list_tests.*' +
+    FLAG_PREFIX + r'filter=.*' +
+    FLAG_PREFIX + r'also_run_disabled_tests.*' +
+    FLAG_PREFIX + r'repeat=.*' +
+    FLAG_PREFIX + r'shuffle.*' +
+    FLAG_PREFIX + r'random_seed=.*' +
+    FLAG_PREFIX + r'color=.*' +
+    FLAG_PREFIX + r'print_time.*' +
+    FLAG_PREFIX + r'output=.*' +
+    FLAG_PREFIX + r'break_on_failure.*' +
+    FLAG_PREFIX + r'throw_on_failure.*' +
+    FLAG_PREFIX + r'catch_exceptions=0.*',
+    re.DOTALL)
+
+
+def RunWithFlag(flag):
+  """Runs gtest_help_test_ with the given flag.
+
+  Returns:
+    the exit code and the text output as a tuple.
+  Args:
+    flag: the command-line flag to pass to gtest_help_test_, or None.
+  """
+
+  if flag is None:
+    command = [PROGRAM_PATH]
+  else:
+    command = [PROGRAM_PATH, flag]
+  child = gtest_test_utils.Subprocess(command)
+  return child.exit_code, child.output
+
+
+class GTestHelpTest(gtest_test_utils.TestCase):
+  """Tests the --help flag and its equivalent forms."""
+
+  def TestHelpFlag(self, flag):
+    """Verifies correct behavior when help flag is specified.
+
+    The right message must be printed and the tests must
+    skipped when the given flag is specified.
+
+    Args:
+      flag:  A flag to pass to the binary or None.
+    """
+
+    exit_code, output = RunWithFlag(flag)
+    self.assertEquals(0, exit_code)
+    self.assert_(HELP_REGEX.search(output), output)
+
+    if IS_LINUX:
+      self.assert_(STREAM_RESULT_TO_FLAG in output, output)
+    else:
+      self.assert_(STREAM_RESULT_TO_FLAG not in output, output)
+
+    if SUPPORTS_DEATH_TESTS and not IS_WINDOWS:
+      self.assert_(DEATH_TEST_STYLE_FLAG in output, output)
+    else:
+      self.assert_(DEATH_TEST_STYLE_FLAG not in output, output)
+
+  def TestNonHelpFlag(self, flag):
+    """Verifies correct behavior when no help flag is specified.
+
+    Verifies that when no help flag is specified, the tests are run
+    and the help message is not printed.
+
+    Args:
+      flag:  A flag to pass to the binary or None.
+    """
+
+    exit_code, output = RunWithFlag(flag)
+    self.assert_(exit_code != 0)
+    self.assert_(not HELP_REGEX.search(output), output)
+
+  def testPrintsHelpWithFullFlag(self):
+    self.TestHelpFlag('--help')
+
+  def testPrintsHelpWithShortFlag(self):
+    self.TestHelpFlag('-h')
+
+  def testPrintsHelpWithQuestionFlag(self):
+    self.TestHelpFlag('-?')
+
+  def testPrintsHelpWithWindowsStyleQuestionFlag(self):
+    self.TestHelpFlag('/?')
+
+  def testPrintsHelpWithUnrecognizedGoogleTestFlag(self):
+    self.TestHelpFlag(UNKNOWN_FLAG)
+
+  def testPrintsHelpWithIncorrectFlagStyle(self):
+    for incorrect_flag in INCORRECT_FLAG_VARIANTS:
+      self.TestHelpFlag(incorrect_flag)
+
+  def testRunsTestsWithoutHelpFlag(self):
+    """Verifies that when no help flag is specified, the tests are run
+    and the help message is not printed."""
+
+    self.TestNonHelpFlag(None)
+
+  def testRunsTestsWithGtestInternalFlag(self):
+    """Verifies that the tests are run and no help message is printed when
+    a flag starting with Google Test prefix and 'internal_' is supplied."""
+
+    self.TestNonHelpFlag(INTERNAL_FLAG_FOR_TESTING)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_help_test_.cc b/gtest-1.6.0/test/gtest_help_test_.cc
index ec22b14..31f78c2 100644
--- a/gtest-1.6.0/test/gtest_help_test_.cc
+++ b/gtest-1.6.0/test/gtest_help_test_.cc
@@ -1,46 +1,46 @@
-// 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: wan@google.com (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.";

-}

-

-#if GTEST_HAS_DEATH_TEST

-TEST(DeathTest, UsedByPythonScriptToDetectSupportForDeathTestsInThisBinary) {}

-#endif

+// 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: wan@google.com (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.";
+}
+
+#if GTEST_HAS_DEATH_TEST
+TEST(DeathTest, UsedByPythonScriptToDetectSupportForDeathTestsInThisBinary) {}
+#endif
diff --git a/gtest-1.6.0/test/gtest_list_tests_unittest.py b/gtest-1.6.0/test/gtest_list_tests_unittest.py
index 8a6c48f..ce8c3ef 100755
--- a/gtest-1.6.0/test/gtest_list_tests_unittest.py
+++ b/gtest-1.6.0/test/gtest_list_tests_unittest.py
@@ -1,177 +1,177 @@
-#!/usr/bin/env python

-#

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

-

-"""Unit test for Google Test's --gtest_list_tests flag.

-

-A user can ask Google Test to list all tests by specifying the

---gtest_list_tests flag.  This script tests such functionality

-by invoking gtest_list_tests_unittest_ (a program written with

-Google Test) the command line flags.

-"""

-

-__author__ = 'phanna@google.com (Patrick Hanna)'

-

-import gtest_test_utils

-

-

-# Constants.

-

-# The command line flag for enabling/disabling listing all tests.

-LIST_TESTS_FLAG = 'gtest_list_tests'

-

-# Path to the gtest_list_tests_unittest_ program.

-EXE_PATH = gtest_test_utils.GetTestExecutablePath('gtest_list_tests_unittest_')

-

-# The expected output when running gtest_list_tests_unittest_ with

-# --gtest_list_tests

-EXPECTED_OUTPUT_NO_FILTER = """FooDeathTest.

-  Test1

-Foo.

-  Bar1

-  Bar2

-  DISABLED_Bar3

-Abc.

-  Xyz

-  Def

-FooBar.

-  Baz

-FooTest.

-  Test1

-  DISABLED_Test2

-  Test3

-"""

-

-# The expected output when running gtest_list_tests_unittest_ with

-# --gtest_list_tests and --gtest_filter=Foo*.

-EXPECTED_OUTPUT_FILTER_FOO = """FooDeathTest.

-  Test1

-Foo.

-  Bar1

-  Bar2

-  DISABLED_Bar3

-FooBar.

-  Baz

-FooTest.

-  Test1

-  DISABLED_Test2

-  Test3

-"""

-

-# Utilities.

-

-

-def Run(args):

-  """Runs gtest_list_tests_unittest_ and returns the list of tests printed."""

-

-  return gtest_test_utils.Subprocess([EXE_PATH] + args,

-                                     capture_stderr=False).output

-

-

-# The unit test.

-

-class GTestListTestsUnitTest(gtest_test_utils.TestCase):

-  """Tests using the --gtest_list_tests flag to list all tests."""

-

-  def RunAndVerify(self, flag_value, expected_output, other_flag):

-    """Runs gtest_list_tests_unittest_ and verifies that it prints

-    the correct tests.

-

-    Args:

-      flag_value:       value of the --gtest_list_tests flag;

-                        None if the flag should not be present.

-

-      expected_output:  the expected output after running command;

-

-      other_flag:       a different flag to be passed to command

-                        along with gtest_list_tests;

-                        None if the flag should not be present.

-    """

-

-    if flag_value is None:

-      flag = ''

-      flag_expression = 'not set'

-    elif flag_value == '0':

-      flag = '--%s=0' % LIST_TESTS_FLAG

-      flag_expression = '0'

-    else:

-      flag = '--%s' % LIST_TESTS_FLAG

-      flag_expression = '1'

-

-    args = [flag]

-

-    if other_flag is not None:

-      args += [other_flag]

-

-    output = Run(args)

-

-    msg = ('when %s is %s, the output of "%s" is "%s".' %

-           (LIST_TESTS_FLAG, flag_expression, ' '.join(args), output))

-

-    if expected_output is not None:

-      self.assert_(output == expected_output, msg)

-    else:

-      self.assert_(output != EXPECTED_OUTPUT_NO_FILTER, msg)

-

-  def testDefaultBehavior(self):

-    """Tests the behavior of the default mode."""

-

-    self.RunAndVerify(flag_value=None,

-                      expected_output=None,

-                      other_flag=None)

-

-  def testFlag(self):

-    """Tests using the --gtest_list_tests flag."""

-

-    self.RunAndVerify(flag_value='0',

-                      expected_output=None,

-                      other_flag=None)

-    self.RunAndVerify(flag_value='1',

-                      expected_output=EXPECTED_OUTPUT_NO_FILTER,

-                      other_flag=None)

-

-  def testOverrideNonFilterFlags(self):

-    """Tests that --gtest_list_tests overrides the non-filter flags."""

-

-    self.RunAndVerify(flag_value='1',

-                      expected_output=EXPECTED_OUTPUT_NO_FILTER,

-                      other_flag='--gtest_break_on_failure')

-

-  def testWithFilterFlags(self):

-    """Tests that --gtest_list_tests takes into account the

-    --gtest_filter flag."""

-

-    self.RunAndVerify(flag_value='1',

-                      expected_output=EXPECTED_OUTPUT_FILTER_FOO,

-                      other_flag='--gtest_filter=Foo*')

-

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Unit test for Google Test's --gtest_list_tests flag.
+
+A user can ask Google Test to list all tests by specifying the
+--gtest_list_tests flag.  This script tests such functionality
+by invoking gtest_list_tests_unittest_ (a program written with
+Google Test) the command line flags.
+"""
+
+__author__ = 'phanna@google.com (Patrick Hanna)'
+
+import gtest_test_utils
+
+
+# Constants.
+
+# The command line flag for enabling/disabling listing all tests.
+LIST_TESTS_FLAG = 'gtest_list_tests'
+
+# Path to the gtest_list_tests_unittest_ program.
+EXE_PATH = gtest_test_utils.GetTestExecutablePath('gtest_list_tests_unittest_')
+
+# The expected output when running gtest_list_tests_unittest_ with
+# --gtest_list_tests
+EXPECTED_OUTPUT_NO_FILTER = """FooDeathTest.
+  Test1
+Foo.
+  Bar1
+  Bar2
+  DISABLED_Bar3
+Abc.
+  Xyz
+  Def
+FooBar.
+  Baz
+FooTest.
+  Test1
+  DISABLED_Test2
+  Test3
+"""
+
+# The expected output when running gtest_list_tests_unittest_ with
+# --gtest_list_tests and --gtest_filter=Foo*.
+EXPECTED_OUTPUT_FILTER_FOO = """FooDeathTest.
+  Test1
+Foo.
+  Bar1
+  Bar2
+  DISABLED_Bar3
+FooBar.
+  Baz
+FooTest.
+  Test1
+  DISABLED_Test2
+  Test3
+"""
+
+# Utilities.
+
+
+def Run(args):
+  """Runs gtest_list_tests_unittest_ and returns the list of tests printed."""
+
+  return gtest_test_utils.Subprocess([EXE_PATH] + args,
+                                     capture_stderr=False).output
+
+
+# The unit test.
+
+class GTestListTestsUnitTest(gtest_test_utils.TestCase):
+  """Tests using the --gtest_list_tests flag to list all tests."""
+
+  def RunAndVerify(self, flag_value, expected_output, other_flag):
+    """Runs gtest_list_tests_unittest_ and verifies that it prints
+    the correct tests.
+
+    Args:
+      flag_value:       value of the --gtest_list_tests flag;
+                        None if the flag should not be present.
+
+      expected_output:  the expected output after running command;
+
+      other_flag:       a different flag to be passed to command
+                        along with gtest_list_tests;
+                        None if the flag should not be present.
+    """
+
+    if flag_value is None:
+      flag = ''
+      flag_expression = 'not set'
+    elif flag_value == '0':
+      flag = '--%s=0' % LIST_TESTS_FLAG
+      flag_expression = '0'
+    else:
+      flag = '--%s' % LIST_TESTS_FLAG
+      flag_expression = '1'
+
+    args = [flag]
+
+    if other_flag is not None:
+      args += [other_flag]
+
+    output = Run(args)
+
+    msg = ('when %s is %s, the output of "%s" is "%s".' %
+           (LIST_TESTS_FLAG, flag_expression, ' '.join(args), output))
+
+    if expected_output is not None:
+      self.assert_(output == expected_output, msg)
+    else:
+      self.assert_(output != EXPECTED_OUTPUT_NO_FILTER, msg)
+
+  def testDefaultBehavior(self):
+    """Tests the behavior of the default mode."""
+
+    self.RunAndVerify(flag_value=None,
+                      expected_output=None,
+                      other_flag=None)
+
+  def testFlag(self):
+    """Tests using the --gtest_list_tests flag."""
+
+    self.RunAndVerify(flag_value='0',
+                      expected_output=None,
+                      other_flag=None)
+    self.RunAndVerify(flag_value='1',
+                      expected_output=EXPECTED_OUTPUT_NO_FILTER,
+                      other_flag=None)
+
+  def testOverrideNonFilterFlags(self):
+    """Tests that --gtest_list_tests overrides the non-filter flags."""
+
+    self.RunAndVerify(flag_value='1',
+                      expected_output=EXPECTED_OUTPUT_NO_FILTER,
+                      other_flag='--gtest_break_on_failure')
+
+  def testWithFilterFlags(self):
+    """Tests that --gtest_list_tests takes into account the
+    --gtest_filter flag."""
+
+    self.RunAndVerify(flag_value='1',
+                      expected_output=EXPECTED_OUTPUT_FILTER_FOO,
+                      other_flag='--gtest_filter=Foo*')
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_list_tests_unittest_.cc b/gtest-1.6.0/test/gtest_list_tests_unittest_.cc
index 0aa5437..2b1d078 100644
--- a/gtest-1.6.0/test/gtest_list_tests_unittest_.cc
+++ b/gtest-1.6.0/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: phanna@google.com (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: phanna@google.com (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/gtest-1.6.0/test/gtest_main_unittest.cc b/gtest-1.6.0/test/gtest_main_unittest.cc
index 16b1b40..ecd9bb8 100644
--- a/gtest-1.6.0/test/gtest_main_unittest.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (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/gtest-1.6.0/test/gtest_no_test_unittest.cc b/gtest-1.6.0/test/gtest_no_test_unittest.cc
index 281deed..e3a85f1 100644
--- a/gtest-1.6.0/test/gtest_no_test_unittest.cc
+++ b/gtest-1.6.0/test/gtest_no_test_unittest.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.

-

-// Tests that a Google Test program that has no test defined can run

-// successfully.

-//

-// Author: wan@google.com (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 three purposes:

-  //

-  // 1. It verifies that an ad-hoc assertion can be executed even if

-  //    no test is defined.

-  // 2. It verifies that a failed ad-hoc assertion causes the test

-  //    program to fail.

-  // 3. 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, 2);

-

-  // The above EXPECT_EQ() should cause RUN_ALL_TESTS() to return non-zero.

-  return RUN_ALL_TESTS() ? 0 : 1;

-}

+// 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: wan@google.com (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 three purposes:
+  //
+  // 1. It verifies that an ad-hoc assertion can be executed even if
+  //    no test is defined.
+  // 2. It verifies that a failed ad-hoc assertion causes the test
+  //    program to fail.
+  // 3. 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, 2);
+
+  // The above EXPECT_EQ() should cause RUN_ALL_TESTS() to return non-zero.
+  return RUN_ALL_TESTS() ? 0 : 1;
+}
diff --git a/gtest-1.6.0/test/gtest_output_test.py b/gtest-1.6.0/test/gtest_output_test.py
index e3aa5a2..f409e2a 100755
--- a/gtest-1.6.0/test/gtest_output_test.py
+++ b/gtest-1.6.0/test/gtest_output_test.py
@@ -1,335 +1,335 @@
-#!/usr/bin/env python

-#

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

-

-"""Tests the text output of Google C++ Testing Framework.

-

-SYNOPSIS

-       gtest_output_test.py --build_dir=BUILD/DIR --gengolden

-         # where BUILD/DIR contains the built gtest_output_test_ file.

-       gtest_output_test.py --gengolden

-       gtest_output_test.py

-"""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import os

-import re

-import sys

-import gtest_test_utils

-

-

-# The flag for generating the golden file

-GENGOLDEN_FLAG = '--gengolden'

-CATCH_EXCEPTIONS_ENV_VAR_NAME = 'GTEST_CATCH_EXCEPTIONS'

-

-IS_WINDOWS = os.name == 'nt'

-

-# TODO(vladl@google.com): remove the _lin suffix.

-GOLDEN_NAME = 'gtest_output_test_golden_lin.txt'

-

-PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_output_test_')

-

-# At least one command we exercise must not have the

-# --gtest_internal_skip_environment_and_ad_hoc_tests flag.

-COMMAND_LIST_TESTS = ({}, [PROGRAM_PATH, '--gtest_list_tests'])

-COMMAND_WITH_COLOR = ({}, [PROGRAM_PATH, '--gtest_color=yes'])

-COMMAND_WITH_TIME = ({}, [PROGRAM_PATH,

-                          '--gtest_print_time',

-                          '--gtest_internal_skip_environment_and_ad_hoc_tests',

-                          '--gtest_filter=FatalFailureTest.*:LoggingTest.*'])

-COMMAND_WITH_DISABLED = (

-    {}, [PROGRAM_PATH,

-         '--gtest_also_run_disabled_tests',

-         '--gtest_internal_skip_environment_and_ad_hoc_tests',

-         '--gtest_filter=*DISABLED_*'])

-COMMAND_WITH_SHARDING = (

-    {'GTEST_SHARD_INDEX': '1', 'GTEST_TOTAL_SHARDS': '2'},

-    [PROGRAM_PATH,

-     '--gtest_internal_skip_environment_and_ad_hoc_tests',

-     '--gtest_filter=PassingTest.*'])

-

-GOLDEN_PATH = os.path.join(gtest_test_utils.GetSourceDir(), GOLDEN_NAME)

-

-

-def ToUnixLineEnding(s):

-  """Changes all Windows/Mac line endings in s to UNIX line endings."""

-

-  return s.replace('\r\n', '\n').replace('\r', '\n')

-

-

-def RemoveLocations(test_output):

-  """Removes all file location info from a Google Test program's output.

-

-  Args:

-       test_output:  the output of a Google Test program.

-

-  Returns:

-       output with all file location info (in the form of

-       'DIRECTORY/FILE_NAME:LINE_NUMBER: 'or

-       'DIRECTORY\\FILE_NAME(LINE_NUMBER): ') replaced by

-       'FILE_NAME:#: '.

-  """

-

-  return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\: ', r'\1:#: ', test_output)

-

-

-def RemoveStackTraceDetails(output):

-  """Removes all stack traces from a Google Test program's output."""

-

-  # *? means "find the shortest string that matches".

-  return re.sub(r'Stack trace:(.|\n)*?\n\n',

-                'Stack trace: (omitted)\n\n', output)

-

-

-def RemoveStackTraces(output):

-  """Removes all traces of stack traces from a Google Test program's output."""

-

-  # *? means "find the shortest string that matches".

-  return re.sub(r'Stack trace:(.|\n)*?\n\n', '', output)

-

-

-def RemoveTime(output):

-  """Removes all time information from a Google Test program's output."""

-

-  return re.sub(r'\(\d+ ms', '(? ms', output)

-

-

-def RemoveTypeInfoDetails(test_output):

-  """Removes compiler-specific type info from Google Test program's output.

-

-  Args:

-       test_output:  the output of a Google Test program.

-

-  Returns:

-       output with type information normalized to canonical form.

-  """

-

-  # some compilers output the name of type 'unsigned int' as 'unsigned'

-  return re.sub(r'unsigned int', 'unsigned', test_output)

-

-

-def NormalizeToCurrentPlatform(test_output):

-  """Normalizes platform specific output details for easier comparison."""

-

-  if IS_WINDOWS:

-    # Removes the color information that is not present on Windows.

-    test_output = re.sub('\x1b\\[(0;3\d)?m', '', test_output)

-    # Changes failure message headers into the Windows format.

-    test_output = re.sub(r': Failure\n', r': error: ', test_output)

-    # Changes file(line_number) to file:line_number.

-    test_output = re.sub(r'((\w|\.)+)\((\d+)\):', r'\1:\3:', test_output)

-

-  return test_output

-

-

-def RemoveTestCounts(output):

-  """Removes test counts from a Google Test program's output."""

-

-  output = re.sub(r'\d+ tests?, listed below',

-                  '? tests, listed below', output)

-  output = re.sub(r'\d+ FAILED TESTS',

-                  '? FAILED TESTS', output)

-  output = re.sub(r'\d+ tests? from \d+ test cases?',

-                  '? tests from ? test cases', output)

-  output = re.sub(r'\d+ tests? from ([a-zA-Z_])',

-                  r'? tests from \1', output)

-  return re.sub(r'\d+ tests?\.', '? tests.', output)

-

-

-def RemoveMatchingTests(test_output, pattern):

-  """Removes output of specified tests from a Google Test program's output.

-

-  This function strips not only the beginning and the end of a test but also

-  all output in between.

-

-  Args:

-    test_output:       A string containing the test output.

-    pattern:           A regex string that matches names of test cases or

-                       tests to remove.

-

-  Returns:

-    Contents of test_output with tests whose names match pattern removed.

-  """

-

-  test_output = re.sub(

-      r'.*\[ RUN      \] .*%s(.|\n)*?\[(  FAILED  |       OK )\] .*%s.*\n' % (

-          pattern, pattern),

-      '',

-      test_output)

-  return re.sub(r'.*%s.*\n' % pattern, '', test_output)

-

-

-def NormalizeOutput(output):

-  """Normalizes output (the output of gtest_output_test_.exe)."""

-

-  output = ToUnixLineEnding(output)

-  output = RemoveLocations(output)

-  output = RemoveStackTraceDetails(output)

-  output = RemoveTime(output)

-  return output

-

-

-def GetShellCommandOutput(env_cmd):

-  """Runs a command in a sub-process, and returns its output in a string.

-

-  Args:

-    env_cmd: The shell command. A 2-tuple where element 0 is a dict of extra

-             environment variables to set, and element 1 is a string with

-             the command and any flags.

-

-  Returns:

-    A string with the command's combined standard and diagnostic output.

-  """

-

-  # Spawns cmd in a sub-process, and gets its standard I/O file objects.

-  # Set and save the environment properly.

-  environ = os.environ.copy()

-  environ.update(env_cmd[0])

-  p = gtest_test_utils.Subprocess(env_cmd[1], env=environ)

-

-  return p.output

-

-

-def GetCommandOutput(env_cmd):

-  """Runs a command and returns its output with all file location

-  info stripped off.

-

-  Args:

-    env_cmd:  The shell command. A 2-tuple where element 0 is a dict of extra

-              environment variables to set, and element 1 is a string with

-              the command and any flags.

-  """

-

-  # Disables exception pop-ups on Windows.

-  environ, cmdline = env_cmd

-  environ = dict(environ)  # Ensures we are modifying a copy.

-  environ[CATCH_EXCEPTIONS_ENV_VAR_NAME] = '1'

-  return NormalizeOutput(GetShellCommandOutput((environ, cmdline)))

-

-

-def GetOutputOfAllCommands():

-  """Returns concatenated output from several representative commands."""

-

-  return (GetCommandOutput(COMMAND_WITH_COLOR) +

-          GetCommandOutput(COMMAND_WITH_TIME) +

-          GetCommandOutput(COMMAND_WITH_DISABLED) +

-          GetCommandOutput(COMMAND_WITH_SHARDING))

-

-

-test_list = GetShellCommandOutput(COMMAND_LIST_TESTS)

-SUPPORTS_DEATH_TESTS = 'DeathTest' in test_list

-SUPPORTS_TYPED_TESTS = 'TypedTest' in test_list

-SUPPORTS_THREADS = 'ExpectFailureWithThreadsTest' in test_list

-SUPPORTS_STACK_TRACES = False

-

-CAN_GENERATE_GOLDEN_FILE = (SUPPORTS_DEATH_TESTS and

-                            SUPPORTS_TYPED_TESTS and

-                            SUPPORTS_THREADS)

-

-

-class GTestOutputTest(gtest_test_utils.TestCase):

-  def RemoveUnsupportedTests(self, test_output):

-    if not SUPPORTS_DEATH_TESTS:

-      test_output = RemoveMatchingTests(test_output, 'DeathTest')

-    if not SUPPORTS_TYPED_TESTS:

-      test_output = RemoveMatchingTests(test_output, 'TypedTest')

-      test_output = RemoveMatchingTests(test_output, 'TypedDeathTest')

-      test_output = RemoveMatchingTests(test_output, 'TypeParamDeathTest')

-    if not SUPPORTS_THREADS:

-      test_output = RemoveMatchingTests(test_output,

-                                        'ExpectFailureWithThreadsTest')

-      test_output = RemoveMatchingTests(test_output,

-                                        'ScopedFakeTestPartResultReporterTest')

-      test_output = RemoveMatchingTests(test_output,

-                                        'WorksConcurrently')

-    if not SUPPORTS_STACK_TRACES:

-      test_output = RemoveStackTraces(test_output)

-

-    return test_output

-

-  def testOutput(self):

-    output = GetOutputOfAllCommands()

-

-    golden_file = open(GOLDEN_PATH, 'rb')

-    # A mis-configured source control system can cause \r appear in EOL

-    # sequences when we read the golden file irrespective of an operating

-    # system used. Therefore, we need to strip those \r's from newlines

-    # unconditionally.

-    golden = ToUnixLineEnding(golden_file.read())

-    golden_file.close()

-

-    # We want the test to pass regardless of certain features being

-    # supported or not.

-

-    # We still have to remove type name specifics in all cases.

-    normalized_actual = RemoveTypeInfoDetails(output)

-    normalized_golden = RemoveTypeInfoDetails(golden)

-

-    if CAN_GENERATE_GOLDEN_FILE:

-      self.assertEqual(normalized_golden, normalized_actual)

-    else:

-      normalized_actual = NormalizeToCurrentPlatform(

-          RemoveTestCounts(normalized_actual))

-      normalized_golden = NormalizeToCurrentPlatform(

-          RemoveTestCounts(self.RemoveUnsupportedTests(normalized_golden)))

-

-      # This code is very handy when debugging golden file differences:

-      if os.getenv('DEBUG_GTEST_OUTPUT_TEST'):

-        open(os.path.join(

-            gtest_test_utils.GetSourceDir(),

-            '_gtest_output_test_normalized_actual.txt'), 'wb').write(

-                normalized_actual)

-        open(os.path.join(

-            gtest_test_utils.GetSourceDir(),

-            '_gtest_output_test_normalized_golden.txt'), 'wb').write(

-                normalized_golden)

-

-      self.assertEqual(normalized_golden, normalized_actual)

-

-

-if __name__ == '__main__':

-  if sys.argv[1:] == [GENGOLDEN_FLAG]:

-    if CAN_GENERATE_GOLDEN_FILE:

-      output = GetOutputOfAllCommands()

-      golden_file = open(GOLDEN_PATH, 'wb')

-      golden_file.write(output)

-      golden_file.close()

-    else:

-      message = (

-          """Unable to write a golden file when compiled in an environment

-that does not support all the required features (death tests, typed tests,

-and multiple threads).  Please generate the golden file using a binary built

-with those features enabled.""")

-

-      sys.stderr.write(message)

-      sys.exit(1)

-  else:

-    gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Tests the text output of Google C++ Testing Framework.
+
+SYNOPSIS
+       gtest_output_test.py --build_dir=BUILD/DIR --gengolden
+         # where BUILD/DIR contains the built gtest_output_test_ file.
+       gtest_output_test.py --gengolden
+       gtest_output_test.py
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+import sys
+import gtest_test_utils
+
+
+# The flag for generating the golden file
+GENGOLDEN_FLAG = '--gengolden'
+CATCH_EXCEPTIONS_ENV_VAR_NAME = 'GTEST_CATCH_EXCEPTIONS'
+
+IS_WINDOWS = os.name == 'nt'
+
+# TODO(vladl@google.com): remove the _lin suffix.
+GOLDEN_NAME = 'gtest_output_test_golden_lin.txt'
+
+PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_output_test_')
+
+# At least one command we exercise must not have the
+# --gtest_internal_skip_environment_and_ad_hoc_tests flag.
+COMMAND_LIST_TESTS = ({}, [PROGRAM_PATH, '--gtest_list_tests'])
+COMMAND_WITH_COLOR = ({}, [PROGRAM_PATH, '--gtest_color=yes'])
+COMMAND_WITH_TIME = ({}, [PROGRAM_PATH,
+                          '--gtest_print_time',
+                          '--gtest_internal_skip_environment_and_ad_hoc_tests',
+                          '--gtest_filter=FatalFailureTest.*:LoggingTest.*'])
+COMMAND_WITH_DISABLED = (
+    {}, [PROGRAM_PATH,
+         '--gtest_also_run_disabled_tests',
+         '--gtest_internal_skip_environment_and_ad_hoc_tests',
+         '--gtest_filter=*DISABLED_*'])
+COMMAND_WITH_SHARDING = (
+    {'GTEST_SHARD_INDEX': '1', 'GTEST_TOTAL_SHARDS': '2'},
+    [PROGRAM_PATH,
+     '--gtest_internal_skip_environment_and_ad_hoc_tests',
+     '--gtest_filter=PassingTest.*'])
+
+GOLDEN_PATH = os.path.join(gtest_test_utils.GetSourceDir(), GOLDEN_NAME)
+
+
+def ToUnixLineEnding(s):
+  """Changes all Windows/Mac line endings in s to UNIX line endings."""
+
+  return s.replace('\r\n', '\n').replace('\r', '\n')
+
+
+def RemoveLocations(test_output):
+  """Removes all file location info from a Google Test program's output.
+
+  Args:
+       test_output:  the output of a Google Test program.
+
+  Returns:
+       output with all file location info (in the form of
+       'DIRECTORY/FILE_NAME:LINE_NUMBER: 'or
+       'DIRECTORY\\FILE_NAME(LINE_NUMBER): ') replaced by
+       'FILE_NAME:#: '.
+  """
+
+  return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\: ', r'\1:#: ', test_output)
+
+
+def RemoveStackTraceDetails(output):
+  """Removes all stack traces from a Google Test program's output."""
+
+  # *? means "find the shortest string that matches".
+  return re.sub(r'Stack trace:(.|\n)*?\n\n',
+                'Stack trace: (omitted)\n\n', output)
+
+
+def RemoveStackTraces(output):
+  """Removes all traces of stack traces from a Google Test program's output."""
+
+  # *? means "find the shortest string that matches".
+  return re.sub(r'Stack trace:(.|\n)*?\n\n', '', output)
+
+
+def RemoveTime(output):
+  """Removes all time information from a Google Test program's output."""
+
+  return re.sub(r'\(\d+ ms', '(? ms', output)
+
+
+def RemoveTypeInfoDetails(test_output):
+  """Removes compiler-specific type info from Google Test program's output.
+
+  Args:
+       test_output:  the output of a Google Test program.
+
+  Returns:
+       output with type information normalized to canonical form.
+  """
+
+  # some compilers output the name of type 'unsigned int' as 'unsigned'
+  return re.sub(r'unsigned int', 'unsigned', test_output)
+
+
+def NormalizeToCurrentPlatform(test_output):
+  """Normalizes platform specific output details for easier comparison."""
+
+  if IS_WINDOWS:
+    # Removes the color information that is not present on Windows.
+    test_output = re.sub('\x1b\\[(0;3\d)?m', '', test_output)
+    # Changes failure message headers into the Windows format.
+    test_output = re.sub(r': Failure\n', r': error: ', test_output)
+    # Changes file(line_number) to file:line_number.
+    test_output = re.sub(r'((\w|\.)+)\((\d+)\):', r'\1:\3:', test_output)
+
+  return test_output
+
+
+def RemoveTestCounts(output):
+  """Removes test counts from a Google Test program's output."""
+
+  output = re.sub(r'\d+ tests?, listed below',
+                  '? tests, listed below', output)
+  output = re.sub(r'\d+ FAILED TESTS',
+                  '? FAILED TESTS', output)
+  output = re.sub(r'\d+ tests? from \d+ test cases?',
+                  '? tests from ? test cases', output)
+  output = re.sub(r'\d+ tests? from ([a-zA-Z_])',
+                  r'? tests from \1', output)
+  return re.sub(r'\d+ tests?\.', '? tests.', output)
+
+
+def RemoveMatchingTests(test_output, pattern):
+  """Removes output of specified tests from a Google Test program's output.
+
+  This function strips not only the beginning and the end of a test but also
+  all output in between.
+
+  Args:
+    test_output:       A string containing the test output.
+    pattern:           A regex string that matches names of test cases or
+                       tests to remove.
+
+  Returns:
+    Contents of test_output with tests whose names match pattern removed.
+  """
+
+  test_output = re.sub(
+      r'.*\[ RUN      \] .*%s(.|\n)*?\[(  FAILED  |       OK )\] .*%s.*\n' % (
+          pattern, pattern),
+      '',
+      test_output)
+  return re.sub(r'.*%s.*\n' % pattern, '', test_output)
+
+
+def NormalizeOutput(output):
+  """Normalizes output (the output of gtest_output_test_.exe)."""
+
+  output = ToUnixLineEnding(output)
+  output = RemoveLocations(output)
+  output = RemoveStackTraceDetails(output)
+  output = RemoveTime(output)
+  return output
+
+
+def GetShellCommandOutput(env_cmd):
+  """Runs a command in a sub-process, and returns its output in a string.
+
+  Args:
+    env_cmd: The shell command. A 2-tuple where element 0 is a dict of extra
+             environment variables to set, and element 1 is a string with
+             the command and any flags.
+
+  Returns:
+    A string with the command's combined standard and diagnostic output.
+  """
+
+  # Spawns cmd in a sub-process, and gets its standard I/O file objects.
+  # Set and save the environment properly.
+  environ = os.environ.copy()
+  environ.update(env_cmd[0])
+  p = gtest_test_utils.Subprocess(env_cmd[1], env=environ)
+
+  return p.output
+
+
+def GetCommandOutput(env_cmd):
+  """Runs a command and returns its output with all file location
+  info stripped off.
+
+  Args:
+    env_cmd:  The shell command. A 2-tuple where element 0 is a dict of extra
+              environment variables to set, and element 1 is a string with
+              the command and any flags.
+  """
+
+  # Disables exception pop-ups on Windows.
+  environ, cmdline = env_cmd
+  environ = dict(environ)  # Ensures we are modifying a copy.
+  environ[CATCH_EXCEPTIONS_ENV_VAR_NAME] = '1'
+  return NormalizeOutput(GetShellCommandOutput((environ, cmdline)))
+
+
+def GetOutputOfAllCommands():
+  """Returns concatenated output from several representative commands."""
+
+  return (GetCommandOutput(COMMAND_WITH_COLOR) +
+          GetCommandOutput(COMMAND_WITH_TIME) +
+          GetCommandOutput(COMMAND_WITH_DISABLED) +
+          GetCommandOutput(COMMAND_WITH_SHARDING))
+
+
+test_list = GetShellCommandOutput(COMMAND_LIST_TESTS)
+SUPPORTS_DEATH_TESTS = 'DeathTest' in test_list
+SUPPORTS_TYPED_TESTS = 'TypedTest' in test_list
+SUPPORTS_THREADS = 'ExpectFailureWithThreadsTest' in test_list
+SUPPORTS_STACK_TRACES = False
+
+CAN_GENERATE_GOLDEN_FILE = (SUPPORTS_DEATH_TESTS and
+                            SUPPORTS_TYPED_TESTS and
+                            SUPPORTS_THREADS)
+
+
+class GTestOutputTest(gtest_test_utils.TestCase):
+  def RemoveUnsupportedTests(self, test_output):
+    if not SUPPORTS_DEATH_TESTS:
+      test_output = RemoveMatchingTests(test_output, 'DeathTest')
+    if not SUPPORTS_TYPED_TESTS:
+      test_output = RemoveMatchingTests(test_output, 'TypedTest')
+      test_output = RemoveMatchingTests(test_output, 'TypedDeathTest')
+      test_output = RemoveMatchingTests(test_output, 'TypeParamDeathTest')
+    if not SUPPORTS_THREADS:
+      test_output = RemoveMatchingTests(test_output,
+                                        'ExpectFailureWithThreadsTest')
+      test_output = RemoveMatchingTests(test_output,
+                                        'ScopedFakeTestPartResultReporterTest')
+      test_output = RemoveMatchingTests(test_output,
+                                        'WorksConcurrently')
+    if not SUPPORTS_STACK_TRACES:
+      test_output = RemoveStackTraces(test_output)
+
+    return test_output
+
+  def testOutput(self):
+    output = GetOutputOfAllCommands()
+
+    golden_file = open(GOLDEN_PATH, 'rb')
+    # A mis-configured source control system can cause \r appear in EOL
+    # sequences when we read the golden file irrespective of an operating
+    # system used. Therefore, we need to strip those \r's from newlines
+    # unconditionally.
+    golden = ToUnixLineEnding(golden_file.read())
+    golden_file.close()
+
+    # We want the test to pass regardless of certain features being
+    # supported or not.
+
+    # We still have to remove type name specifics in all cases.
+    normalized_actual = RemoveTypeInfoDetails(output)
+    normalized_golden = RemoveTypeInfoDetails(golden)
+
+    if CAN_GENERATE_GOLDEN_FILE:
+      self.assertEqual(normalized_golden, normalized_actual)
+    else:
+      normalized_actual = NormalizeToCurrentPlatform(
+          RemoveTestCounts(normalized_actual))
+      normalized_golden = NormalizeToCurrentPlatform(
+          RemoveTestCounts(self.RemoveUnsupportedTests(normalized_golden)))
+
+      # This code is very handy when debugging golden file differences:
+      if os.getenv('DEBUG_GTEST_OUTPUT_TEST'):
+        open(os.path.join(
+            gtest_test_utils.GetSourceDir(),
+            '_gtest_output_test_normalized_actual.txt'), 'wb').write(
+                normalized_actual)
+        open(os.path.join(
+            gtest_test_utils.GetSourceDir(),
+            '_gtest_output_test_normalized_golden.txt'), 'wb').write(
+                normalized_golden)
+
+      self.assertEqual(normalized_golden, normalized_actual)
+
+
+if __name__ == '__main__':
+  if sys.argv[1:] == [GENGOLDEN_FLAG]:
+    if CAN_GENERATE_GOLDEN_FILE:
+      output = GetOutputOfAllCommands()
+      golden_file = open(GOLDEN_PATH, 'wb')
+      golden_file.write(output)
+      golden_file.close()
+    else:
+      message = (
+          """Unable to write a golden file when compiled in an environment
+that does not support all the required features (death tests, typed tests,
+and multiple threads).  Please generate the golden file using a binary built
+with those features enabled.""")
+
+      sys.stderr.write(message)
+      sys.exit(1)
+  else:
+    gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_output_test_.cc b/gtest-1.6.0/test/gtest_output_test_.cc
index 3f5ed65..13dbec4 100644
--- a/gtest-1.6.0/test/gtest_output_test_.cc
+++ b/gtest-1.6.0/test/gtest_output_test_.cc
@@ -1,1020 +1,1020 @@
-// 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: wan@google.com (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_IS_THREADSAFE

-using testing::ScopedFakeTestPartResultReporter;

-using testing::TestPartResultArray;

-

-using testing::internal::Notification;

-using testing::internal::ThreadWithParam;

-#endif

-

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

-using testing::internal::String;

-using testing::internal::scoped_ptr;

-

-// 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 that parameters of failing parameterized tests are printed in the

-// failing test summary.

-class FailingParamTest : public testing::TestWithParam<int> {};

-

-TEST_P(FailingParamTest, Fails) {

-  EXPECT_EQ(1, GetParam());

-}

-

-// This generates a test which will fail. Google Test is expected to print

-// its parameter when it outputs the list of all failed tests.

-INSTANTIATE_TEST_CASE_P(PrintingFailingParams,

-                        FailingParamTest,

-                        testing::Values(2));

-

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

-}

-

-#if GTEST_IS_THREADSAFE

-// Tests that SCOPED_TRACE()s can be used concurrently from multiple

-// threads.  Namely, an assertion should be affected by

-// SCOPED_TRACE()s in its own thread only.

-

-// Here's the sequence of actions that happen in the test:

-//

-//   Thread A (main)                | Thread B (spawned)

-//   ===============================|================================

-//   spawns thread B                |

-//   -------------------------------+--------------------------------

-//   waits for n1                   | SCOPED_TRACE("Trace B");

-//                                  | generates failure #1

-//                                  | notifies n1

-//   -------------------------------+--------------------------------

-//   SCOPED_TRACE("Trace A");       | waits for n2

-//   generates failure #2           |

-//   notifies n2                    |

-//   -------------------------------|--------------------------------

-//   waits for n3                   | generates failure #3

-//                                  | trace B dies

-//                                  | generates failure #4

-//                                  | notifies n3

-//   -------------------------------|--------------------------------

-//   generates failure #5           | finishes

-//   trace A dies                   |

-//   generates failure #6           |

-//   -------------------------------|--------------------------------

-//   waits for thread B to finish   |

-

-struct CheckPoints {

-  Notification n1;

-  Notification n2;

-  Notification n3;

-};

-

-static void ThreadWithScopedTrace(CheckPoints* check_points) {

-  {

-    SCOPED_TRACE("Trace B");

-    ADD_FAILURE()

-        << "Expected failure #1 (in thread B, only trace B alive).";

-    check_points->n1.Notify();

-    check_points->n2.WaitForNotification();

-

-    ADD_FAILURE()

-        << "Expected failure #3 (in thread B, trace A & B both alive).";

-  }  // Trace B dies here.

-  ADD_FAILURE()

-      << "Expected failure #4 (in thread B, only trace A alive).";

-  check_points->n3.Notify();

-}

-

-TEST(SCOPED_TRACETest, WorksConcurrently) {

-  printf("(expecting 6 failures)\n");

-

-  CheckPoints check_points;

-  ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace,

-                                       &check_points,

-                                       NULL);

-  check_points.n1.WaitForNotification();

-

-  {

-    SCOPED_TRACE("Trace A");

-    ADD_FAILURE()

-        << "Expected failure #2 (in thread A, trace A & B both alive).";

-    check_points.n2.Notify();

-    check_points.n3.WaitForNotification();

-

-    ADD_FAILURE()

-        << "Expected failure #5 (in thread A, only trace A alive).";

-  }  // Trace A dies here.

-  ADD_FAILURE()

-      << "Expected failure #6 (in thread A, no trace alive).";

-  thread.Join();

-}

-#endif  // GTEST_IS_THREADSAFE

-

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

-}

-

-TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {

-  ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc";

-}

-

-#if GTEST_IS_THREADSAFE

-

-// A unary function that may die.

-void DieIf(bool should_die) {

-  GTEST_CHECK_(!should_die) << " - death inside DieIf().";

-}

-

-// Tests running death tests in a multi-threaded context.

-

-// Used for coordination between the main and the spawn thread.

-struct SpawnThreadNotifications {

-  SpawnThreadNotifications() {}

-

-  Notification spawn_thread_started;

-  Notification spawn_thread_ok_to_terminate;

-

- private:

-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SpawnThreadNotifications);

-};

-

-// The function to be executed in the thread spawn by the

-// MultipleThreads test (below).

-static void ThreadRoutine(SpawnThreadNotifications* notifications) {

-  // Signals the main thread that this thread has started.

-  notifications->spawn_thread_started.Notify();

-

-  // Waits for permission to finish from the main thread.

-  notifications->spawn_thread_ok_to_terminate.WaitForNotification();

-}

-

-// This is a death-test test, but it's not named with a DeathTest

-// suffix.  It starts threads which might interfere with later

-// death tests, so it must run after all other death tests.

-class DeathTestAndMultiThreadsTest : public testing::Test {

- protected:

-  // Starts a thread and waits for it to begin.

-  virtual void SetUp() {

-    thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>(

-        &ThreadRoutine, &notifications_, NULL));

-    notifications_.spawn_thread_started.WaitForNotification();

-  }

-  // Tells the thread to finish, and reaps it.

-  // Depending on the version of the thread library in use,

-  // a manager thread might still be left running that will interfere

-  // with later death tests.  This is unfortunate, but this class

-  // cleans up after itself as best it can.

-  virtual void TearDown() {

-    notifications_.spawn_thread_ok_to_terminate.Notify();

-  }

-

- private:

-  SpawnThreadNotifications notifications_;

-  scoped_ptr<ThreadWithParam<SpawnThreadNotifications*> > thread_;

-};

-

-#endif  // GTEST_IS_THREADSAFE

-

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

-

-class ExpectFailureWithThreadsTest : public ExpectFailureTest {

- protected:

-  static void AddFailureInOtherThread(FailureMode failure) {

-    ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);

-    thread.Join();

-  }

-};

-

-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

-

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

-  }

-};

-

-bool GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests) = false;

-

-// 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: wan@google.com (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_IS_THREADSAFE
+using testing::ScopedFakeTestPartResultReporter;
+using testing::TestPartResultArray;
+
+using testing::internal::Notification;
+using testing::internal::ThreadWithParam;
+#endif
+
+namespace posix = ::testing::internal::posix;
+using testing::internal::String;
+using testing::internal::scoped_ptr;
+
+// 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 that parameters of failing parameterized tests are printed in the
+// failing test summary.
+class FailingParamTest : public testing::TestWithParam<int> {};
+
+TEST_P(FailingParamTest, Fails) {
+  EXPECT_EQ(1, GetParam());
+}
+
+// This generates a test which will fail. Google Test is expected to print
+// its parameter when it outputs the list of all failed tests.
+INSTANTIATE_TEST_CASE_P(PrintingFailingParams,
+                        FailingParamTest,
+                        testing::Values(2));
+
+// 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.";
+}
+
+#if GTEST_IS_THREADSAFE
+// Tests that SCOPED_TRACE()s can be used concurrently from multiple
+// threads.  Namely, an assertion should be affected by
+// SCOPED_TRACE()s in its own thread only.
+
+// Here's the sequence of actions that happen in the test:
+//
+//   Thread A (main)                | Thread B (spawned)
+//   ===============================|================================
+//   spawns thread B                |
+//   -------------------------------+--------------------------------
+//   waits for n1                   | SCOPED_TRACE("Trace B");
+//                                  | generates failure #1
+//                                  | notifies n1
+//   -------------------------------+--------------------------------
+//   SCOPED_TRACE("Trace A");       | waits for n2
+//   generates failure #2           |
+//   notifies n2                    |
+//   -------------------------------|--------------------------------
+//   waits for n3                   | generates failure #3
+//                                  | trace B dies
+//                                  | generates failure #4
+//                                  | notifies n3
+//   -------------------------------|--------------------------------
+//   generates failure #5           | finishes
+//   trace A dies                   |
+//   generates failure #6           |
+//   -------------------------------|--------------------------------
+//   waits for thread B to finish   |
+
+struct CheckPoints {
+  Notification n1;
+  Notification n2;
+  Notification n3;
+};
+
+static void ThreadWithScopedTrace(CheckPoints* check_points) {
+  {
+    SCOPED_TRACE("Trace B");
+    ADD_FAILURE()
+        << "Expected failure #1 (in thread B, only trace B alive).";
+    check_points->n1.Notify();
+    check_points->n2.WaitForNotification();
+
+    ADD_FAILURE()
+        << "Expected failure #3 (in thread B, trace A & B both alive).";
+  }  // Trace B dies here.
+  ADD_FAILURE()
+      << "Expected failure #4 (in thread B, only trace A alive).";
+  check_points->n3.Notify();
+}
+
+TEST(SCOPED_TRACETest, WorksConcurrently) {
+  printf("(expecting 6 failures)\n");
+
+  CheckPoints check_points;
+  ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace,
+                                       &check_points,
+                                       NULL);
+  check_points.n1.WaitForNotification();
+
+  {
+    SCOPED_TRACE("Trace A");
+    ADD_FAILURE()
+        << "Expected failure #2 (in thread A, trace A & B both alive).";
+    check_points.n2.Notify();
+    check_points.n3.WaitForNotification();
+
+    ADD_FAILURE()
+        << "Expected failure #5 (in thread A, only trace A alive).";
+  }  // Trace A dies here.
+  ADD_FAILURE()
+      << "Expected failure #6 (in thread A, no trace alive).";
+  thread.Join();
+}
+#endif  // GTEST_IS_THREADSAFE
+
+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.";
+}
+
+TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {
+  ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc";
+}
+
+#if GTEST_IS_THREADSAFE
+
+// A unary function that may die.
+void DieIf(bool should_die) {
+  GTEST_CHECK_(!should_die) << " - death inside DieIf().";
+}
+
+// Tests running death tests in a multi-threaded context.
+
+// Used for coordination between the main and the spawn thread.
+struct SpawnThreadNotifications {
+  SpawnThreadNotifications() {}
+
+  Notification spawn_thread_started;
+  Notification spawn_thread_ok_to_terminate;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SpawnThreadNotifications);
+};
+
+// The function to be executed in the thread spawn by the
+// MultipleThreads test (below).
+static void ThreadRoutine(SpawnThreadNotifications* notifications) {
+  // Signals the main thread that this thread has started.
+  notifications->spawn_thread_started.Notify();
+
+  // Waits for permission to finish from the main thread.
+  notifications->spawn_thread_ok_to_terminate.WaitForNotification();
+}
+
+// This is a death-test test, but it's not named with a DeathTest
+// suffix.  It starts threads which might interfere with later
+// death tests, so it must run after all other death tests.
+class DeathTestAndMultiThreadsTest : public testing::Test {
+ protected:
+  // Starts a thread and waits for it to begin.
+  virtual void SetUp() {
+    thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>(
+        &ThreadRoutine, &notifications_, NULL));
+    notifications_.spawn_thread_started.WaitForNotification();
+  }
+  // Tells the thread to finish, and reaps it.
+  // Depending on the version of the thread library in use,
+  // a manager thread might still be left running that will interfere
+  // with later death tests.  This is unfortunate, but this class
+  // cleans up after itself as best it can.
+  virtual void TearDown() {
+    notifications_.spawn_thread_ok_to_terminate.Notify();
+  }
+
+ private:
+  SpawnThreadNotifications notifications_;
+  scoped_ptr<ThreadWithParam<SpawnThreadNotifications*> > thread_;
+};
+
+#endif  // GTEST_IS_THREADSAFE
+
+// 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
+
+class ExpectFailureWithThreadsTest : public ExpectFailureTest {
+ protected:
+  static void AddFailureInOtherThread(FailureMode failure) {
+    ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
+    thread.Join();
+  }
+};
+
+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
+
+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.";
+  }
+};
+
+bool GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests) = false;
+
+// 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/gtest-1.6.0/test/gtest_output_test_golden_lin.txt b/gtest-1.6.0/test/gtest_output_test_golden_lin.txt
index bd2032a..a1d342d 100644
--- a/gtest-1.6.0/test/gtest_output_test_golden_lin.txt
+++ b/gtest-1.6.0/test/gtest_output_test_golden_lin.txt
@@ -1,711 +1,711 @@
-The non-test part of the code is expected to have 2 failures.

-

-gtest_output_test_.cc:#: Failure

-Value of: false

-  Actual: false

-Expected: true

-gtest_output_test_.cc:#: Failure

-Value of: 3

-Expected: 2

-[==========] Running 62 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:#: Failure

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

-Value of: x

-  Actual: 2

-Expected: 1

-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine

-[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine

-(expecting a failure on false)

-gtest_output_test_.cc:#: Failure

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

-Expected: (3) >= (a[i]), actual: 3 vs 9

-i == 2

-i == 3

-gtest_output_test_.cc:#: Failure

-Expected: (3) >= (a[i]), actual: 3 vs 6

-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions

-[----------] 6 tests from SCOPED_TRACETest

-[ RUN      ] SCOPED_TRACETest.ObeysScopes

-(expected to fail)

-gtest_output_test_.cc:#: Failure

-Failed

-This failure is expected, and shouldn't have a trace.

-gtest_output_test_.cc:#: Failure

-Failed

-This failure is expected, and should have a trace.

-Google Test trace:

-gtest_output_test_.cc:#: Expected trace

-gtest_output_test_.cc:#: Failure

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

-Value of: n

-  Actual: 1

-Expected: 2

-Google Test trace:

-gtest_output_test_.cc:#: i = 1

-gtest_output_test_.cc:#: Failure

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

-Value of: n

-  Actual: 1

-Expected: 2

-Google Test trace:

-gtest_output_test_.cc:#: n = 1

-gtest_output_test_.cc:#: Failure

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

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

-Failed

-This failure is expected, and should contain trace point A.

-Google Test trace:

-gtest_output_test_.cc:#: A

-gtest_output_test_.cc:#: Failure

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

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

-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

-[ RUN      ] SCOPED_TRACETest.WorksConcurrently

-(expecting 6 failures)

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #1 (in thread B, only trace B alive).

-Google Test trace:

-gtest_output_test_.cc:#: Trace B

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #2 (in thread A, trace A & B both alive).

-Google Test trace:

-gtest_output_test_.cc:#: Trace A

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #3 (in thread B, trace A & B both alive).

-Google Test trace:

-gtest_output_test_.cc:#: Trace B

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #4 (in thread B, only trace A alive).

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #5 (in thread A, only trace A alive).

-Google Test trace:

-gtest_output_test_.cc:#: Trace A

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #6 (in thread A, no trace alive).

-[  FAILED  ] SCOPED_TRACETest.WorksConcurrently

-[----------] 1 test from NonFatalFailureInFixtureConstructorTest

-[ RUN      ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor

-(expecting 5 failures)

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #1, in the test fixture c'tor.

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #2, in SetUp().

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #3, in the test body.

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #4, in TearDown.

-gtest_output_test_.cc:#: Failure

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

-Failed

-Expected failure #1, in the test fixture c'tor.

-gtest_output_test_.cc:#: Failure

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

-Failed

-Expected failure #1, in SetUp().

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #2, in the test function.

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #3, in TearDown().

-gtest_output_test_.cc:#: Failure

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

-Failed

-Expected failure #1, in SetUp().

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #2, in TearDown().

-gtest_output_test_.cc:#: Failure

-Failed

-Expected failure #3, in the test fixture d'tor.

-[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp

-[----------] 1 test from AddFailureAtTest

-[ RUN      ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber

-foo.cc:42: Failure

-Failed

-Expected failure in foo.cc

-[  FAILED  ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber

-[----------] 4 tests from MixedUpTestCaseTest

-[ RUN      ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo

-[       OK ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo

-[ RUN      ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo

-[       OK ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo

-[ RUN      ] MixedUpTestCaseTest.ThisShouldFail

-gtest.cc:#: Failure

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

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

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

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

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

-Expected: 1 non-fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure

-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures

-(expecting a failure)

-gtest.cc:#: Failure

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

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

-Expected: 1 non-fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns

-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementThrows

-(expecting a failure)

-gtest.cc:#: Failure

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

-Expected: 1 fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure

-[ RUN      ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures

-(expecting a failure)

-gtest.cc:#: Failure

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

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

-Expected: 1 fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns

-[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementThrows

-(expecting a failure)

-gtest.cc:#: Failure

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

-Value of: TypeParam()

-  Actual: 0

-Expected: 1

-Expected failure

-[  FAILED  ] TypedTest/0.Failure, where TypeParam = int

-[----------] 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:#: Failure

-Value of: TypeParam()

-  Actual: '\0'

-Expected: 1U

-Which is: 1

-Expected failure

-[  FAILED  ] Unsigned/TypedTestP/0.Failure, where TypeParam = unsigned char

-[----------] 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:#: Failure

-Value of: TypeParam()

-  Actual: 0

-Expected: 1U

-Which is: 1

-Expected failure

-[  FAILED  ] Unsigned/TypedTestP/1.Failure, where TypeParam = unsigned int

-[----------] 4 tests from ExpectFailureTest

-[ RUN      ] ExpectFailureTest.ExpectFatalFailure

-(expecting 1 failure)

-gtest.cc:#: Failure

-Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Success:

-Succeeded

-

-(expecting 1 failure)

-gtest.cc:#: Failure

-Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure.

-

-(expecting 1 failure)

-gtest.cc:#: Failure

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

-Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Success:

-Succeeded

-

-(expecting 1 failure)

-gtest.cc:#: Failure

-Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-(expecting 1 failure)

-gtest.cc:#: Failure

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

-Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Success:

-Succeeded

-

-(expecting 1 failure)

-gtest.cc:#: Failure

-Expected: 1 fatal failure

-  Actual:

-gtest_output_test_.cc:#: Non-fatal failure:

-Failed

-Expected non-fatal failure.

-

-(expecting 1 failure)

-gtest.cc:#: Failure

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

-Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Success:

-Succeeded

-

-(expecting 1 failure)

-gtest.cc:#: Failure

-Expected: 1 non-fatal failure

-  Actual:

-gtest_output_test_.cc:#: Fatal failure:

-Failed

-Expected fatal failure.

-

-(expecting 1 failure)

-gtest.cc:#: Failure

-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

-[----------] 2 tests from ExpectFailureWithThreadsTest

-[ RUN      ] ExpectFailureWithThreadsTest.ExpectFatalFailure

-(expecting 2 failures)

-gtest_output_test_.cc:#: Failure

-Failed

-Expected fatal failure.

-gtest.cc:#: Failure

-Expected: 1 fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectFailureWithThreadsTest.ExpectFatalFailure

-[ RUN      ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure

-(expecting 2 failures)

-gtest_output_test_.cc:#: Failure

-Failed

-Expected non-fatal failure.

-gtest.cc:#: Failure

-Expected: 1 non-fatal failure

-  Actual: 0 failures

-[  FAILED  ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure

-[----------] 1 test from ScopedFakeTestPartResultReporterTest

-[ RUN      ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread

-(expecting 2 failures)

-gtest_output_test_.cc:#: Failure

-Failed

-Expected fatal failure.

-gtest_output_test_.cc:#: Failure

-Failed

-Expected non-fatal failure.

-[  FAILED  ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread

-[----------] 1 test from PrintingFailingParams/FailingParamTest

-[ RUN      ] PrintingFailingParams/FailingParamTest.Fails/0

-gtest_output_test_.cc:#: Failure

-Value of: GetParam()

-  Actual: 2

-Expected: 1

-[  FAILED  ] PrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2

-[----------] Global test environment tear-down

-BarEnvironment::TearDown() called.

-gtest_output_test_.cc:#: Failure

-Failed

-Expected non-fatal failure.

-FooEnvironment::TearDown() called.

-gtest_output_test_.cc:#: Failure

-Failed

-Expected fatal failure.

-[==========] 62 tests from 27 test cases ran.

-[  PASSED  ] 21 tests.

-[  FAILED  ] 41 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  ] SCOPED_TRACETest.WorksConcurrently

-[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor

-[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor

-[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp

-[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp

-[  FAILED  ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber

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

-[  FAILED  ] ExpectFailureWithThreadsTest.ExpectFatalFailure

-[  FAILED  ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure

-[  FAILED  ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread

-[  FAILED  ] PrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2

-

-41 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:#: Failure

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

-Value of: x

-  Actual: 2

-Expected: 1

-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)

-[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine

-(expecting a failure on false)

-gtest_output_test_.cc:#: Failure

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

-Expected: (3) >= (a[i]), actual: 3 vs 9

-i == 2

-i == 3

-gtest_output_test_.cc:#: Failure

-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 2 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:#: Failure
+Value of: false
+  Actual: false
+Expected: true
+gtest_output_test_.cc:#: Failure
+Value of: 3
+Expected: 2
+[==========] Running 62 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:#: Failure
+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:#: Failure
+Value of: x
+  Actual: 2
+Expected: 1
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
+[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
+(expecting a failure on false)
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+Expected: (3) >= (a[i]), actual: 3 vs 9
+i == 2
+i == 3
+gtest_output_test_.cc:#: Failure
+Expected: (3) >= (a[i]), actual: 3 vs 6
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
+[----------] 6 tests from SCOPED_TRACETest
+[ RUN      ] SCOPED_TRACETest.ObeysScopes
+(expected to fail)
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and shouldn't have a trace.
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and should have a trace.
+Google Test trace:
+gtest_output_test_.cc:#: Expected trace
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+Value of: n
+  Actual: 1
+Expected: 2
+Google Test trace:
+gtest_output_test_.cc:#: i = 1
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+Value of: n
+  Actual: 1
+Expected: 2
+Google Test trace:
+gtest_output_test_.cc:#: n = 1
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+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:#: Failure
+Failed
+This failure is expected, and should contain trace point A.
+Google Test trace:
+gtest_output_test_.cc:#: A
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+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:#: Failure
+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
+[ RUN      ] SCOPED_TRACETest.WorksConcurrently
+(expecting 6 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #1 (in thread B, only trace B alive).
+Google Test trace:
+gtest_output_test_.cc:#: Trace B
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2 (in thread A, trace A & B both alive).
+Google Test trace:
+gtest_output_test_.cc:#: Trace A
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #3 (in thread B, trace A & B both alive).
+Google Test trace:
+gtest_output_test_.cc:#: Trace B
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #4 (in thread B, only trace A alive).
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #5 (in thread A, only trace A alive).
+Google Test trace:
+gtest_output_test_.cc:#: Trace A
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #6 (in thread A, no trace alive).
+[  FAILED  ] SCOPED_TRACETest.WorksConcurrently
+[----------] 1 test from NonFatalFailureInFixtureConstructorTest
+[ RUN      ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
+(expecting 5 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #1, in the test fixture c'tor.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2, in SetUp().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #3, in the test body.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #4, in TearDown.
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+Failed
+Expected failure #1, in the test fixture c'tor.
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+Failed
+Expected failure #1, in SetUp().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2, in the test function.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #3, in TearDown().
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+Failed
+Expected failure #1, in SetUp().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2, in TearDown().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #3, in the test fixture d'tor.
+[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp
+[----------] 1 test from AddFailureAtTest
+[ RUN      ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
+foo.cc:42: Failure
+Failed
+Expected failure in foo.cc
+[  FAILED  ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
+[----------] 4 tests from MixedUpTestCaseTest
+[ RUN      ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo
+[       OK ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo
+[ RUN      ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo
+[       OK ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo
+[ RUN      ] MixedUpTestCaseTest.ThisShouldFail
+gtest.cc:#: Failure
+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:#: Failure
+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:#: Failure
+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:#: Failure
+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:#: Failure
+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:#: Failure
+Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
+(expecting a failure)
+gtest.cc:#: Failure
+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:#: Failure
+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:#: Failure
+Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
+(expecting a failure)
+gtest.cc:#: Failure
+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:#: Failure
+Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
+[ RUN      ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
+(expecting a failure)
+gtest.cc:#: Failure
+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:#: Failure
+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:#: Failure
+Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns
+[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementThrows
+(expecting a failure)
+gtest.cc:#: Failure
+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:#: Failure
+Value of: TypeParam()
+  Actual: 0
+Expected: 1
+Expected failure
+[  FAILED  ] TypedTest/0.Failure, where TypeParam = int
+[----------] 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:#: Failure
+Value of: TypeParam()
+  Actual: '\0'
+Expected: 1U
+Which is: 1
+Expected failure
+[  FAILED  ] Unsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
+[----------] 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:#: Failure
+Value of: TypeParam()
+  Actual: 0
+Expected: 1U
+Which is: 1
+Expected failure
+[  FAILED  ] Unsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
+[----------] 4 tests from ExpectFailureTest
+[ RUN      ] ExpectFailureTest.ExpectFatalFailure
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+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:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+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:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+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:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+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
+[----------] 2 tests from ExpectFailureWithThreadsTest
+[ RUN      ] ExpectFailureWithThreadsTest.ExpectFatalFailure
+(expecting 2 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected fatal failure.
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFailureWithThreadsTest.ExpectFatalFailure
+[ RUN      ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
+(expecting 2 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected non-fatal failure.
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
+[----------] 1 test from ScopedFakeTestPartResultReporterTest
+[ RUN      ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
+(expecting 2 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected fatal failure.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected non-fatal failure.
+[  FAILED  ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
+[----------] 1 test from PrintingFailingParams/FailingParamTest
+[ RUN      ] PrintingFailingParams/FailingParamTest.Fails/0
+gtest_output_test_.cc:#: Failure
+Value of: GetParam()
+  Actual: 2
+Expected: 1
+[  FAILED  ] PrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
+[----------] Global test environment tear-down
+BarEnvironment::TearDown() called.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected non-fatal failure.
+FooEnvironment::TearDown() called.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected fatal failure.
+[==========] 62 tests from 27 test cases ran.
+[  PASSED  ] 21 tests.
+[  FAILED  ] 41 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  ] SCOPED_TRACETest.WorksConcurrently
+[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
+[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor
+[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp
+[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp
+[  FAILED  ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
+[  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
+[  FAILED  ] ExpectFailureWithThreadsTest.ExpectFatalFailure
+[  FAILED  ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
+[  FAILED  ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
+[  FAILED  ] PrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
+
+41 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:#: Failure
+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:#: Failure
+Value of: x
+  Actual: 2
+Expected: 1
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)
+[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
+(expecting a failure on false)
+gtest_output_test_.cc:#: Failure
+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:#: Failure
+Expected: (3) >= (a[i]), actual: 3 vs 9
+i == 2
+i == 3
+gtest_output_test_.cc:#: Failure
+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 2 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/gtest-1.6.0/test/gtest_pred_impl_unittest.cc b/gtest-1.6.0/test/gtest_pred_impl_unittest.cc
index c9bf853..35dc9bc 100644
--- a/gtest-1.6.0/test/gtest_pred_impl_unittest.cc
+++ b/gtest-1.6.0/test/gtest_pred_impl_unittest.cc
@@ -1,2427 +1,2427 @@
-// 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 09/24/2010 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();

-

-  return testing::AssertionFailure()

-      << e1

-      << " is expected to be positive, but evaluates to "

-      << v1 << ".";

-}

-

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

-

-  return testing::AssertionFailure()

-      << e1 << " + " << e2

-      << " is expected to be positive, but evaluates to "

-      << v1 + v2 << ".";

-}

-

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

-

-  return testing::AssertionFailure()

-      << e1 << " + " << e2 << " + " << e3

-      << " is expected to be positive, but evaluates to "

-      << v1 + v2 + v3 << ".";

-}

-

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

-

-  return testing::AssertionFailure()

-      << e1 << " + " << e2 << " + " << e3 << " + " << e4

-      << " is expected to be positive, but evaluates to "

-      << v1 + v2 + v3 + v4 << ".";

-}

-

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

-

-  return testing::AssertionFailure()

-      << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5

-      << " is expected to be positive, but evaluates to "

-      << v1 + v2 + v3 + v4 + v5 << ".";

-}

-

-// 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 09/24/2010 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();
+
+  return testing::AssertionFailure()
+      << e1
+      << " is expected to be positive, but evaluates to "
+      << v1 << ".";
+}
+
+// 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();
+
+  return testing::AssertionFailure()
+      << e1 << " + " << e2
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 << ".";
+}
+
+// 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();
+
+  return testing::AssertionFailure()
+      << e1 << " + " << e2 << " + " << e3
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 << ".";
+}
+
+// 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();
+
+  return testing::AssertionFailure()
+      << e1 << " + " << e2 << " + " << e3 << " + " << e4
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 + v4 << ".";
+}
+
+// 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();
+
+  return testing::AssertionFailure()
+      << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 + v4 + v5 << ".";
+}
+
+// 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/gtest-1.6.0/test/gtest_prod_test.cc b/gtest-1.6.0/test/gtest_prod_test.cc
index 0e9cfbe..060abce 100644
--- a/gtest-1.6.0/test/gtest_prod_test.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (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/gtest-1.6.0/test/gtest_repeat_test.cc b/gtest-1.6.0/test/gtest_repeat_test.cc
index c29ab8f..5223dc0 100644
--- a/gtest-1.6.0/test/gtest_repeat_test.cc
+++ b/gtest-1.6.0/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: wan@google.com (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";\

-      ::testing::internal::posix::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(::testing::internal::posix::Abort(), "");

-

-  GTEST_FLAG(death_test_style) = "fast";

-  EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::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(vladl@google.com): 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: wan@google.com (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";\
+      ::testing::internal::posix::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(::testing::internal::posix::Abort(), "");
+
+  GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::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(vladl@google.com): 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/gtest-1.6.0/test/gtest_shuffle_test.py b/gtest-1.6.0/test/gtest_shuffle_test.py
index f1db31c..30d0303 100755
--- a/gtest-1.6.0/test/gtest_shuffle_test.py
+++ b/gtest-1.6.0/test/gtest_shuffle_test.py
@@ -1,325 +1,325 @@
-#!/usr/bin/env python

-#

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

-

-"""Verifies that test shuffling works."""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import os

-import gtest_test_utils

-

-# Command to run the gtest_shuffle_test_ program.

-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_shuffle_test_')

-

-# The environment variables for test sharding.

-TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'

-SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'

-

-TEST_FILTER = 'A*.A:A*.B:C*'

-

-ALL_TESTS = []

-ACTIVE_TESTS = []

-FILTERED_TESTS = []

-SHARDED_TESTS = []

-

-SHUFFLED_ALL_TESTS = []

-SHUFFLED_ACTIVE_TESTS = []

-SHUFFLED_FILTERED_TESTS = []

-SHUFFLED_SHARDED_TESTS = []

-

-

-def AlsoRunDisabledTestsFlag():

-  return '--gtest_also_run_disabled_tests'

-

-

-def FilterFlag(test_filter):

-  return '--gtest_filter=%s' % (test_filter,)

-

-

-def RepeatFlag(n):

-  return '--gtest_repeat=%s' % (n,)

-

-

-def ShuffleFlag():

-  return '--gtest_shuffle'

-

-

-def RandomSeedFlag(n):

-  return '--gtest_random_seed=%s' % (n,)

-

-

-def RunAndReturnOutput(extra_env, args):

-  """Runs the test program and returns its output."""

-

-  environ_copy = os.environ.copy()

-  environ_copy.update(extra_env)

-

-  return gtest_test_utils.Subprocess([COMMAND] + args, env=environ_copy).output

-

-

-def GetTestsForAllIterations(extra_env, args):

-  """Runs the test program and returns a list of test lists.

-

-  Args:

-    extra_env: a map from environment variables to their values

-    args: command line flags to pass to gtest_shuffle_test_

-

-  Returns:

-    A list where the i-th element is the list of tests run in the i-th

-    test iteration.

-  """

-

-  test_iterations = []

-  for line in RunAndReturnOutput(extra_env, args).split('\n'):

-    if line.startswith('----'):

-      tests = []

-      test_iterations.append(tests)

-    elif line.strip():

-      tests.append(line.strip())  # 'TestCaseName.TestName'

-

-  return test_iterations

-

-

-def GetTestCases(tests):

-  """Returns a list of test cases in the given full test names.

-

-  Args:

-    tests: a list of full test names

-

-  Returns:

-    A list of test cases from 'tests', in their original order.

-    Consecutive duplicates are removed.

-  """

-

-  test_cases = []

-  for test in tests:

-    test_case = test.split('.')[0]

-    if not test_case in test_cases:

-      test_cases.append(test_case)

-

-  return test_cases

-

-

-def CalculateTestLists():

-  """Calculates the list of tests run under different flags."""

-

-  if not ALL_TESTS:

-    ALL_TESTS.extend(

-        GetTestsForAllIterations({}, [AlsoRunDisabledTestsFlag()])[0])

-

-  if not ACTIVE_TESTS:

-    ACTIVE_TESTS.extend(GetTestsForAllIterations({}, [])[0])

-

-  if not FILTERED_TESTS:

-    FILTERED_TESTS.extend(

-        GetTestsForAllIterations({}, [FilterFlag(TEST_FILTER)])[0])

-

-  if not SHARDED_TESTS:

-    SHARDED_TESTS.extend(

-        GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',

-                                  SHARD_INDEX_ENV_VAR: '1'},

-                                 [])[0])

-

-  if not SHUFFLED_ALL_TESTS:

-    SHUFFLED_ALL_TESTS.extend(GetTestsForAllIterations(

-        {}, [AlsoRunDisabledTestsFlag(), ShuffleFlag(), RandomSeedFlag(1)])[0])

-

-  if not SHUFFLED_ACTIVE_TESTS:

-    SHUFFLED_ACTIVE_TESTS.extend(GetTestsForAllIterations(

-        {}, [ShuffleFlag(), RandomSeedFlag(1)])[0])

-

-  if not SHUFFLED_FILTERED_TESTS:

-    SHUFFLED_FILTERED_TESTS.extend(GetTestsForAllIterations(

-        {}, [ShuffleFlag(), RandomSeedFlag(1), FilterFlag(TEST_FILTER)])[0])

-

-  if not SHUFFLED_SHARDED_TESTS:

-    SHUFFLED_SHARDED_TESTS.extend(

-        GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',

-                                  SHARD_INDEX_ENV_VAR: '1'},

-                                 [ShuffleFlag(), RandomSeedFlag(1)])[0])

-

-

-class GTestShuffleUnitTest(gtest_test_utils.TestCase):

-  """Tests test shuffling."""

-

-  def setUp(self):

-    CalculateTestLists()

-

-  def testShufflePreservesNumberOfTests(self):

-    self.assertEqual(len(ALL_TESTS), len(SHUFFLED_ALL_TESTS))

-    self.assertEqual(len(ACTIVE_TESTS), len(SHUFFLED_ACTIVE_TESTS))

-    self.assertEqual(len(FILTERED_TESTS), len(SHUFFLED_FILTERED_TESTS))

-    self.assertEqual(len(SHARDED_TESTS), len(SHUFFLED_SHARDED_TESTS))

-

-  def testShuffleChangesTestOrder(self):

-    self.assert_(SHUFFLED_ALL_TESTS != ALL_TESTS, SHUFFLED_ALL_TESTS)

-    self.assert_(SHUFFLED_ACTIVE_TESTS != ACTIVE_TESTS, SHUFFLED_ACTIVE_TESTS)

-    self.assert_(SHUFFLED_FILTERED_TESTS != FILTERED_TESTS,

-                 SHUFFLED_FILTERED_TESTS)

-    self.assert_(SHUFFLED_SHARDED_TESTS != SHARDED_TESTS,

-                 SHUFFLED_SHARDED_TESTS)

-

-  def testShuffleChangesTestCaseOrder(self):

-    self.assert_(GetTestCases(SHUFFLED_ALL_TESTS) != GetTestCases(ALL_TESTS),

-                 GetTestCases(SHUFFLED_ALL_TESTS))

-    self.assert_(

-        GetTestCases(SHUFFLED_ACTIVE_TESTS) != GetTestCases(ACTIVE_TESTS),

-        GetTestCases(SHUFFLED_ACTIVE_TESTS))

-    self.assert_(

-        GetTestCases(SHUFFLED_FILTERED_TESTS) != GetTestCases(FILTERED_TESTS),

-        GetTestCases(SHUFFLED_FILTERED_TESTS))

-    self.assert_(

-        GetTestCases(SHUFFLED_SHARDED_TESTS) != GetTestCases(SHARDED_TESTS),

-        GetTestCases(SHUFFLED_SHARDED_TESTS))

-

-  def testShuffleDoesNotRepeatTest(self):

-    for test in SHUFFLED_ALL_TESTS:

-      self.assertEqual(1, SHUFFLED_ALL_TESTS.count(test),

-                       '%s appears more than once' % (test,))

-    for test in SHUFFLED_ACTIVE_TESTS:

-      self.assertEqual(1, SHUFFLED_ACTIVE_TESTS.count(test),

-                       '%s appears more than once' % (test,))

-    for test in SHUFFLED_FILTERED_TESTS:

-      self.assertEqual(1, SHUFFLED_FILTERED_TESTS.count(test),

-                       '%s appears more than once' % (test,))

-    for test in SHUFFLED_SHARDED_TESTS:

-      self.assertEqual(1, SHUFFLED_SHARDED_TESTS.count(test),

-                       '%s appears more than once' % (test,))

-

-  def testShuffleDoesNotCreateNewTest(self):

-    for test in SHUFFLED_ALL_TESTS:

-      self.assert_(test in ALL_TESTS, '%s is an invalid test' % (test,))

-    for test in SHUFFLED_ACTIVE_TESTS:

-      self.assert_(test in ACTIVE_TESTS, '%s is an invalid test' % (test,))

-    for test in SHUFFLED_FILTERED_TESTS:

-      self.assert_(test in FILTERED_TESTS, '%s is an invalid test' % (test,))

-    for test in SHUFFLED_SHARDED_TESTS:

-      self.assert_(test in SHARDED_TESTS, '%s is an invalid test' % (test,))

-

-  def testShuffleIncludesAllTests(self):

-    for test in ALL_TESTS:

-      self.assert_(test in SHUFFLED_ALL_TESTS, '%s is missing' % (test,))

-    for test in ACTIVE_TESTS:

-      self.assert_(test in SHUFFLED_ACTIVE_TESTS, '%s is missing' % (test,))

-    for test in FILTERED_TESTS:

-      self.assert_(test in SHUFFLED_FILTERED_TESTS, '%s is missing' % (test,))

-    for test in SHARDED_TESTS:

-      self.assert_(test in SHUFFLED_SHARDED_TESTS, '%s is missing' % (test,))

-

-  def testShuffleLeavesDeathTestsAtFront(self):

-    non_death_test_found = False

-    for test in SHUFFLED_ACTIVE_TESTS:

-      if 'DeathTest.' in test:

-        self.assert_(not non_death_test_found,

-                     '%s appears after a non-death test' % (test,))

-      else:

-        non_death_test_found = True

-

-  def _VerifyTestCasesDoNotInterleave(self, tests):

-    test_cases = []

-    for test in tests:

-      [test_case, _] = test.split('.')

-      if test_cases and test_cases[-1] != test_case:

-        test_cases.append(test_case)

-        self.assertEqual(1, test_cases.count(test_case),

-                         'Test case %s is not grouped together in %s' %

-                         (test_case, tests))

-

-  def testShuffleDoesNotInterleaveTestCases(self):

-    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ALL_TESTS)

-    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ACTIVE_TESTS)

-    self._VerifyTestCasesDoNotInterleave(SHUFFLED_FILTERED_TESTS)

-    self._VerifyTestCasesDoNotInterleave(SHUFFLED_SHARDED_TESTS)

-

-  def testShuffleRestoresOrderAfterEachIteration(self):

-    # Get the test lists in all 3 iterations, using random seed 1, 2,

-    # and 3 respectively.  Google Test picks a different seed in each

-    # iteration, and this test depends on the current implementation

-    # picking successive numbers.  This dependency is not ideal, but

-    # makes the test much easier to write.

-    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (

-        GetTestsForAllIterations(

-            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))

-

-    # Make sure running the tests with random seed 1 gets the same

-    # order as in iteration 1 above.

-    [tests_with_seed1] = GetTestsForAllIterations(

-        {}, [ShuffleFlag(), RandomSeedFlag(1)])

-    self.assertEqual(tests_in_iteration1, tests_with_seed1)

-

-    # Make sure running the tests with random seed 2 gets the same

-    # order as in iteration 2 above.  Success means that Google Test

-    # correctly restores the test order before re-shuffling at the

-    # beginning of iteration 2.

-    [tests_with_seed2] = GetTestsForAllIterations(

-        {}, [ShuffleFlag(), RandomSeedFlag(2)])

-    self.assertEqual(tests_in_iteration2, tests_with_seed2)

-

-    # Make sure running the tests with random seed 3 gets the same

-    # order as in iteration 3 above.  Success means that Google Test

-    # correctly restores the test order before re-shuffling at the

-    # beginning of iteration 3.

-    [tests_with_seed3] = GetTestsForAllIterations(

-        {}, [ShuffleFlag(), RandomSeedFlag(3)])

-    self.assertEqual(tests_in_iteration3, tests_with_seed3)

-

-  def testShuffleGeneratesNewOrderInEachIteration(self):

-    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (

-        GetTestsForAllIterations(

-            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))

-

-    self.assert_(tests_in_iteration1 != tests_in_iteration2,

-                 tests_in_iteration1)

-    self.assert_(tests_in_iteration1 != tests_in_iteration3,

-                 tests_in_iteration1)

-    self.assert_(tests_in_iteration2 != tests_in_iteration3,

-                 tests_in_iteration2)

-

-  def testShuffleShardedTestsPreservesPartition(self):

-    # If we run M tests on N shards, the same M tests should be run in

-    # total, regardless of the random seeds used by the shards.

-    [tests1] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',

-                                         SHARD_INDEX_ENV_VAR: '0'},

-                                        [ShuffleFlag(), RandomSeedFlag(1)])

-    [tests2] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',

-                                         SHARD_INDEX_ENV_VAR: '1'},

-                                        [ShuffleFlag(), RandomSeedFlag(20)])

-    [tests3] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',

-                                         SHARD_INDEX_ENV_VAR: '2'},

-                                        [ShuffleFlag(), RandomSeedFlag(25)])

-    sorted_sharded_tests = tests1 + tests2 + tests3

-    sorted_sharded_tests.sort()

-    sorted_active_tests = []

-    sorted_active_tests.extend(ACTIVE_TESTS)

-    sorted_active_tests.sort()

-    self.assertEqual(sorted_active_tests, sorted_sharded_tests)

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Verifies that test shuffling works."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import gtest_test_utils
+
+# Command to run the gtest_shuffle_test_ program.
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_shuffle_test_')
+
+# The environment variables for test sharding.
+TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
+SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
+
+TEST_FILTER = 'A*.A:A*.B:C*'
+
+ALL_TESTS = []
+ACTIVE_TESTS = []
+FILTERED_TESTS = []
+SHARDED_TESTS = []
+
+SHUFFLED_ALL_TESTS = []
+SHUFFLED_ACTIVE_TESTS = []
+SHUFFLED_FILTERED_TESTS = []
+SHUFFLED_SHARDED_TESTS = []
+
+
+def AlsoRunDisabledTestsFlag():
+  return '--gtest_also_run_disabled_tests'
+
+
+def FilterFlag(test_filter):
+  return '--gtest_filter=%s' % (test_filter,)
+
+
+def RepeatFlag(n):
+  return '--gtest_repeat=%s' % (n,)
+
+
+def ShuffleFlag():
+  return '--gtest_shuffle'
+
+
+def RandomSeedFlag(n):
+  return '--gtest_random_seed=%s' % (n,)
+
+
+def RunAndReturnOutput(extra_env, args):
+  """Runs the test program and returns its output."""
+
+  environ_copy = os.environ.copy()
+  environ_copy.update(extra_env)
+
+  return gtest_test_utils.Subprocess([COMMAND] + args, env=environ_copy).output
+
+
+def GetTestsForAllIterations(extra_env, args):
+  """Runs the test program and returns a list of test lists.
+
+  Args:
+    extra_env: a map from environment variables to their values
+    args: command line flags to pass to gtest_shuffle_test_
+
+  Returns:
+    A list where the i-th element is the list of tests run in the i-th
+    test iteration.
+  """
+
+  test_iterations = []
+  for line in RunAndReturnOutput(extra_env, args).split('\n'):
+    if line.startswith('----'):
+      tests = []
+      test_iterations.append(tests)
+    elif line.strip():
+      tests.append(line.strip())  # 'TestCaseName.TestName'
+
+  return test_iterations
+
+
+def GetTestCases(tests):
+  """Returns a list of test cases in the given full test names.
+
+  Args:
+    tests: a list of full test names
+
+  Returns:
+    A list of test cases from 'tests', in their original order.
+    Consecutive duplicates are removed.
+  """
+
+  test_cases = []
+  for test in tests:
+    test_case = test.split('.')[0]
+    if not test_case in test_cases:
+      test_cases.append(test_case)
+
+  return test_cases
+
+
+def CalculateTestLists():
+  """Calculates the list of tests run under different flags."""
+
+  if not ALL_TESTS:
+    ALL_TESTS.extend(
+        GetTestsForAllIterations({}, [AlsoRunDisabledTestsFlag()])[0])
+
+  if not ACTIVE_TESTS:
+    ACTIVE_TESTS.extend(GetTestsForAllIterations({}, [])[0])
+
+  if not FILTERED_TESTS:
+    FILTERED_TESTS.extend(
+        GetTestsForAllIterations({}, [FilterFlag(TEST_FILTER)])[0])
+
+  if not SHARDED_TESTS:
+    SHARDED_TESTS.extend(
+        GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                  SHARD_INDEX_ENV_VAR: '1'},
+                                 [])[0])
+
+  if not SHUFFLED_ALL_TESTS:
+    SHUFFLED_ALL_TESTS.extend(GetTestsForAllIterations(
+        {}, [AlsoRunDisabledTestsFlag(), ShuffleFlag(), RandomSeedFlag(1)])[0])
+
+  if not SHUFFLED_ACTIVE_TESTS:
+    SHUFFLED_ACTIVE_TESTS.extend(GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(1)])[0])
+
+  if not SHUFFLED_FILTERED_TESTS:
+    SHUFFLED_FILTERED_TESTS.extend(GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(1), FilterFlag(TEST_FILTER)])[0])
+
+  if not SHUFFLED_SHARDED_TESTS:
+    SHUFFLED_SHARDED_TESTS.extend(
+        GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                  SHARD_INDEX_ENV_VAR: '1'},
+                                 [ShuffleFlag(), RandomSeedFlag(1)])[0])
+
+
+class GTestShuffleUnitTest(gtest_test_utils.TestCase):
+  """Tests test shuffling."""
+
+  def setUp(self):
+    CalculateTestLists()
+
+  def testShufflePreservesNumberOfTests(self):
+    self.assertEqual(len(ALL_TESTS), len(SHUFFLED_ALL_TESTS))
+    self.assertEqual(len(ACTIVE_TESTS), len(SHUFFLED_ACTIVE_TESTS))
+    self.assertEqual(len(FILTERED_TESTS), len(SHUFFLED_FILTERED_TESTS))
+    self.assertEqual(len(SHARDED_TESTS), len(SHUFFLED_SHARDED_TESTS))
+
+  def testShuffleChangesTestOrder(self):
+    self.assert_(SHUFFLED_ALL_TESTS != ALL_TESTS, SHUFFLED_ALL_TESTS)
+    self.assert_(SHUFFLED_ACTIVE_TESTS != ACTIVE_TESTS, SHUFFLED_ACTIVE_TESTS)
+    self.assert_(SHUFFLED_FILTERED_TESTS != FILTERED_TESTS,
+                 SHUFFLED_FILTERED_TESTS)
+    self.assert_(SHUFFLED_SHARDED_TESTS != SHARDED_TESTS,
+                 SHUFFLED_SHARDED_TESTS)
+
+  def testShuffleChangesTestCaseOrder(self):
+    self.assert_(GetTestCases(SHUFFLED_ALL_TESTS) != GetTestCases(ALL_TESTS),
+                 GetTestCases(SHUFFLED_ALL_TESTS))
+    self.assert_(
+        GetTestCases(SHUFFLED_ACTIVE_TESTS) != GetTestCases(ACTIVE_TESTS),
+        GetTestCases(SHUFFLED_ACTIVE_TESTS))
+    self.assert_(
+        GetTestCases(SHUFFLED_FILTERED_TESTS) != GetTestCases(FILTERED_TESTS),
+        GetTestCases(SHUFFLED_FILTERED_TESTS))
+    self.assert_(
+        GetTestCases(SHUFFLED_SHARDED_TESTS) != GetTestCases(SHARDED_TESTS),
+        GetTestCases(SHUFFLED_SHARDED_TESTS))
+
+  def testShuffleDoesNotRepeatTest(self):
+    for test in SHUFFLED_ALL_TESTS:
+      self.assertEqual(1, SHUFFLED_ALL_TESTS.count(test),
+                       '%s appears more than once' % (test,))
+    for test in SHUFFLED_ACTIVE_TESTS:
+      self.assertEqual(1, SHUFFLED_ACTIVE_TESTS.count(test),
+                       '%s appears more than once' % (test,))
+    for test in SHUFFLED_FILTERED_TESTS:
+      self.assertEqual(1, SHUFFLED_FILTERED_TESTS.count(test),
+                       '%s appears more than once' % (test,))
+    for test in SHUFFLED_SHARDED_TESTS:
+      self.assertEqual(1, SHUFFLED_SHARDED_TESTS.count(test),
+                       '%s appears more than once' % (test,))
+
+  def testShuffleDoesNotCreateNewTest(self):
+    for test in SHUFFLED_ALL_TESTS:
+      self.assert_(test in ALL_TESTS, '%s is an invalid test' % (test,))
+    for test in SHUFFLED_ACTIVE_TESTS:
+      self.assert_(test in ACTIVE_TESTS, '%s is an invalid test' % (test,))
+    for test in SHUFFLED_FILTERED_TESTS:
+      self.assert_(test in FILTERED_TESTS, '%s is an invalid test' % (test,))
+    for test in SHUFFLED_SHARDED_TESTS:
+      self.assert_(test in SHARDED_TESTS, '%s is an invalid test' % (test,))
+
+  def testShuffleIncludesAllTests(self):
+    for test in ALL_TESTS:
+      self.assert_(test in SHUFFLED_ALL_TESTS, '%s is missing' % (test,))
+    for test in ACTIVE_TESTS:
+      self.assert_(test in SHUFFLED_ACTIVE_TESTS, '%s is missing' % (test,))
+    for test in FILTERED_TESTS:
+      self.assert_(test in SHUFFLED_FILTERED_TESTS, '%s is missing' % (test,))
+    for test in SHARDED_TESTS:
+      self.assert_(test in SHUFFLED_SHARDED_TESTS, '%s is missing' % (test,))
+
+  def testShuffleLeavesDeathTestsAtFront(self):
+    non_death_test_found = False
+    for test in SHUFFLED_ACTIVE_TESTS:
+      if 'DeathTest.' in test:
+        self.assert_(not non_death_test_found,
+                     '%s appears after a non-death test' % (test,))
+      else:
+        non_death_test_found = True
+
+  def _VerifyTestCasesDoNotInterleave(self, tests):
+    test_cases = []
+    for test in tests:
+      [test_case, _] = test.split('.')
+      if test_cases and test_cases[-1] != test_case:
+        test_cases.append(test_case)
+        self.assertEqual(1, test_cases.count(test_case),
+                         'Test case %s is not grouped together in %s' %
+                         (test_case, tests))
+
+  def testShuffleDoesNotInterleaveTestCases(self):
+    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ALL_TESTS)
+    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ACTIVE_TESTS)
+    self._VerifyTestCasesDoNotInterleave(SHUFFLED_FILTERED_TESTS)
+    self._VerifyTestCasesDoNotInterleave(SHUFFLED_SHARDED_TESTS)
+
+  def testShuffleRestoresOrderAfterEachIteration(self):
+    # Get the test lists in all 3 iterations, using random seed 1, 2,
+    # and 3 respectively.  Google Test picks a different seed in each
+    # iteration, and this test depends on the current implementation
+    # picking successive numbers.  This dependency is not ideal, but
+    # makes the test much easier to write.
+    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
+        GetTestsForAllIterations(
+            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
+
+    # Make sure running the tests with random seed 1 gets the same
+    # order as in iteration 1 above.
+    [tests_with_seed1] = GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(1)])
+    self.assertEqual(tests_in_iteration1, tests_with_seed1)
+
+    # Make sure running the tests with random seed 2 gets the same
+    # order as in iteration 2 above.  Success means that Google Test
+    # correctly restores the test order before re-shuffling at the
+    # beginning of iteration 2.
+    [tests_with_seed2] = GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(2)])
+    self.assertEqual(tests_in_iteration2, tests_with_seed2)
+
+    # Make sure running the tests with random seed 3 gets the same
+    # order as in iteration 3 above.  Success means that Google Test
+    # correctly restores the test order before re-shuffling at the
+    # beginning of iteration 3.
+    [tests_with_seed3] = GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(3)])
+    self.assertEqual(tests_in_iteration3, tests_with_seed3)
+
+  def testShuffleGeneratesNewOrderInEachIteration(self):
+    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
+        GetTestsForAllIterations(
+            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
+
+    self.assert_(tests_in_iteration1 != tests_in_iteration2,
+                 tests_in_iteration1)
+    self.assert_(tests_in_iteration1 != tests_in_iteration3,
+                 tests_in_iteration1)
+    self.assert_(tests_in_iteration2 != tests_in_iteration3,
+                 tests_in_iteration2)
+
+  def testShuffleShardedTestsPreservesPartition(self):
+    # If we run M tests on N shards, the same M tests should be run in
+    # total, regardless of the random seeds used by the shards.
+    [tests1] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                         SHARD_INDEX_ENV_VAR: '0'},
+                                        [ShuffleFlag(), RandomSeedFlag(1)])
+    [tests2] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                         SHARD_INDEX_ENV_VAR: '1'},
+                                        [ShuffleFlag(), RandomSeedFlag(20)])
+    [tests3] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                         SHARD_INDEX_ENV_VAR: '2'},
+                                        [ShuffleFlag(), RandomSeedFlag(25)])
+    sorted_sharded_tests = tests1 + tests2 + tests3
+    sorted_sharded_tests.sort()
+    sorted_active_tests = []
+    sorted_active_tests.extend(ACTIVE_TESTS)
+    sorted_active_tests.sort()
+    self.assertEqual(sorted_active_tests, sorted_sharded_tests)
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_shuffle_test_.cc b/gtest-1.6.0/test/gtest_shuffle_test_.cc
index dadd6b5..0752789 100644
--- a/gtest-1.6.0/test/gtest_shuffle_test_.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (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/gtest-1.6.0/test/gtest_sole_header_test.cc b/gtest-1.6.0/test/gtest_sole_header_test.cc
index cdf0e9a..ccd091a 100644
--- a/gtest-1.6.0/test/gtest_sole_header_test.cc
+++ b/gtest-1.6.0/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: mheule@google.com (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: mheule@google.com (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/gtest-1.6.0/test/gtest_stress_test.cc b/gtest-1.6.0/test/gtest_stress_test.cc
index 9538c82..4e7d9bf 100644
--- a/gtest-1.6.0/test/gtest_stress_test.cc
+++ b/gtest-1.6.0/test/gtest_stress_test.cc
@@ -1,257 +1,257 @@
-// 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: wan@google.com (Zhanyong Wan)

-

-// Tests that SCOPED_TRACE() and various Google Test assertions can be

-// used in a large number of threads concurrently.

-

-#include "gtest/gtest.h"

-

-#include <iostream>

-#include <vector>

-

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

-

-#if GTEST_IS_THREADSAFE

-

-namespace testing {

-namespace {

-

-using internal::Notification;

-using internal::String;

-using internal::TestPropertyKeyIs;

-using internal::ThreadWithParam;

-using internal::scoped_ptr;

-

-// In order to run tests in this file, for platforms where Google Test is

-// thread safe, implement ThreadWithParam. See the description of its API

-// in gtest-port.h, where it is defined for already supported platforms.

-

-// 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 std::vector<TestProperty>& properties,

-    int id, const char* suffix) {

-  TestPropertyKeyIs matches_key(IdToKey(id, suffix).c_str());

-  const std::vector<TestProperty>::const_iterator property =

-      std::find_if(properties.begin(), properties.end(), matches_key);

-  ASSERT_TRUE(property != properties.end())

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

-  GTEST_LOG_(INFO) << "Thread #" << id << " running...";

-

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

-  }

-}

-

-void CheckTestFailureCount(int expected_failures) {

-  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();

-  const TestResult* const result = info->result();

-  GTEST_CHECK_(expected_failures == result->total_part_count())

-      << "Logged " << result->total_part_count() << " failures "

-      << " vs. " << expected_failures << " expected";

-}

-

-// Tests using SCOPED_TRACE() and Google Test assertions in many threads

-// concurrently.

-TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {

-  {

-    scoped_ptr<ThreadWithParam<int> > threads[kThreadCount];

-    Notification threads_can_start;

-    for (int i = 0; i != kThreadCount; i++)

-      threads[i].reset(new ThreadWithParam<int>(&ManyAsserts,

-                                                i,

-                                                &threads_can_start));

-

-    threads_can_start.Notify();

-

-    // Blocks until all the threads are done.

-    for (int i = 0; i != kThreadCount; i++)

-      threads[i]->Join();

-  }

-

-  // Ensures that kThreadCount*kThreadCount failures have been reported.

-  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();

-  const TestResult* const result = info->result();

-

-  std::vector<TestProperty> properties;

-  // We have no access to the TestResult's list of properties but we can

-  // copy them one by one.

-  for (int i = 0; i < result->test_property_count(); ++i)

-    properties.push_back(result->GetTestProperty(i));

-

-  EXPECT_EQ(kThreadCount * 2 + 1, result->test_property_count())

-      << "String and int values recorded on each thread, "

-      << "as well as one shared_key";

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

-    ExpectKeyAndValueWereRecordedForId(properties, i, "string");

-    ExpectKeyAndValueWereRecordedForId(properties, i, "int");

-  }

-  CheckTestFailureCount(kThreadCount*kThreadCount);

-}

-

-void FailingThread(bool is_fatal) {

-  if (is_fatal)

-    FAIL() << "Fatal failure in some other thread. "

-           << "(This failure is expected.)";

-  else

-    ADD_FAILURE() << "Non-fatal failure in some other thread. "

-                  << "(This failure is expected.)";

-}

-

-void GenerateFatalFailureInAnotherThread(bool is_fatal) {

-  ThreadWithParam<bool> thread(&FailingThread, is_fatal, NULL);

-  thread.Join();

-}

-

-TEST(NoFatalFailureTest, ExpectNoFatalFailureIgnoresFailuresInOtherThreads) {

-  EXPECT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));

-  // We should only have one failure (the one from

-  // GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE

-  // should succeed.

-  CheckTestFailureCount(1);

-}

-

-void AssertNoFatalFailureIgnoresFailuresInOtherThreads() {

-  ASSERT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));

-}

-TEST(NoFatalFailureTest, AssertNoFatalFailureIgnoresFailuresInOtherThreads) {

-  // Using a subroutine, to make sure, that the test continues.

-  AssertNoFatalFailureIgnoresFailuresInOtherThreads();

-  // We should only have one failure (the one from

-  // GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE

-  // should succeed.

-  CheckTestFailureCount(1);

-}

-

-TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {

-  // This statement should fail, since the current thread doesn't generate a

-  // fatal failure, only another one does.

-  EXPECT_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true), "expected");

-  CheckTestFailureCount(2);

-}

-

-TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {

-  // This statement should succeed, because failures in all threads are

-  // considered.

-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(

-      GenerateFatalFailureInAnotherThread(true), "expected");

-  CheckTestFailureCount(0);

-  // We need to add a failure, because main() checks that there are failures.

-  // But when only this test is run, we shouldn't have any failures.

-  ADD_FAILURE() << "This is an expected non-fatal failure.";

-}

-

-TEST(NonFatalFailureTest, ExpectNonFatalFailureIgnoresFailuresInOtherThreads) {

-  // This statement should fail, since the current thread doesn't generate a

-  // fatal failure, only another one does.

-  EXPECT_NONFATAL_FAILURE(GenerateFatalFailureInAnotherThread(false),

-                          "expected");

-  CheckTestFailureCount(2);

-}

-

-TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThreads) {

-  // This statement should succeed, because failures in all threads are

-  // considered.

-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(

-      GenerateFatalFailureInAnotherThread(false), "expected");

-  CheckTestFailureCount(0);

-  // We need to add a failure, because main() checks that there are failures,

-  // But when only this test is run, we shouldn't have any failures.

-  ADD_FAILURE() << "This is an expected non-fatal failure.";

-}

-

-}  // namespace

-}  // namespace testing

-

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

-  testing::InitGoogleTest(&argc, argv);

-

-  const int result = RUN_ALL_TESTS();  // Expected to fail.

-  GTEST_CHECK_(result == 1) << "RUN_ALL_TESTS() did not fail as expected";

-

-  printf("\nPASS\n");

-  return 0;

-}

-

-#else

-TEST(StressTest,

-     DISABLED_ThreadSafetyTestsAreSkippedWhenGoogleTestIsNotThreadSafe) {

-}

-

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

-  testing::InitGoogleTest(&argc, argv);

-  return RUN_ALL_TESTS();

-}

-#endif  // GTEST_IS_THREADSAFE

+// 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: wan@google.com (Zhanyong Wan)
+
+// Tests that SCOPED_TRACE() and various Google Test assertions can be
+// used in a large number of threads concurrently.
+
+#include "gtest/gtest.h"
+
+#include <iostream>
+#include <vector>
+
+// 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_
+
+#if GTEST_IS_THREADSAFE
+
+namespace testing {
+namespace {
+
+using internal::Notification;
+using internal::String;
+using internal::TestPropertyKeyIs;
+using internal::ThreadWithParam;
+using internal::scoped_ptr;
+
+// In order to run tests in this file, for platforms where Google Test is
+// thread safe, implement ThreadWithParam. See the description of its API
+// in gtest-port.h, where it is defined for already supported platforms.
+
+// 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 std::vector<TestProperty>& properties,
+    int id, const char* suffix) {
+  TestPropertyKeyIs matches_key(IdToKey(id, suffix).c_str());
+  const std::vector<TestProperty>::const_iterator property =
+      std::find_if(properties.begin(), properties.end(), matches_key);
+  ASSERT_TRUE(property != properties.end())
+      << "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) {
+  GTEST_LOG_(INFO) << "Thread #" << id << " running...";
+
+  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.";
+  }
+}
+
+void CheckTestFailureCount(int expected_failures) {
+  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
+  const TestResult* const result = info->result();
+  GTEST_CHECK_(expected_failures == result->total_part_count())
+      << "Logged " << result->total_part_count() << " failures "
+      << " vs. " << expected_failures << " expected";
+}
+
+// Tests using SCOPED_TRACE() and Google Test assertions in many threads
+// concurrently.
+TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
+  {
+    scoped_ptr<ThreadWithParam<int> > threads[kThreadCount];
+    Notification threads_can_start;
+    for (int i = 0; i != kThreadCount; i++)
+      threads[i].reset(new ThreadWithParam<int>(&ManyAsserts,
+                                                i,
+                                                &threads_can_start));
+
+    threads_can_start.Notify();
+
+    // Blocks until all the threads are done.
+    for (int i = 0; i != kThreadCount; i++)
+      threads[i]->Join();
+  }
+
+  // Ensures that kThreadCount*kThreadCount failures have been reported.
+  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
+  const TestResult* const result = info->result();
+
+  std::vector<TestProperty> properties;
+  // We have no access to the TestResult's list of properties but we can
+  // copy them one by one.
+  for (int i = 0; i < result->test_property_count(); ++i)
+    properties.push_back(result->GetTestProperty(i));
+
+  EXPECT_EQ(kThreadCount * 2 + 1, result->test_property_count())
+      << "String and int values recorded on each thread, "
+      << "as well as one shared_key";
+  for (int i = 0; i < kThreadCount; ++i) {
+    ExpectKeyAndValueWereRecordedForId(properties, i, "string");
+    ExpectKeyAndValueWereRecordedForId(properties, i, "int");
+  }
+  CheckTestFailureCount(kThreadCount*kThreadCount);
+}
+
+void FailingThread(bool is_fatal) {
+  if (is_fatal)
+    FAIL() << "Fatal failure in some other thread. "
+           << "(This failure is expected.)";
+  else
+    ADD_FAILURE() << "Non-fatal failure in some other thread. "
+                  << "(This failure is expected.)";
+}
+
+void GenerateFatalFailureInAnotherThread(bool is_fatal) {
+  ThreadWithParam<bool> thread(&FailingThread, is_fatal, NULL);
+  thread.Join();
+}
+
+TEST(NoFatalFailureTest, ExpectNoFatalFailureIgnoresFailuresInOtherThreads) {
+  EXPECT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));
+  // We should only have one failure (the one from
+  // GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE
+  // should succeed.
+  CheckTestFailureCount(1);
+}
+
+void AssertNoFatalFailureIgnoresFailuresInOtherThreads() {
+  ASSERT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));
+}
+TEST(NoFatalFailureTest, AssertNoFatalFailureIgnoresFailuresInOtherThreads) {
+  // Using a subroutine, to make sure, that the test continues.
+  AssertNoFatalFailureIgnoresFailuresInOtherThreads();
+  // We should only have one failure (the one from
+  // GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE
+  // should succeed.
+  CheckTestFailureCount(1);
+}
+
+TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {
+  // This statement should fail, since the current thread doesn't generate a
+  // fatal failure, only another one does.
+  EXPECT_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true), "expected");
+  CheckTestFailureCount(2);
+}
+
+TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {
+  // This statement should succeed, because failures in all threads are
+  // considered.
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(
+      GenerateFatalFailureInAnotherThread(true), "expected");
+  CheckTestFailureCount(0);
+  // We need to add a failure, because main() checks that there are failures.
+  // But when only this test is run, we shouldn't have any failures.
+  ADD_FAILURE() << "This is an expected non-fatal failure.";
+}
+
+TEST(NonFatalFailureTest, ExpectNonFatalFailureIgnoresFailuresInOtherThreads) {
+  // This statement should fail, since the current thread doesn't generate a
+  // fatal failure, only another one does.
+  EXPECT_NONFATAL_FAILURE(GenerateFatalFailureInAnotherThread(false),
+                          "expected");
+  CheckTestFailureCount(2);
+}
+
+TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThreads) {
+  // This statement should succeed, because failures in all threads are
+  // considered.
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
+      GenerateFatalFailureInAnotherThread(false), "expected");
+  CheckTestFailureCount(0);
+  // We need to add a failure, because main() checks that there are failures,
+  // But when only this test is run, we shouldn't have any failures.
+  ADD_FAILURE() << "This is an expected non-fatal failure.";
+}
+
+}  // namespace
+}  // namespace testing
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  const int result = RUN_ALL_TESTS();  // Expected to fail.
+  GTEST_CHECK_(result == 1) << "RUN_ALL_TESTS() did not fail as expected";
+
+  printf("\nPASS\n");
+  return 0;
+}
+
+#else
+TEST(StressTest,
+     DISABLED_ThreadSafetyTestsAreSkippedWhenGoogleTestIsNotThreadSafe) {
+}
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+#endif  // GTEST_IS_THREADSAFE
diff --git a/gtest-1.6.0/test/gtest_test_utils.py b/gtest-1.6.0/test/gtest_test_utils.py
index 214931d..4e897bd 100755
--- a/gtest-1.6.0/test/gtest_test_utils.py
+++ b/gtest-1.6.0/test/gtest_test_utils.py
@@ -1,305 +1,305 @@
-#!/usr/bin/env python

-#

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

-

-"""Unit test utilities for Google C++ Testing Framework."""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import atexit

-import os

-import shutil

-import sys

-import tempfile

-import unittest

-_test_module = unittest

-

-# Suppresses the 'Import not at the top of the file' lint complaint.

-# pylint: disable-msg=C6204

-try:

-  import subprocess

-  _SUBPROCESS_MODULE_AVAILABLE = True

-except:

-  import popen2

-  _SUBPROCESS_MODULE_AVAILABLE = False

-# pylint: enable-msg=C6204

-

-GTEST_OUTPUT_VAR_NAME = 'GTEST_OUTPUT'

-

-IS_WINDOWS = os.name == 'nt'

-IS_CYGWIN = os.name == 'posix' and 'CYGWIN' in os.uname()[0]

-

-# Here we expose a class from a particular module, depending on the

-# environment. The comment suppresses the 'Invalid variable name' lint

-# complaint.

-TestCase = _test_module.TestCase  # pylint: disable-msg=C6409

-

-# Initially maps a flag to its default value. After

-# _ParseAndStripGTestFlags() is called, maps a flag to its actual value.

-_flag_map = {'source_dir': os.path.dirname(sys.argv[0]),

-             'build_dir': os.path.dirname(sys.argv[0])}

-_gtest_flags_are_parsed = False

-

-

-def _ParseAndStripGTestFlags(argv):

-  """Parses and strips Google Test flags from argv.  This is idempotent."""

-

-  # Suppresses the lint complaint about a global variable since we need it

-  # here to maintain module-wide state.

-  global _gtest_flags_are_parsed  # pylint: disable-msg=W0603

-  if _gtest_flags_are_parsed:

-    return

-

-  _gtest_flags_are_parsed = True

-  for flag in _flag_map:

-    # The environment variable overrides the default value.

-    if flag.upper() in os.environ:

-      _flag_map[flag] = os.environ[flag.upper()]

-

-    # The command line flag overrides the environment variable.

-    i = 1  # Skips the program name.

-    while i < len(argv):

-      prefix = '--' + flag + '='

-      if argv[i].startswith(prefix):

-        _flag_map[flag] = argv[i][len(prefix):]

-        del argv[i]

-        break

-      else:

-        # We don't increment i in case we just found a --gtest_* flag

-        # and removed it from argv.

-        i += 1

-

-

-def GetFlag(flag):

-  """Returns the value of the given flag."""

-

-  # In case GetFlag() is called before Main(), we always call

-  # _ParseAndStripGTestFlags() here to make sure the --gtest_* flags

-  # are parsed.

-  _ParseAndStripGTestFlags(sys.argv)

-

-  return _flag_map[flag]

-

-

-def GetSourceDir():

-  """Returns the absolute path of the directory where the .py files are."""

-

-  return os.path.abspath(GetFlag('source_dir'))

-

-

-def GetBuildDir():

-  """Returns the absolute path of the directory where the test binaries are."""

-

-  return os.path.abspath(GetFlag('build_dir'))

-

-

-_temp_dir = None

-

-def _RemoveTempDir():

-  if _temp_dir:

-    shutil.rmtree(_temp_dir, ignore_errors=True)

-

-atexit.register(_RemoveTempDir)

-

-

-def GetTempDir():

-  """Returns a directory for temporary files."""

-

-  global _temp_dir

-  if not _temp_dir:

-    _temp_dir = tempfile.mkdtemp()

-  return _temp_dir

-

-

-def GetTestExecutablePath(executable_name, build_dir=None):

-  """Returns the absolute path of the test binary given its name.

-

-  The function will print a message and abort the program if the resulting file

-  doesn't exist.

-

-  Args:

-    executable_name: name of the test binary that the test script runs.

-    build_dir:       directory where to look for executables, by default

-                     the result of GetBuildDir().

-

-  Returns:

-    The absolute path of the test binary.

-  """

-

-  path = os.path.abspath(os.path.join(build_dir or GetBuildDir(),

-                                      executable_name))

-  if (IS_WINDOWS or IS_CYGWIN) and not path.endswith('.exe'):

-    path += '.exe'

-

-  if not os.path.exists(path):

-    message = (

-        'Unable to find the test binary. Please make sure to provide path\n'

-        'to the binary via the --build_dir flag or the BUILD_DIR\n'

-        'environment variable.')

-    print >> sys.stderr, message

-    sys.exit(1)

-

-  return path

-

-

-def GetExitStatus(exit_code):

-  """Returns the argument to exit(), or -1 if exit() wasn't called.

-

-  Args:

-    exit_code: the result value of os.system(command).

-  """

-

-  if os.name == 'nt':

-    # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns

-    # the argument to exit() directly.

-    return exit_code

-  else:

-    # On Unix, os.WEXITSTATUS() must be used to extract the exit status

-    # from the result of os.system().

-    if os.WIFEXITED(exit_code):

-      return os.WEXITSTATUS(exit_code)

-    else:

-      return -1

-

-

-class Subprocess:

-  def __init__(self, command, working_dir=None, capture_stderr=True, env=None):

-    """Changes into a specified directory, if provided, and executes a command.

-

-    Restores the old directory afterwards.

-

-    Args:

-      command:        The command to run, in the form of sys.argv.

-      working_dir:    The directory to change into.

-      capture_stderr: Determines whether to capture stderr in the output member

-                      or to discard it.

-      env:            Dictionary with environment to pass to the subprocess.

-

-    Returns:

-      An object that represents outcome of the executed process. It has the

-      following attributes:

-        terminated_by_signal   True iff the child process has been terminated

-                               by a signal.

-        signal                 Sygnal that terminated the child process.

-        exited                 True iff the child process exited normally.

-        exit_code              The code with which the child process exited.

-        output                 Child process's stdout and stderr output

-                               combined in a string.

-    """

-

-    # The subprocess module is the preferrable way of running programs

-    # since it is available and behaves consistently on all platforms,

-    # including Windows. But it is only available starting in python 2.4.

-    # In earlier python versions, we revert to the popen2 module, which is

-    # available in python 2.0 and later but doesn't provide required

-    # functionality (Popen4) under Windows. This allows us to support Mac

-    # OS X 10.4 Tiger, which has python 2.3 installed.

-    if _SUBPROCESS_MODULE_AVAILABLE:

-      if capture_stderr:

-        stderr = subprocess.STDOUT

-      else:

-        stderr = subprocess.PIPE

-

-      p = subprocess.Popen(command,

-                           stdout=subprocess.PIPE, stderr=stderr,

-                           cwd=working_dir, universal_newlines=True, env=env)

-      # communicate returns a tuple with the file obect for the child's

-      # output.

-      self.output = p.communicate()[0]

-      self._return_code = p.returncode

-    else:

-      old_dir = os.getcwd()

-

-      def _ReplaceEnvDict(dest, src):

-        # Changes made by os.environ.clear are not inheritable by child

-        # processes until Python 2.6. To produce inheritable changes we have

-        # to delete environment items with the del statement.

-        for key in dest:

-          del dest[key]

-        dest.update(src)

-

-      # When 'env' is not None, backup the environment variables and replace

-      # them with the passed 'env'. When 'env' is None, we simply use the

-      # current 'os.environ' for compatibility with the subprocess.Popen

-      # semantics used above.

-      if env is not None:

-        old_environ = os.environ.copy()

-        _ReplaceEnvDict(os.environ, env)

-

-      try:

-        if working_dir is not None:

-          os.chdir(working_dir)

-        if capture_stderr:

-          p = popen2.Popen4(command)

-        else:

-          p = popen2.Popen3(command)

-        p.tochild.close()

-        self.output = p.fromchild.read()

-        ret_code = p.wait()

-      finally:

-        os.chdir(old_dir)

-

-        # Restore the old environment variables

-        # if they were replaced.

-        if env is not None:

-          _ReplaceEnvDict(os.environ, old_environ)

-

-      # Converts ret_code to match the semantics of

-      # subprocess.Popen.returncode.

-      if os.WIFSIGNALED(ret_code):

-        self._return_code = -os.WTERMSIG(ret_code)

-      else:  # os.WIFEXITED(ret_code) should return True here.

-        self._return_code = os.WEXITSTATUS(ret_code)

-

-    if self._return_code < 0:

-      self.terminated_by_signal = True

-      self.exited = False

-      self.signal = -self._return_code

-    else:

-      self.terminated_by_signal = False

-      self.exited = True

-      self.exit_code = self._return_code

-

-

-def Main():

-  """Runs the unit test."""

-

-  # We must call _ParseAndStripGTestFlags() before calling

-  # unittest.main().  Otherwise the latter will be confused by the

-  # --gtest_* flags.

-  _ParseAndStripGTestFlags(sys.argv)

-  # The tested binaries should not be writing XML output files unless the

-  # script explicitly instructs them to.

-  # TODO(vladl@google.com): Move this into Subprocess when we implement

-  # passing environment into it as a parameter.

-  if GTEST_OUTPUT_VAR_NAME in os.environ:

-    del os.environ[GTEST_OUTPUT_VAR_NAME]

-

-  _test_module.main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Unit test utilities for Google C++ Testing Framework."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import atexit
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+_test_module = unittest
+
+# Suppresses the 'Import not at the top of the file' lint complaint.
+# pylint: disable-msg=C6204
+try:
+  import subprocess
+  _SUBPROCESS_MODULE_AVAILABLE = True
+except:
+  import popen2
+  _SUBPROCESS_MODULE_AVAILABLE = False
+# pylint: enable-msg=C6204
+
+GTEST_OUTPUT_VAR_NAME = 'GTEST_OUTPUT'
+
+IS_WINDOWS = os.name == 'nt'
+IS_CYGWIN = os.name == 'posix' and 'CYGWIN' in os.uname()[0]
+
+# Here we expose a class from a particular module, depending on the
+# environment. The comment suppresses the 'Invalid variable name' lint
+# complaint.
+TestCase = _test_module.TestCase  # pylint: disable-msg=C6409
+
+# Initially maps a flag to its default value. After
+# _ParseAndStripGTestFlags() is called, maps a flag to its actual value.
+_flag_map = {'source_dir': os.path.dirname(sys.argv[0]),
+             'build_dir': os.path.dirname(sys.argv[0])}
+_gtest_flags_are_parsed = False
+
+
+def _ParseAndStripGTestFlags(argv):
+  """Parses and strips Google Test flags from argv.  This is idempotent."""
+
+  # Suppresses the lint complaint about a global variable since we need it
+  # here to maintain module-wide state.
+  global _gtest_flags_are_parsed  # pylint: disable-msg=W0603
+  if _gtest_flags_are_parsed:
+    return
+
+  _gtest_flags_are_parsed = True
+  for flag in _flag_map:
+    # The environment variable overrides the default value.
+    if flag.upper() in os.environ:
+      _flag_map[flag] = os.environ[flag.upper()]
+
+    # The command line flag overrides the environment variable.
+    i = 1  # Skips the program name.
+    while i < len(argv):
+      prefix = '--' + flag + '='
+      if argv[i].startswith(prefix):
+        _flag_map[flag] = argv[i][len(prefix):]
+        del argv[i]
+        break
+      else:
+        # We don't increment i in case we just found a --gtest_* flag
+        # and removed it from argv.
+        i += 1
+
+
+def GetFlag(flag):
+  """Returns the value of the given flag."""
+
+  # In case GetFlag() is called before Main(), we always call
+  # _ParseAndStripGTestFlags() here to make sure the --gtest_* flags
+  # are parsed.
+  _ParseAndStripGTestFlags(sys.argv)
+
+  return _flag_map[flag]
+
+
+def GetSourceDir():
+  """Returns the absolute path of the directory where the .py files are."""
+
+  return os.path.abspath(GetFlag('source_dir'))
+
+
+def GetBuildDir():
+  """Returns the absolute path of the directory where the test binaries are."""
+
+  return os.path.abspath(GetFlag('build_dir'))
+
+
+_temp_dir = None
+
+def _RemoveTempDir():
+  if _temp_dir:
+    shutil.rmtree(_temp_dir, ignore_errors=True)
+
+atexit.register(_RemoveTempDir)
+
+
+def GetTempDir():
+  """Returns a directory for temporary files."""
+
+  global _temp_dir
+  if not _temp_dir:
+    _temp_dir = tempfile.mkdtemp()
+  return _temp_dir
+
+
+def GetTestExecutablePath(executable_name, build_dir=None):
+  """Returns the absolute path of the test binary given its name.
+
+  The function will print a message and abort the program if the resulting file
+  doesn't exist.
+
+  Args:
+    executable_name: name of the test binary that the test script runs.
+    build_dir:       directory where to look for executables, by default
+                     the result of GetBuildDir().
+
+  Returns:
+    The absolute path of the test binary.
+  """
+
+  path = os.path.abspath(os.path.join(build_dir or GetBuildDir(),
+                                      executable_name))
+  if (IS_WINDOWS or IS_CYGWIN) and not path.endswith('.exe'):
+    path += '.exe'
+
+  if not os.path.exists(path):
+    message = (
+        'Unable to find the test binary. Please make sure to provide path\n'
+        'to the binary via the --build_dir flag or the BUILD_DIR\n'
+        'environment variable.')
+    print >> sys.stderr, message
+    sys.exit(1)
+
+  return path
+
+
+def GetExitStatus(exit_code):
+  """Returns the argument to exit(), or -1 if exit() wasn't called.
+
+  Args:
+    exit_code: the result value of os.system(command).
+  """
+
+  if os.name == 'nt':
+    # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns
+    # the argument to exit() directly.
+    return exit_code
+  else:
+    # On Unix, os.WEXITSTATUS() must be used to extract the exit status
+    # from the result of os.system().
+    if os.WIFEXITED(exit_code):
+      return os.WEXITSTATUS(exit_code)
+    else:
+      return -1
+
+
+class Subprocess:
+  def __init__(self, command, working_dir=None, capture_stderr=True, env=None):
+    """Changes into a specified directory, if provided, and executes a command.
+
+    Restores the old directory afterwards.
+
+    Args:
+      command:        The command to run, in the form of sys.argv.
+      working_dir:    The directory to change into.
+      capture_stderr: Determines whether to capture stderr in the output member
+                      or to discard it.
+      env:            Dictionary with environment to pass to the subprocess.
+
+    Returns:
+      An object that represents outcome of the executed process. It has the
+      following attributes:
+        terminated_by_signal   True iff the child process has been terminated
+                               by a signal.
+        signal                 Sygnal that terminated the child process.
+        exited                 True iff the child process exited normally.
+        exit_code              The code with which the child process exited.
+        output                 Child process's stdout and stderr output
+                               combined in a string.
+    """
+
+    # The subprocess module is the preferrable way of running programs
+    # since it is available and behaves consistently on all platforms,
+    # including Windows. But it is only available starting in python 2.4.
+    # In earlier python versions, we revert to the popen2 module, which is
+    # available in python 2.0 and later but doesn't provide required
+    # functionality (Popen4) under Windows. This allows us to support Mac
+    # OS X 10.4 Tiger, which has python 2.3 installed.
+    if _SUBPROCESS_MODULE_AVAILABLE:
+      if capture_stderr:
+        stderr = subprocess.STDOUT
+      else:
+        stderr = subprocess.PIPE
+
+      p = subprocess.Popen(command,
+                           stdout=subprocess.PIPE, stderr=stderr,
+                           cwd=working_dir, universal_newlines=True, env=env)
+      # communicate returns a tuple with the file obect for the child's
+      # output.
+      self.output = p.communicate()[0]
+      self._return_code = p.returncode
+    else:
+      old_dir = os.getcwd()
+
+      def _ReplaceEnvDict(dest, src):
+        # Changes made by os.environ.clear are not inheritable by child
+        # processes until Python 2.6. To produce inheritable changes we have
+        # to delete environment items with the del statement.
+        for key in dest:
+          del dest[key]
+        dest.update(src)
+
+      # When 'env' is not None, backup the environment variables and replace
+      # them with the passed 'env'. When 'env' is None, we simply use the
+      # current 'os.environ' for compatibility with the subprocess.Popen
+      # semantics used above.
+      if env is not None:
+        old_environ = os.environ.copy()
+        _ReplaceEnvDict(os.environ, env)
+
+      try:
+        if working_dir is not None:
+          os.chdir(working_dir)
+        if capture_stderr:
+          p = popen2.Popen4(command)
+        else:
+          p = popen2.Popen3(command)
+        p.tochild.close()
+        self.output = p.fromchild.read()
+        ret_code = p.wait()
+      finally:
+        os.chdir(old_dir)
+
+        # Restore the old environment variables
+        # if they were replaced.
+        if env is not None:
+          _ReplaceEnvDict(os.environ, old_environ)
+
+      # Converts ret_code to match the semantics of
+      # subprocess.Popen.returncode.
+      if os.WIFSIGNALED(ret_code):
+        self._return_code = -os.WTERMSIG(ret_code)
+      else:  # os.WIFEXITED(ret_code) should return True here.
+        self._return_code = os.WEXITSTATUS(ret_code)
+
+    if self._return_code < 0:
+      self.terminated_by_signal = True
+      self.exited = False
+      self.signal = -self._return_code
+    else:
+      self.terminated_by_signal = False
+      self.exited = True
+      self.exit_code = self._return_code
+
+
+def Main():
+  """Runs the unit test."""
+
+  # We must call _ParseAndStripGTestFlags() before calling
+  # unittest.main().  Otherwise the latter will be confused by the
+  # --gtest_* flags.
+  _ParseAndStripGTestFlags(sys.argv)
+  # The tested binaries should not be writing XML output files unless the
+  # script explicitly instructs them to.
+  # TODO(vladl@google.com): Move this into Subprocess when we implement
+  # passing environment into it as a parameter.
+  if GTEST_OUTPUT_VAR_NAME in os.environ:
+    del os.environ[GTEST_OUTPUT_VAR_NAME]
+
+  _test_module.main()
diff --git a/gtest-1.6.0/test/gtest_throw_on_failure_ex_test.cc b/gtest-1.6.0/test/gtest_throw_on_failure_ex_test.cc
index 3893010..8d46c76 100644
--- a/gtest-1.6.0/test/gtest_throw_on_failure_ex_test.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (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/gtest-1.6.0/test/gtest_throw_on_failure_test.py b/gtest-1.6.0/test/gtest_throw_on_failure_test.py
index 7ede785..5678ffe 100755
--- a/gtest-1.6.0/test/gtest_throw_on_failure_test.py
+++ b/gtest-1.6.0/test/gtest_throw_on_failure_test.py
@@ -1,171 +1,171 @@
-#!/usr/bin/env python

-#

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

-

-"""Tests Google Test's throw-on-failure mode with exceptions disabled.

-

-This script invokes gtest_throw_on_failure_test_ (a program written with

-Google Test) with different environments and command line flags.

-"""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import os

-import gtest_test_utils

-

-

-# Constants.

-

-# The command line flag for enabling/disabling the throw-on-failure mode.

-THROW_ON_FAILURE = 'gtest_throw_on_failure'

-

-# Path to the gtest_throw_on_failure_test_ program, compiled with

-# exceptions disabled.

-EXE_PATH = gtest_test_utils.GetTestExecutablePath(

-    'gtest_throw_on_failure_test_')

-

-

-# Utilities.

-

-

-def SetEnvVar(env_var, value):

-  """Sets an environment variable to a given value; unsets it when the

-  given value is None.

-  """

-

-  env_var = env_var.upper()

-  if value is not None:

-    os.environ[env_var] = value

-  elif env_var in os.environ:

-    del os.environ[env_var]

-

-

-def Run(command):

-  """Runs a command; returns True/False if its exit code is/isn't 0."""

-

-  print 'Running "%s". . .' % ' '.join(command)

-  p = gtest_test_utils.Subprocess(command)

-  return p.exited and p.exit_code == 0

-

-

-# The tests.  TODO(wan@google.com): refactor the class to share common

-# logic with code in gtest_break_on_failure_unittest.py.

-class ThrowOnFailureTest(gtest_test_utils.TestCase):

-  """Tests the throw-on-failure mode."""

-

-  def RunAndVerify(self, env_var_value, flag_value, should_fail):

-    """Runs gtest_throw_on_failure_test_ and verifies that it does

-    (or does not) exit with a non-zero code.

-

-    Args:

-      env_var_value:    value of the GTEST_BREAK_ON_FAILURE environment

-                        variable; None if the variable should be unset.

-      flag_value:       value of the --gtest_break_on_failure flag;

-                        None if the flag should not be present.

-      should_fail:      True iff the program is expected to fail.

-    """

-

-    SetEnvVar(THROW_ON_FAILURE, env_var_value)

-

-    if env_var_value is None:

-      env_var_value_msg = ' is not set'

-    else:

-      env_var_value_msg = '=' + env_var_value

-

-    if flag_value is None:

-      flag = ''

-    elif flag_value == '0':

-      flag = '--%s=0' % THROW_ON_FAILURE

-    else:

-      flag = '--%s' % THROW_ON_FAILURE

-

-    command = [EXE_PATH]

-    if flag:

-      command.append(flag)

-

-    if should_fail:

-      should_or_not = 'should'

-    else:

-      should_or_not = 'should not'

-

-    failed = not Run(command)

-

-    SetEnvVar(THROW_ON_FAILURE, None)

-

-    msg = ('when %s%s, an assertion failure in "%s" %s cause a non-zero '

-           'exit code.' %

-           (THROW_ON_FAILURE, env_var_value_msg, ' '.join(command),

-            should_or_not))

-    self.assert_(failed == should_fail, msg)

-

-  def testDefaultBehavior(self):

-    """Tests the behavior of the default mode."""

-

-    self.RunAndVerify(env_var_value=None, flag_value=None, should_fail=False)

-

-  def testThrowOnFailureEnvVar(self):

-    """Tests using the GTEST_THROW_ON_FAILURE environment variable."""

-

-    self.RunAndVerify(env_var_value='0',

-                      flag_value=None,

-                      should_fail=False)

-    self.RunAndVerify(env_var_value='1',

-                      flag_value=None,

-                      should_fail=True)

-

-  def testThrowOnFailureFlag(self):

-    """Tests using the --gtest_throw_on_failure flag."""

-

-    self.RunAndVerify(env_var_value=None,

-                      flag_value='0',

-                      should_fail=False)

-    self.RunAndVerify(env_var_value=None,

-                      flag_value='1',

-                      should_fail=True)

-

-  def testThrowOnFailureFlagOverridesEnvVar(self):

-    """Tests that --gtest_throw_on_failure overrides GTEST_THROW_ON_FAILURE."""

-

-    self.RunAndVerify(env_var_value='0',

-                      flag_value='0',

-                      should_fail=False)

-    self.RunAndVerify(env_var_value='0',

-                      flag_value='1',

-                      should_fail=True)

-    self.RunAndVerify(env_var_value='1',

-                      flag_value='0',

-                      should_fail=False)

-    self.RunAndVerify(env_var_value='1',

-                      flag_value='1',

-                      should_fail=True)

-

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Tests Google Test's throw-on-failure mode with exceptions disabled.
+
+This script invokes gtest_throw_on_failure_test_ (a program written with
+Google Test) with different environments and command line flags.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import gtest_test_utils
+
+
+# Constants.
+
+# The command line flag for enabling/disabling the throw-on-failure mode.
+THROW_ON_FAILURE = 'gtest_throw_on_failure'
+
+# Path to the gtest_throw_on_failure_test_ program, compiled with
+# exceptions disabled.
+EXE_PATH = gtest_test_utils.GetTestExecutablePath(
+    'gtest_throw_on_failure_test_')
+
+
+# Utilities.
+
+
+def SetEnvVar(env_var, value):
+  """Sets an environment variable to a given value; unsets it when the
+  given value is None.
+  """
+
+  env_var = env_var.upper()
+  if value is not None:
+    os.environ[env_var] = value
+  elif env_var in os.environ:
+    del os.environ[env_var]
+
+
+def Run(command):
+  """Runs a command; returns True/False if its exit code is/isn't 0."""
+
+  print 'Running "%s". . .' % ' '.join(command)
+  p = gtest_test_utils.Subprocess(command)
+  return p.exited and p.exit_code == 0
+
+
+# The tests.  TODO(wan@google.com): refactor the class to share common
+# logic with code in gtest_break_on_failure_unittest.py.
+class ThrowOnFailureTest(gtest_test_utils.TestCase):
+  """Tests the throw-on-failure mode."""
+
+  def RunAndVerify(self, env_var_value, flag_value, should_fail):
+    """Runs gtest_throw_on_failure_test_ and verifies that it does
+    (or does not) exit with a non-zero code.
+
+    Args:
+      env_var_value:    value of the GTEST_BREAK_ON_FAILURE environment
+                        variable; None if the variable should be unset.
+      flag_value:       value of the --gtest_break_on_failure flag;
+                        None if the flag should not be present.
+      should_fail:      True iff the program is expected to fail.
+    """
+
+    SetEnvVar(THROW_ON_FAILURE, env_var_value)
+
+    if env_var_value is None:
+      env_var_value_msg = ' is not set'
+    else:
+      env_var_value_msg = '=' + env_var_value
+
+    if flag_value is None:
+      flag = ''
+    elif flag_value == '0':
+      flag = '--%s=0' % THROW_ON_FAILURE
+    else:
+      flag = '--%s' % THROW_ON_FAILURE
+
+    command = [EXE_PATH]
+    if flag:
+      command.append(flag)
+
+    if should_fail:
+      should_or_not = 'should'
+    else:
+      should_or_not = 'should not'
+
+    failed = not Run(command)
+
+    SetEnvVar(THROW_ON_FAILURE, None)
+
+    msg = ('when %s%s, an assertion failure in "%s" %s cause a non-zero '
+           'exit code.' %
+           (THROW_ON_FAILURE, env_var_value_msg, ' '.join(command),
+            should_or_not))
+    self.assert_(failed == should_fail, msg)
+
+  def testDefaultBehavior(self):
+    """Tests the behavior of the default mode."""
+
+    self.RunAndVerify(env_var_value=None, flag_value=None, should_fail=False)
+
+  def testThrowOnFailureEnvVar(self):
+    """Tests using the GTEST_THROW_ON_FAILURE environment variable."""
+
+    self.RunAndVerify(env_var_value='0',
+                      flag_value=None,
+                      should_fail=False)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value=None,
+                      should_fail=True)
+
+  def testThrowOnFailureFlag(self):
+    """Tests using the --gtest_throw_on_failure flag."""
+
+    self.RunAndVerify(env_var_value=None,
+                      flag_value='0',
+                      should_fail=False)
+    self.RunAndVerify(env_var_value=None,
+                      flag_value='1',
+                      should_fail=True)
+
+  def testThrowOnFailureFlagOverridesEnvVar(self):
+    """Tests that --gtest_throw_on_failure overrides GTEST_THROW_ON_FAILURE."""
+
+    self.RunAndVerify(env_var_value='0',
+                      flag_value='0',
+                      should_fail=False)
+    self.RunAndVerify(env_var_value='0',
+                      flag_value='1',
+                      should_fail=True)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value='0',
+                      should_fail=False)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value='1',
+                      should_fail=True)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_throw_on_failure_test_.cc b/gtest-1.6.0/test/gtest_throw_on_failure_test_.cc
index 7ad2151..03776ec 100644
--- a/gtest-1.6.0/test/gtest_throw_on_failure_test_.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (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/gtest-1.6.0/test/gtest_uninitialized_test.py b/gtest-1.6.0/test/gtest_uninitialized_test.py
index e11c8fe..6ae57ee 100755
--- a/gtest-1.6.0/test/gtest_uninitialized_test.py
+++ b/gtest-1.6.0/test/gtest_uninitialized_test.py
@@ -1,70 +1,70 @@
-#!/usr/bin/env python

-#

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

-

-"""Verifies that Google Test warns the user when not initialized properly."""

-

-__author__ = 'wan@google.com (Zhanyong Wan)'

-

-import gtest_test_utils

-

-

-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_uninitialized_test_')

-

-

-def Assert(condition):

-  if not condition:

-    raise AssertionError

-

-

-def AssertEq(expected, actual):

-  if expected != actual:

-    print 'Expected: %s' % (expected,)

-    print '  Actual: %s' % (actual,)

-    raise AssertionError

-

-

-def TestExitCodeAndOutput(command):

-  """Runs the given command and verifies its exit code and output."""

-

-  # Verifies that 'command' exits with code 1.

-  p = gtest_test_utils.Subprocess(command)

-  Assert(p.exited)

-  AssertEq(1, p.exit_code)

-  Assert('InitGoogleTest' in p.output)

-

-

-class GTestUninitializedTest(gtest_test_utils.TestCase):

-  def testExitCodeAndOutput(self):

-    TestExitCodeAndOutput(COMMAND)

-

-

-if __name__ == '__main__':

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Verifies that Google Test warns the user when not initialized properly."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import gtest_test_utils
+
+
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_uninitialized_test_')
+
+
+def Assert(condition):
+  if not condition:
+    raise AssertionError
+
+
+def AssertEq(expected, actual):
+  if expected != actual:
+    print 'Expected: %s' % (expected,)
+    print '  Actual: %s' % (actual,)
+    raise AssertionError
+
+
+def TestExitCodeAndOutput(command):
+  """Runs the given command and verifies its exit code and output."""
+
+  # Verifies that 'command' exits with code 1.
+  p = gtest_test_utils.Subprocess(command)
+  Assert(p.exited)
+  AssertEq(1, p.exit_code)
+  Assert('InitGoogleTest' in p.output)
+
+
+class GTestUninitializedTest(gtest_test_utils.TestCase):
+  def testExitCodeAndOutput(self):
+    TestExitCodeAndOutput(COMMAND)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_uninitialized_test_.cc b/gtest-1.6.0/test/gtest_uninitialized_test_.cc
index 5f371a4..4431698 100644
--- a/gtest-1.6.0/test/gtest_uninitialized_test_.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (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/gtest-1.6.0/test/gtest_unittest.cc b/gtest-1.6.0/test/gtest_unittest.cc
index d4fdf73..23d6860 100644
--- a/gtest-1.6.0/test/gtest_unittest.cc
+++ b/gtest-1.6.0/test/gtest_unittest.cc
@@ -1,7337 +1,7337 @@
-// 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: wan@google.com (Zhanyong Wan)

-//

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

-// Google Test work.

-

-#include "gtest/gtest.h"

-#include <vector>

-#include <ostream>

-

-// 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(stream_result_to) != "unknown"

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

-

-#include <map>

-

-namespace testing {

-namespace internal {

-

-// 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(stream_result_to);

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

-using testing::TestEventListeners;

-using testing::TestPartResult;

-using testing::TestPartResultArray;

-using testing::TestProperty;

-using testing::TestResult;

-using testing::UnitTest;

-using testing::kMaxStackTraceDepth;

-using testing::internal::AddReference;

-using testing::internal::AlwaysFalse;

-using testing::internal::AlwaysTrue;

-using testing::internal::AppendUserMessage;

-using testing::internal::ArrayAwareFind;

-using testing::internal::ArrayEq;

-using testing::internal::CodePointToUtf8;

-using testing::internal::CompileAssertTypesEqual;

-using testing::internal::CopyArray;

-using testing::internal::CountIf;

-using testing::internal::EqFailure;

-using testing::internal::FloatingPoint;

-using testing::internal::ForEach;

-using testing::internal::FormatTimeInMillisAsSeconds;

-using testing::internal::GTestFlagSaver;

-using testing::internal::GetCurrentOsStackTraceExceptTop;

-using testing::internal::GetElementOr;

-using testing::internal::GetNextRandomSeed;

-using testing::internal::GetRandomSeedFromFlag;

-using testing::internal::GetTestTypeId;

-using testing::internal::GetTypeId;

-using testing::internal::GetUnitTestImpl;

-using testing::internal::ImplicitlyConvertible;

-using testing::internal::Int32;

-using testing::internal::Int32FromEnvOrDie;

-using testing::internal::IsAProtocolMessage;

-using testing::internal::IsContainer;

-using testing::internal::IsContainerTest;

-using testing::internal::IsNotContainer;

-using testing::internal::NativeArray;

-using testing::internal::ParseInt32Flag;

-using testing::internal::RemoveConst;

-using testing::internal::RemoveReference;

-using testing::internal::ShouldRunTestOnShard;

-using testing::internal::ShouldShard;

-using testing::internal::ShouldUseColor;

-using testing::internal::Shuffle;

-using testing::internal::ShuffleRange;

-using testing::internal::SkipPrefix;

-using testing::internal::StreamableToString;

-using testing::internal::String;

-using testing::internal::TestEventListenersAccessor;

-using testing::internal::TestResultAccessor;

-using testing::internal::UInt32;

-using testing::internal::WideStringToUtf8;

-using testing::internal::kCopy;

-using testing::internal::kMaxRandomSeed;

-using testing::internal::kReference;

-using testing::internal::kTestTypeIdInGoogleTest;

-using testing::internal::scoped_ptr;

-

-#if GTEST_HAS_STREAM_REDIRECTION

-using testing::internal::CaptureStdout;

-using testing::internal::GetCapturedStdout;

-#endif

-

-#if GTEST_IS_THREADSAFE

-using testing::internal::ThreadWithParam;

-#endif

-

-class TestingVector : public std::vector<int> {

-};

-

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

-                           const TestingVector& vector) {

-  os << "{ ";

-  for (size_t i = 0; i < vector.size(); i++) {

-    os << vector[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_EQ("0", FormatTimeInMillisAsSeconds(0));

-}

-

-TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {

-  EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3));

-  EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10));

-  EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200));

-  EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200));

-  EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000));

-}

-

-TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {

-  EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3));

-  EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10));

-  EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200));

-  EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200));

-  EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000));

-}

-

-#if GTEST_CAN_COMPARE_NULL

-

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

-

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

-

-# 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" suppressed them.

-#  pragma option pop

-# endif

-

-#endif  // GTEST_CAN_COMPARE_NULL

-//

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

-  // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints

-  // in wide strings and wide chars. In order to accomodate them, we have to

-  // introduce such character constants as integers.

-  EXPECT_STREQ("\xD5\xB6",

-               CodePointToUtf8(static_cast<wchar_t>(0x576), 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(static_cast<wchar_t>(0x8D3), buffer));

-

-  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101

-  EXPECT_STREQ("\xEC\x9D\x8D",

-               CodePointToUtf8(static_cast<wchar_t>(0xC74D), 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

-  const wchar_t s[] = { 0x576, '\0' };

-  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str());

-  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -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

-  const wchar_t s1[] = { 0x8D3, '\0' };

-  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str());

-  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str());

-

-  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101

-  const wchar_t s2[] = { 0xC74D, '\0' };

-  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str());

-  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -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) {

-  const wchar_t s[] = { 0xD801, 0xDC00, '\0' };

-  EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -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.

-  const wchar_t s1[] = { 0xD800, '\0' };

-  EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str());

-  // Leading surrogate is not followed by the trailing surrogate.

-  const wchar_t s2[] = { 0xD800, 'M', '\0' };

-  EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str());

-  // Trailing surrogate appearas without a leading surrogate.

-  const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' };

-  EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str());

-}

-#endif  // !GTEST_WIDE_STRING_USES_UTF16_

-

-// Tests that codepoint concatenation works correctly.

-#if !GTEST_WIDE_STRING_USES_UTF16_

-TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {

-  const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};

-  EXPECT_STREQ(

-      "\xF4\x88\x98\xB4"

-          "\xEC\x9D\x8D"

-          "\n"

-          "\xD5\xB6"

-          "\xE0\xA3\x93"

-          "\xF4\x88\x98\xB4",

-      WideStringToUtf8(s, -1).c_str());

-}

-#else

-TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {

-  const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'};

-  EXPECT_STREQ(

-      "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",

-      WideStringToUtf8(s, -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 STL container utilities.

-

-// Tests CountIf().

-

-static bool IsPositive(int n) { return n > 0; }

-

-TEST(ContainerUtilityTest, CountIf) {

-  std::vector<int> v;

-  EXPECT_EQ(0, CountIf(v, IsPositive));  // Works for an empty container.

-

-  v.push_back(-1);

-  v.push_back(0);

-  EXPECT_EQ(0, CountIf(v, IsPositive));  // Works when no value satisfies.

-

-  v.push_back(2);

-  v.push_back(-10);

-  v.push_back(10);

-  EXPECT_EQ(2, CountIf(v, IsPositive));

-}

-

-// Tests ForEach().

-

-static int g_sum = 0;

-static void Accumulate(int n) { g_sum += n; }

-

-TEST(ContainerUtilityTest, ForEach) {

-  std::vector<int> v;

-  g_sum = 0;

-  ForEach(v, Accumulate);

-  EXPECT_EQ(0, g_sum);  // Works for an empty container;

-

-  g_sum = 0;

-  v.push_back(1);

-  ForEach(v, Accumulate);

-  EXPECT_EQ(1, g_sum);  // Works for a container with one element.

-

-  g_sum = 0;

-  v.push_back(20);

-  v.push_back(300);

-  ForEach(v, Accumulate);

-  EXPECT_EQ(321, g_sum);

-}

-

-// Tests GetElementOr().

-TEST(ContainerUtilityTest, GetElementOr) {

-  std::vector<char> a;

-  EXPECT_EQ('x', GetElementOr(a, 0, 'x'));

-

-  a.push_back('a');

-  a.push_back('b');

-  EXPECT_EQ('a', GetElementOr(a, 0, 'x'));

-  EXPECT_EQ('b', GetElementOr(a, 1, 'x'));

-  EXPECT_EQ('x', GetElementOr(a, -2, 'x'));

-  EXPECT_EQ('x', GetElementOr(a, 2, 'x'));

-}

-

-TEST(ContainerUtilityDeathTest, ShuffleRange) {

-  std::vector<int> a;

-  a.push_back(0);

-  a.push_back(1);

-  a.push_back(2);

-  testing::internal::Random random(1);

-

-  EXPECT_DEATH_IF_SUPPORTED(

-      ShuffleRange(&random, -1, 1, &a),

-      "Invalid shuffle range start -1: must be in range \\[0, 3\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      ShuffleRange(&random, 4, 4, &a),

-      "Invalid shuffle range start 4: must be in range \\[0, 3\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      ShuffleRange(&random, 3, 2, &a),

-      "Invalid shuffle range finish 2: must be in range \\[3, 3\\]");

-  EXPECT_DEATH_IF_SUPPORTED(

-      ShuffleRange(&random, 3, 4, &a),

-      "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_.push_back(i);

-    }

-  }

-

-  static bool VectorIsCorrupt(const TestingVector& vector) {

-    if (kVectorSize != static_cast<int>(vector.size())) {

-      return true;

-    }

-

-    bool found_in_vector[kVectorSize] = { false };

-    for (size_t i = 0; i < vector.size(); i++) {

-      const int e = vector[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[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, static_cast<int>(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...

-  ShuffleRange(&random_, 0, 0, &vector_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...in the middle...

-  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...at the end...

-  ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...and past the end.

-  ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-}

-

-TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {

-  // Tests a size one range at the beginning...

-  ShuffleRange(&random_, 0, 1, &vector_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...in the middle...

-  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsUnshuffled, vector_);

-

-  // ...and at the end.

-  ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_);

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

-  Shuffle(&random_, &vector_);

-  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_[0]);

-  EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]);

-}

-

-TEST_F(VectorShuffleTest, ShufflesStartOfVector) {

-  const int kRangeSize = kVectorSize/2;

-

-  ShuffleRange(&random_, 0, kRangeSize, &vector_);

-

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

-  ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_);

-

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);

-  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize);

-}

-

-TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {

-  int kRangeSize = kVectorSize/3;

-  ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_);

-

-  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.push_back(i);

-  }

-

-  random_.Reseed(1234);

-  Shuffle(&random_, &vector_);

-  random_.Reseed(1234);

-  Shuffle(&random_, &vector2);

-

-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);

-  ASSERT_PRED1(VectorIsNotCorrupt, vector2);

-

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

-    EXPECT_EQ(vector_[i], vector2[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]);

-}

-

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

-}

-

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

-

-  // Use explicit function call notation here to suppress self-assign warning.

-  dest.operator=(dest);

-  EXPECT_STREQ("hello", dest.c_str());

-}

-

-// Sun Studio < 12 incorrectly rejects this code due to an overloading

-// ambiguity.

-#if !(defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)

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

-}

-#endif

-

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

-

-class ScopedFakeTestPartResultReporterWithThreadsTest

-  : public ScopedFakeTestPartResultReporterTest {

- protected:

-  static void AddFailureInOtherThread(FailureMode failure) {

-    ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);

-    thread.Join();

-  }

-};

-

-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

-

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

-}

-

-#if GTEST_HAS_GLOBAL_STRING

-TEST_F(ExpectFatalFailureTest, AcceptsStringObject) {

-  EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure."));

-}

-#endif

-

-TEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) {

-  EXPECT_FATAL_FAILURE(AddFatalFailure(),

-                       ::std::string("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" suppressed 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.

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

-}

-

-#if GTEST_HAS_GLOBAL_STRING

-TEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) {

-  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),

-                          ::string("Expected non-fatal failure."));

-}

-#endif

-

-TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {

-  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),

-                          ::std::string("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

-

-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

-

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

-

-// The test fixture for testing TestResult.

-class TestResultTest : public Test {

- protected:

-  typedef std::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<TPRVector*>(

-        &TestResultAccessor::test_part_results(*r1));

-    TPRVector* results2 = const_cast<TPRVector*>(

-        &TestResultAccessor::test_part_results(*r2));

-

-    // r0 is an empty TestResult.

-

-    // r1 contains a single SUCCESS TestPartResult.

-    results1->push_back(*pr1);

-

-    // r2 contains a SUCCESS, and a FAILURE.

-    results2->push_back(*pr1);

-    results2->push_back(*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), "");

-  EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-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), "");

-  EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), "");

-}

-

-// 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(stack_trace_depth) = kMaxStackTraceDepth;

-    GTEST_FLAG(stream_result_to) = "";

-    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_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth));

-    EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str());

-    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(stack_trace_depth) = 1;

-    GTEST_FLAG(stream_result_to) = "localhost:1234";

-    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__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)

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

-

-  // The standard signature of putenv accepts a 'char*' argument. Other

-  // implementations, like C++Builder's, accept a 'const char*'.

-  // We cast away the 'const' since that would work for both variants.

-  putenv(const_cast<char*>(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 function that returns AssertionResult for use in

-// EXPECT/ASSERT_TRUE/FALSE.

-AssertionResult ResultIsEven(int n) {

-  if (IsEven(n))

-    return AssertionSuccess() << n << " is even";

-  else

-    return AssertionFailure() << n << " is odd";

-}

-

-// A predicate function that returns AssertionResult but gives no

-// explanation why it succeeds. Needed for testing that

-// EXPECT/ASSERT_FALSE handles such functions correctly.

-AssertionResult ResultIsEvenNoExplanation(int n) {

-  if (IsEven(n))

-    return AssertionSuccess();

-  else

-    return AssertionFailure() << n << " is odd";

-}

-

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

-}

-

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

-}

-

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

-}

-

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

-}

-

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

-  // We use the assignment syntax since some compilers, like Sun Studio,

-  // don't allow initializing references using construction syntax

-  // (parentheses).

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

-  // We use the assignment syntax since some compilers, like Sun Studio,

-  // don't allow initializing references using construction syntax

-  // (parentheses).

-  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.5f, 0.25f),  // NOLINT

-                          "The difference between 1.0f and 1.5f is 0.5, "

-                          "which exceeds 0.25f");

-  // 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.5f, 0.25f),  // NOLINT

-                       "The difference between 1.0f and 1.5f is 0.5, "

-                       "which exceeds 0.25f");

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

-  // We use the assignment syntax since some compilers, like Sun Studio,

-  // don't allow initializing references using construction syntax

-  // (parentheses).

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

-  // We use the assignment syntax since some compilers, like Sun Studio,

-  // don't allow initializing references using construction syntax

-  // (parentheses).

-  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.5, 0.25),  // NOLINT

-                          "The difference between 1.0 and 1.5 is 0.5, "

-                          "which exceeds 0.25");

-  // 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.5, 0.25),  // NOLINT

-                       "The difference between 1.0 and 1.5 is 0.5, "

-                       "which exceeds 0.25");

-  // 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_TRUE(predicate) for predicates returning AssertionResult.

-TEST(AssertionTest, AssertTrueWithAssertionResult) {

-  ASSERT_TRUE(ResultIsEven(2));

-#ifndef __BORLANDC__

-  // ICE's in C++Builder.

-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)),

-                       "Value of: ResultIsEven(3)\n"

-                       "  Actual: false (3 is odd)\n"

-                       "Expected: true");

-#endif

-  ASSERT_TRUE(ResultIsEvenNoExplanation(2));

-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)),

-                       "Value of: ResultIsEvenNoExplanation(3)\n"

-                       "  Actual: false (3 is odd)\n"

-                       "Expected: true");

-}

-

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

-}

-

-// Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult.

-TEST(AssertionTest, AssertFalseWithAssertionResult) {

-  ASSERT_FALSE(ResultIsEven(3));

-#ifndef __BORLANDC__

-  // ICE's in C++Builder.

-  EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)),

-                       "Value of: ResultIsEven(2)\n"

-                       "  Actual: true (2 is even)\n"

-                       "Expected: false");

-#endif

-  ASSERT_FALSE(ResultIsEvenNoExplanation(3));

-  EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)),

-                       "Value of: ResultIsEvenNoExplanation(2)\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_CAN_COMPARE_NULL

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

-

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

-

-# ifndef __BORLANDC__

-

-  // ICE's in C++Builder 2007 and 2009.

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

-  bool false_value = false;

-  ASSERT_EQ(true && false_value, 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 a_value) : value_(a_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");

-}

-

-enum NamedEnum {

-  kE1 = 0,

-  kE2 = 1

-};

-

-TEST(AssertionTest, NamedEnum) {

-  EXPECT_EQ(kE1, kE1);

-  EXPECT_LT(kE1, kE2);

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0");

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Actual: 1");

-}

-

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

-// Sun Studio and HP aCC also reject this code.

-#if !GTEST_OS_MAC && !defined(__SUNPRO_CC) && !defined(__HP_aCC)

-

-// Tests using assertions with anonymous enums.

-enum {

-  kCaseA = -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, kCaseB and kCaseA have the same value when truncated to

-  // int size.  We want to test whether this will confuse the

-  // assertions.

-  kCaseB = testing::internal::kMaxBiggestInt,

-

-# else

-

-  kCaseB = INT_MAX,

-

-# endif  // GTEST_OS_LINUX

-

-  kCaseC = 42

-};

-

-TEST(AssertionTest, AnonymousEnum) {

-# if GTEST_OS_LINUX

-

-  EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));

-

-# endif  // GTEST_OS_LINUX

-

-  EXPECT_EQ(kCaseA, kCaseA);

-  EXPECT_NE(kCaseA, kCaseB);

-  EXPECT_LT(kCaseA, kCaseB);

-  EXPECT_LE(kCaseA, kCaseB);

-  EXPECT_GT(kCaseB, kCaseA);

-  EXPECT_GE(kCaseA, kCaseA);

-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB),

-                          "(kCaseA) >= (kCaseB)");

-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC),

-                          "-1 vs 42");

-

-  ASSERT_EQ(kCaseA, kCaseA);

-  ASSERT_NE(kCaseA, kCaseB);

-  ASSERT_LT(kCaseA, kCaseB);

-  ASSERT_LE(kCaseA, kCaseB);

-  ASSERT_GT(kCaseB, kCaseA);

-  ASSERT_GE(kCaseA, kCaseA);

-

-# ifndef __BORLANDC__

-

-  // ICE's in C++Builder.

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),

-                       "Value of: kCaseB");

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),

-                       "Actual: 42");

-# endif

-

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),

-                       "Which is: -1");

-}

-

-#endif  // !GTEST_OS_MAC && !defined(__SUNPRO_CC)

-

-#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_TRUE(predicate) for predicates returning AssertionResult.

-TEST(ExpectTest, ExpectTrueWithAssertionResult) {

-  EXPECT_TRUE(ResultIsEven(2));

-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)),

-                          "Value of: ResultIsEven(3)\n"

-                          "  Actual: false (3 is odd)\n"

-                          "Expected: true");

-  EXPECT_TRUE(ResultIsEvenNoExplanation(2));

-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)),

-                          "Value of: ResultIsEvenNoExplanation(3)\n"

-                          "  Actual: false (3 is odd)\n"

-                          "Expected: true");

-}

-

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

-}

-

-// Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult.

-TEST(ExpectTest, ExpectFalseWithAssertionResult) {

-  EXPECT_FALSE(ResultIsEven(3));

-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)),

-                          "Value of: ResultIsEven(2)\n"

-                          "  Actual: true (2 is even)\n"

-                          "Expected: false");

-  EXPECT_FALSE(ResultIsEvenNoExplanation(3));

-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)),

-                          "Value of: ResultIsEvenNoExplanation(2)\n"

-                          "  Actual: true\n"

-                          "Expected: false");

-}

-

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

-// Tests EXPECT_EQ(NULL, pointer).

-TEST(ExpectTest, EXPECT_EQ_NULL) {

-  // A success.

-  const char* p = NULL;

-  // Some older GCC versions may issue a spurious warning 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_CAN_COMPARE_NULL

-

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

-

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

-}

-

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

-TEST(MacroTest, ADD_FAILURE_AT) {

-  // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and

-  // the failure message contains the user-streamed part.

-  EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!");

-

-  // Verifies that the user-streamed part is optional.

-  EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed");

-

-  // Unfortunately, we cannot verify that the failure message contains

-  // the right file path and line number the same way, as

-  // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and

-  // line number.  Instead, we do that in gtest_output_test_.cc.

-}

-

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

-      bool false_value = false;

-      ASSERT_EQ(false_value, 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 = 0x8119;

-  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),

-                       "Value of: wchar");

-}

-

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

-}

-

-#if GTEST_HAS_STD_WSTRING

-

-// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ.

-TEST(EqAssertionTest, StdWideString) {

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

-  // content.

-  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };

-  EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119);

-

-  // Compares an std::wstring to a const wchar_t* that has different

-  // content.

-  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);

-  }, "kTestX8120");

-

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

-  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };

-  ASSERT_EQ(kTestX8119, ::wstring(kTestX8119));

-

-  // Compares a const wchar_t* to a ::wstring that has different

-  // content.

-  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };

-  EXPECT_NONFATAL_FAILURE({  // NOLINT

-    EXPECT_EQ(kTestX8120, ::wstring(kTestX8119));

-  }, "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");

-}

-

-// A class that supports binary comparison operators but not streaming.

-class UnprintableChar {

- public:

-  explicit UnprintableChar(char ch) : char_(ch) {}

-

-  bool operator==(const UnprintableChar& rhs) const {

-    return char_ == rhs.char_;

-  }

-  bool operator!=(const UnprintableChar& rhs) const {

-    return char_ != rhs.char_;

-  }

-  bool operator<(const UnprintableChar& rhs) const {

-    return char_ < rhs.char_;

-  }

-  bool operator<=(const UnprintableChar& rhs) const {

-    return char_ <= rhs.char_;

-  }

-  bool operator>(const UnprintableChar& rhs) const {

-    return char_ > rhs.char_;

-  }

-  bool operator>=(const UnprintableChar& rhs) const {

-    return char_ >= rhs.char_;

-  }

-

- private:

-  char char_;

-};

-

-// Tests that ASSERT_EQ() and friends don't require the arguments to

-// be printable.

-TEST(ComparisonAssertionTest, AcceptsUnprintableArgs) {

-  const UnprintableChar x('x'), y('y');

-  ASSERT_EQ(x, x);

-  EXPECT_NE(x, y);

-  ASSERT_LT(x, y);

-  EXPECT_LE(x, y);

-  ASSERT_GT(y, x);

-  EXPECT_GE(x, x);

-

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>");

-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>");

-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>");

-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>");

-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>");

-

-  // Code tested by EXPECT_FATAL_FAILURE cannot reference local

-  // variables, so we have to write UnprintableChar('x') instead of x.

-#ifndef __BORLANDC__

-  // ICE's in C++Builder.

-  EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')),

-                       "1-byte object <78>");

-  EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),

-                       "1-byte object <78>");

-#endif

-  EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),

-                       "1-byte object <79>");

-  EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),

-                       "1-byte object <78>");

-  EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),

-                       "1-byte object <79>");

-}

-

-// 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 that the copy constructor works when it is NOT optimized away by

-// the compiler.

-TEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) {

-  // Checks that the copy constructor doesn't try to dereference NULL pointers

-  // in the source object.

-  AssertionResult r1 = AssertionSuccess();

-  AssertionResult r2 = r1;

-  // The following line is added to prevent the compiler from optimizing

-  // away the constructor call.

-  r1 << "abc";

-

-  AssertionResult r3 = r1;

-  EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1));

-  EXPECT_STREQ("abc", r1.message());

-}

-

-// Tests that AssertionSuccess and AssertionFailure construct

-// AssertionResult objects as expected.

-TEST(AssertionResultTest, ConstructionWorks) {

-  AssertionResult r1 = AssertionSuccess();

-  EXPECT_TRUE(r1);

-  EXPECT_STREQ("", r1.message());

-

-  AssertionResult r2 = AssertionSuccess() << "abc";

-  EXPECT_TRUE(r2);

-  EXPECT_STREQ("abc", r2.message());

-

-  AssertionResult r3 = AssertionFailure();

-  EXPECT_FALSE(r3);

-  EXPECT_STREQ("", r3.message());

-

-  AssertionResult r4 = AssertionFailure() << "def";

-  EXPECT_FALSE(r4);

-  EXPECT_STREQ("def", r4.message());

-

-  AssertionResult r5 = AssertionFailure(Message() << "ghi");

-  EXPECT_FALSE(r5);

-  EXPECT_STREQ("ghi", r5.message());

-}

-

-// Tests that the negation flips the predicate result but keeps the message.

-TEST(AssertionResultTest, NegationWorks) {

-  AssertionResult r1 = AssertionSuccess() << "abc";

-  EXPECT_FALSE(!r1);

-  EXPECT_STREQ("abc", (!r1).message());

-

-  AssertionResult r2 = AssertionFailure() << "def";

-  EXPECT_TRUE(!r2);

-  EXPECT_STREQ("def", (!r2).message());

-}

-

-TEST(AssertionResultTest, StreamingWorks) {

-  AssertionResult r = AssertionSuccess();

-  r << "abc" << 'd' << 0 << true;

-  EXPECT_STREQ("abcd0true", r.message());

-}

-

-TEST(AssertionResultTest, CanStreamOstreamManipulators) {

-  AssertionResult r = AssertionSuccess();

-  r << "Data" << std::endl << std::flush << std::ends << "Will be visible";

-  EXPECT_STREQ("Data\n\\0Will be visible", r.message());

-}

-

-// Tests streaming a user type whose definition and operator << are

-// both in the global namespace.

-class Base {

- public:

-  explicit Base(int an_x) : x_(an_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 an_x): Base(an_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 an_x): Base(an_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 an_x): Base(an_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),

-            stack_trace_depth(kMaxStackTraceDepth),

-            stream_result_to(""),

-            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_FLAG(stack_trace_depth) flag has

-  // the given value.

-  static Flags StackTraceDepth(Int32 stack_trace_depth) {

-    Flags flags;

-    flags.stack_trace_depth = stack_trace_depth;

-    return flags;

-  }

-

-  // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has

-  // the given value.

-  static Flags StreamResultTo(const char* stream_result_to) {

-    Flags flags;

-    flags.stream_result_to = stream_result_to;

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

-  Int32 stack_trace_depth;

-  const char* stream_result_to;

-  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(stack_trace_depth) = kMaxStackTraceDepth;

-    GTEST_FLAG(stream_result_to) = "";

-    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.stack_trace_depth, GTEST_FLAG(stack_trace_depth));

-    EXPECT_STREQ(expected.stream_result_to,

-                 GTEST_FLAG(stream_result_to).c_str());

-    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, bool should_print_help) {

-    const bool saved_help_flag = ::testing::internal::g_help_flag;

-    ::testing::internal::g_help_flag = false;

-

-#if GTEST_HAS_STREAM_REDIRECTION

-    CaptureStdout();

-#endif

-

-    // Parses the command line.

-    internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));

-

-#if GTEST_HAS_STREAM_REDIRECTION

-    const String captured_stdout = GetCapturedStdout();

-#endif

-

-    // Verifies the flag values.

-    CheckFlags(expected);

-

-    // Verifies that the recognized flags are removed from the command

-    // line.

-    AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);

-

-    // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the

-    // help message for the flags it recognizes.

-    EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);

-

-#if GTEST_HAS_STREAM_REDIRECTION

-    const char* const expected_help_fragment =

-        "This program contains tests written using";

-    if (should_print_help) {

-      EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);

-    } else {

-      EXPECT_PRED_FORMAT2(IsNotSubstring,

-                          expected_help_fragment, captured_stdout);

-    }

-#endif  // GTEST_HAS_STREAM_REDIRECTION

-

-    ::testing::internal::g_help_flag = saved_help_flag;

-  }

-

-  // This macro wraps TestParsingFlags s.t. the user doesn't need

-  // to specify the array sizes.

-

-#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \

-  TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \

-                   sizeof(argv2)/sizeof(*argv2) - 1, argv2, \

-                   expected, should_print_help)

-};

-

-// 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(), false);

-}

-

-// 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(), false);

-}

-

-// 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(""), true);

-}

-

-// 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(""), false);

-}

-

-// 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"), false);

-}

-

-// 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), false);

-}

-

-// 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), 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), 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), 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), false);

-}

-

-// 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), false);

-}

-

-// 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), false);

-}

-

-// 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"), false);

-}

-

-// 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, false);

-}

-

-// 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), false);

-}

-

-// 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), false);

-}

-

-// 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), 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), 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), 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(), true);

-}

-

-// 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"), false);

-}

-

-// 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"), false);

-}

-

-// 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/"), false);

-}

-

-// 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), false);

-}

-

-// 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), false);

-}

-

-// 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), 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), 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), 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), false);

-}

-

-// 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), false);

-}

-

-// 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), false);

-}

-

-// 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), false);

-}

-

-// 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), 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), false);

-}

-

-// 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), 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), false);

-}

-

-// Tests parsing --gtest_stack_trace_depth=number.

-TEST_F(InitGoogleTestTest, StackTraceDepth) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_stack_trace_depth=5",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);

-}

-

-TEST_F(InitGoogleTestTest, StreamResultTo) {

-  const char* argv[] = {

-    "foo.exe",

-    "--gtest_stream_result_to=localhost:1234",

-    NULL

-  };

-

-  const char* argv2[] = {

-    "foo.exe",

-    NULL

-  };

-

-  GTEST_TEST_PARSING_FLAGS_(

-      argv, argv2, Flags::StreamResultTo("localhost:1234"), false);

-}

-

-// 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), false);

-}

-

-// 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), 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), false);

-}

-

-#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, false);

-}

-#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", "xterm-256color");  // TERM supports colors.

-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.

-

-  SetEnv("TERM", "screen");  // 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.

-

-  SetEnv("TERM", "cygwin");  // 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 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>();

-static bool dummy2 GTEST_ATTRIBUTE_UNUSED_ =

-    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(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(std::vector<String>* vector, const char* id)

-      : vector_(vector), id_(id) {}

-

- protected:

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

-    vector_->push_back(GetEventDescription("OnTestProgramStart"));

-  }

-

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

-    vector_->push_back(GetEventDescription("OnTestProgramEnd"));

-  }

-

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

-                                    int /*iteration*/) {

-    vector_->push_back(GetEventDescription("OnTestIterationStart"));

-  }

-

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

-                                  int /*iteration*/) {

-    vector_->push_back(GetEventDescription("OnTestIterationEnd"));

-  }

-

- private:

-  String GetEventDescription(const char* method) {

-    Message message;

-    message << id_ << "." << method;

-    return message.GetString();

-  }

-

-  std::vector<String>* vector_;

-  const char* const id_;

-

-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);

-};

-

-TEST(EventListenerTest, AppendKeepsOrder) {

-  std::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(3U, vec.size());

-  EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());

-  EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());

-  EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());

-

-  vec.clear();

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(

-      *UnitTest::GetInstance());

-  ASSERT_EQ(3U, vec.size());

-  EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());

-  EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());

-  EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());

-

-  vec.clear();

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(

-      *UnitTest::GetInstance(), 0);

-  ASSERT_EQ(3U, vec.size());

-  EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());

-  EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());

-  EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());

-

-  vec.clear();

-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(

-      *UnitTest::GetInstance(), 0);

-  ASSERT_EQ(3U, vec.size());

-  EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());

-  EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());

-  EXPECT_STREQ("1st.OnTestIterationEnd", vec[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;

-}

-

-// Sanity tests to ensure that the alternative, verbose spellings of

-// some of the macros work.  We don't test them thoroughly as that

-// would be quite involved.  Since their implementations are

-// straightforward, and they are rarely used, we'll just rely on the

-// users to tell us when they are broken.

-GTEST_TEST(AlternativeNameTest, Works) {  // GTEST_TEST is the same as TEST.

-  GTEST_SUCCEED() << "OK";  // GTEST_SUCCEED is the same as SUCCEED.

-

-  // GTEST_FAIL is the same as FAIL.

-  EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure",

-                       "An expected failure");

-

-  // GTEST_ASSERT_XY is the same as ASSERT_XY.

-

-  GTEST_ASSERT_EQ(0, 0);

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure",

-                       "An expected failure");

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure",

-                       "An expected failure");

-

-  GTEST_ASSERT_NE(0, 1);

-  GTEST_ASSERT_NE(1, 0);

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure",

-                       "An expected failure");

-

-  GTEST_ASSERT_LE(0, 0);

-  GTEST_ASSERT_LE(0, 1);

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure",

-                       "An expected failure");

-

-  GTEST_ASSERT_LT(0, 1);

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure",

-                       "An expected failure");

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure",

-                       "An expected failure");

-

-  GTEST_ASSERT_GE(0, 0);

-  GTEST_ASSERT_GE(1, 0);

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure",

-                       "An expected failure");

-

-  GTEST_ASSERT_GT(1, 0);

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure",

-                       "An expected failure");

-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure",

-                       "An expected failure");

-}

-

-// Tests for internal utilities necessary for implementation of the universal

-// printing.

-// TODO(vladl@google.com): Find a better home for them.

-

-class ConversionHelperBase {};

-class ConversionHelperDerived : public ConversionHelperBase {};

-

-// Tests that IsAProtocolMessage<T>::value is a compile-time constant.

-TEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) {

-  GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value,

-                        const_true);

-  GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false);

-}

-

-// Tests that IsAProtocolMessage<T>::value is true when T is

-// proto2::Message or a sub-class of it.

-TEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) {

-  EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value);

-  EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value);

-}

-

-// Tests that IsAProtocolMessage<T>::value is false when T is neither

-// ProtocolMessage nor a sub-class of it.

-TEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) {

-  EXPECT_FALSE(IsAProtocolMessage<int>::value);

-  EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value);

-}

-

-// Tests that CompileAssertTypesEqual compiles when the type arguments are

-// equal.

-TEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) {

-  CompileAssertTypesEqual<void, void>();

-  CompileAssertTypesEqual<int*, int*>();

-}

-

-// Tests that RemoveReference does not affect non-reference types.

-TEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) {

-  CompileAssertTypesEqual<int, RemoveReference<int>::type>();

-  CompileAssertTypesEqual<const char, RemoveReference<const char>::type>();

-}

-

-// Tests that RemoveReference removes reference from reference types.

-TEST(RemoveReferenceTest, RemovesReference) {

-  CompileAssertTypesEqual<int, RemoveReference<int&>::type>();

-  CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>();

-}

-

-// Tests GTEST_REMOVE_REFERENCE_.

-

-template <typename T1, typename T2>

-void TestGTestRemoveReference() {

-  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>();

-}

-

-TEST(RemoveReferenceTest, MacroVersion) {

-  TestGTestRemoveReference<int, int>();

-  TestGTestRemoveReference<const char, const char&>();

-}

-

-

-// Tests that RemoveConst does not affect non-const types.

-TEST(RemoveConstTest, DoesNotAffectNonConstType) {

-  CompileAssertTypesEqual<int, RemoveConst<int>::type>();

-  CompileAssertTypesEqual<char&, RemoveConst<char&>::type>();

-}

-

-// Tests that RemoveConst removes const from const types.

-TEST(RemoveConstTest, RemovesConst) {

-  CompileAssertTypesEqual<int, RemoveConst<const int>::type>();

-  CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>();

-  CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>();

-}

-

-// Tests GTEST_REMOVE_CONST_.

-

-template <typename T1, typename T2>

-void TestGTestRemoveConst() {

-  CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>();

-}

-

-TEST(RemoveConstTest, MacroVersion) {

-  TestGTestRemoveConst<int, int>();

-  TestGTestRemoveConst<double&, double&>();

-  TestGTestRemoveConst<char, const char>();

-}

-

-// Tests GTEST_REMOVE_REFERENCE_AND_CONST_.

-

-template <typename T1, typename T2>

-void TestGTestRemoveReferenceAndConst() {

-  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>();

-}

-

-TEST(RemoveReferenceToConstTest, Works) {

-  TestGTestRemoveReferenceAndConst<int, int>();

-  TestGTestRemoveReferenceAndConst<double, double&>();

-  TestGTestRemoveReferenceAndConst<char, const char>();

-  TestGTestRemoveReferenceAndConst<char, const char&>();

-  TestGTestRemoveReferenceAndConst<const char*, const char*>();

-}

-

-// Tests that AddReference does not affect reference types.

-TEST(AddReferenceTest, DoesNotAffectReferenceType) {

-  CompileAssertTypesEqual<int&, AddReference<int&>::type>();

-  CompileAssertTypesEqual<const char&, AddReference<const char&>::type>();

-}

-

-// Tests that AddReference adds reference to non-reference types.

-TEST(AddReferenceTest, AddsReference) {

-  CompileAssertTypesEqual<int&, AddReference<int>::type>();

-  CompileAssertTypesEqual<const char&, AddReference<const char>::type>();

-}

-

-// Tests GTEST_ADD_REFERENCE_.

-

-template <typename T1, typename T2>

-void TestGTestAddReference() {

-  CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>();

-}

-

-TEST(AddReferenceTest, MacroVersion) {

-  TestGTestAddReference<int&, int>();

-  TestGTestAddReference<const char&, const char&>();

-}

-

-// Tests GTEST_REFERENCE_TO_CONST_.

-

-template <typename T1, typename T2>

-void TestGTestReferenceToConst() {

-  CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>();

-}

-

-TEST(GTestReferenceToConstTest, Works) {

-  TestGTestReferenceToConst<const char&, char>();

-  TestGTestReferenceToConst<const int&, const int>();

-  TestGTestReferenceToConst<const double&, double>();

-  TestGTestReferenceToConst<const String&, const String&>();

-}

-

-// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant.

-TEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) {

-  GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true);

-  GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value),

-                        const_false);

-}

-

-// Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can

-// be implicitly converted to T2.

-TEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) {

-  EXPECT_TRUE((ImplicitlyConvertible<int, double>::value));

-  EXPECT_TRUE((ImplicitlyConvertible<double, int>::value));

-  EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value));

-  EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value));

-  EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&,

-                                     const ConversionHelperBase&>::value));

-  EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase,

-                                     ConversionHelperBase>::value));

-}

-

-// Tests that ImplicitlyConvertible<T1, T2>::value is false when T1

-// cannot be implicitly converted to T2.

-TEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) {

-  EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value));

-  EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value));

-  EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value));

-  EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&,

-                                      ConversionHelperDerived&>::value));

-}

-

-// Tests IsContainerTest.

-

-class NonContainer {};

-

-TEST(IsContainerTestTest, WorksForNonContainer) {

-  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0)));

-  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0)));

-  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0)));

-}

-

-TEST(IsContainerTestTest, WorksForContainer) {

-  EXPECT_EQ(sizeof(IsContainer),

-            sizeof(IsContainerTest<std::vector<bool> >(0)));

-  EXPECT_EQ(sizeof(IsContainer),

-            sizeof(IsContainerTest<std::map<int, double> >(0)));

-}

-

-// Tests ArrayEq().

-

-TEST(ArrayEqTest, WorksForDegeneratedArrays) {

-  EXPECT_TRUE(ArrayEq(5, 5L));

-  EXPECT_FALSE(ArrayEq('a', 0));

-}

-

-TEST(ArrayEqTest, WorksForOneDimensionalArrays) {

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

-  long b[] = { 0, 1 };

-  EXPECT_TRUE(ArrayEq(a, b));

-  EXPECT_TRUE(ArrayEq(a, 2, b));

-

-  b[0] = 2;

-  EXPECT_FALSE(ArrayEq(a, b));

-  EXPECT_FALSE(ArrayEq(a, 1, b));

-}

-

-TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {

-  const char a[][3] = { "hi", "lo" };

-  const char b[][3] = { "hi", "lo" };

-  const char c[][3] = { "hi", "li" };

-

-  EXPECT_TRUE(ArrayEq(a, b));

-  EXPECT_TRUE(ArrayEq(a, 2, b));

-

-  EXPECT_FALSE(ArrayEq(a, c));

-  EXPECT_FALSE(ArrayEq(a, 2, c));

-}

-

-// Tests ArrayAwareFind().

-

-TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {

-  const char a[] = "hello";

-  EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o'));

-  EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x'));

-}

-

-TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {

-  int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };

-  const int b[2] = { 2, 3 };

-  EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));

-

-  const int c[2] = { 6, 7 };

-  EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));

-}

-

-// Tests CopyArray().

-

-TEST(CopyArrayTest, WorksForDegeneratedArrays) {

-  int n = 0;

-  CopyArray('a', &n);

-  EXPECT_EQ('a', n);

-}

-

-TEST(CopyArrayTest, WorksForOneDimensionalArrays) {

-  const char a[3] = "hi";

-  int b[3];

-#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.

-  CopyArray(a, &b);

-  EXPECT_TRUE(ArrayEq(a, b));

-#endif

-

-  int c[3];

-  CopyArray(a, 3, c);

-  EXPECT_TRUE(ArrayEq(a, c));

-}

-

-TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {

-  const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };

-  int b[2][3];

-#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.

-  CopyArray(a, &b);

-  EXPECT_TRUE(ArrayEq(a, b));

-#endif

-

-  int c[2][3];

-  CopyArray(a, 2, c);

-  EXPECT_TRUE(ArrayEq(a, c));

-}

-

-// Tests NativeArray.

-

-TEST(NativeArrayTest, ConstructorFromArrayWorks) {

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

-  NativeArray<int> na(a, 3, kReference);

-  EXPECT_EQ(3U, na.size());

-  EXPECT_EQ(a, na.begin());

-}

-

-TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) {

-  typedef int Array[2];

-  Array* a = new Array[1];

-  (*a)[0] = 0;

-  (*a)[1] = 1;

-  NativeArray<int> na(*a, 2, kCopy);

-  EXPECT_NE(*a, na.begin());

-  delete[] a;

-  EXPECT_EQ(0, na.begin()[0]);

-  EXPECT_EQ(1, na.begin()[1]);

-

-  // We rely on the heap checker to verify that na deletes the copy of

-  // array.

-}

-

-TEST(NativeArrayTest, TypeMembersAreCorrect) {

-  StaticAssertTypeEq<char, NativeArray<char>::value_type>();

-  StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>();

-

-  StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>();

-  StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>();

-}

-

-TEST(NativeArrayTest, MethodsWork) {

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

-  NativeArray<int> na(a, 3, kCopy);

-  ASSERT_EQ(3U, na.size());

-  EXPECT_EQ(3, na.end() - na.begin());

-

-  NativeArray<int>::const_iterator it = na.begin();

-  EXPECT_EQ(0, *it);

-  ++it;

-  EXPECT_EQ(1, *it);

-  it++;

-  EXPECT_EQ(2, *it);

-  ++it;

-  EXPECT_EQ(na.end(), it);

-

-  EXPECT_TRUE(na == na);

-

-  NativeArray<int> na2(a, 3, kReference);

-  EXPECT_TRUE(na == na2);

-

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

-  const int b2[4] = { 0, 1, 2, 3 };

-  EXPECT_FALSE(na == NativeArray<int>(b1, 3, kReference));

-  EXPECT_FALSE(na == NativeArray<int>(b2, 4, kCopy));

-}

-

-TEST(NativeArrayTest, WorksForTwoDimensionalArray) {

-  const char a[2][3] = { "hi", "lo" };

-  NativeArray<char[3]> na(a, 2, kReference);

-  ASSERT_EQ(2U, na.size());

-  EXPECT_EQ(a, na.begin());

-}

-

-// Tests SkipPrefix().

-

-TEST(SkipPrefixTest, SkipsWhenPrefixMatches) {

-  const char* const str = "hello";

-

-  const char* p = str;

-  EXPECT_TRUE(SkipPrefix("", &p));

-  EXPECT_EQ(str, p);

-

-  p = str;

-  EXPECT_TRUE(SkipPrefix("hell", &p));

-  EXPECT_EQ(str + 4, p);

-}

-

-TEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) {

-  const char* const str = "world";

-

-  const char* p = str;

-  EXPECT_FALSE(SkipPrefix("W", &p));

-  EXPECT_EQ(str, p);

-

-  p = str;

-  EXPECT_FALSE(SkipPrefix("world!", &p));

-  EXPECT_EQ(str, p);

-}

+// 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: wan@google.com (Zhanyong Wan)
+//
+// Tests for Google Test itself.  This verifies that the basic constructs of
+// Google Test work.
+
+#include "gtest/gtest.h"
+#include <vector>
+#include <ostream>
+
+// 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(stream_result_to) != "unknown"
+      || 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>
+
+#include <map>
+
+namespace testing {
+namespace internal {
+
+// 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(stream_result_to);
+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::TestCase;
+using testing::TestEventListeners;
+using testing::TestPartResult;
+using testing::TestPartResultArray;
+using testing::TestProperty;
+using testing::TestResult;
+using testing::UnitTest;
+using testing::kMaxStackTraceDepth;
+using testing::internal::AddReference;
+using testing::internal::AlwaysFalse;
+using testing::internal::AlwaysTrue;
+using testing::internal::AppendUserMessage;
+using testing::internal::ArrayAwareFind;
+using testing::internal::ArrayEq;
+using testing::internal::CodePointToUtf8;
+using testing::internal::CompileAssertTypesEqual;
+using testing::internal::CopyArray;
+using testing::internal::CountIf;
+using testing::internal::EqFailure;
+using testing::internal::FloatingPoint;
+using testing::internal::ForEach;
+using testing::internal::FormatTimeInMillisAsSeconds;
+using testing::internal::GTestFlagSaver;
+using testing::internal::GetCurrentOsStackTraceExceptTop;
+using testing::internal::GetElementOr;
+using testing::internal::GetNextRandomSeed;
+using testing::internal::GetRandomSeedFromFlag;
+using testing::internal::GetTestTypeId;
+using testing::internal::GetTypeId;
+using testing::internal::GetUnitTestImpl;
+using testing::internal::ImplicitlyConvertible;
+using testing::internal::Int32;
+using testing::internal::Int32FromEnvOrDie;
+using testing::internal::IsAProtocolMessage;
+using testing::internal::IsContainer;
+using testing::internal::IsContainerTest;
+using testing::internal::IsNotContainer;
+using testing::internal::NativeArray;
+using testing::internal::ParseInt32Flag;
+using testing::internal::RemoveConst;
+using testing::internal::RemoveReference;
+using testing::internal::ShouldRunTestOnShard;
+using testing::internal::ShouldShard;
+using testing::internal::ShouldUseColor;
+using testing::internal::Shuffle;
+using testing::internal::ShuffleRange;
+using testing::internal::SkipPrefix;
+using testing::internal::StreamableToString;
+using testing::internal::String;
+using testing::internal::TestEventListenersAccessor;
+using testing::internal::TestResultAccessor;
+using testing::internal::UInt32;
+using testing::internal::WideStringToUtf8;
+using testing::internal::kCopy;
+using testing::internal::kMaxRandomSeed;
+using testing::internal::kReference;
+using testing::internal::kTestTypeIdInGoogleTest;
+using testing::internal::scoped_ptr;
+
+#if GTEST_HAS_STREAM_REDIRECTION
+using testing::internal::CaptureStdout;
+using testing::internal::GetCapturedStdout;
+#endif
+
+#if GTEST_IS_THREADSAFE
+using testing::internal::ThreadWithParam;
+#endif
+
+class TestingVector : public std::vector<int> {
+};
+
+::std::ostream& operator<<(::std::ostream& os,
+                           const TestingVector& vector) {
+  os << "{ ";
+  for (size_t i = 0; i < vector.size(); i++) {
+    os << vector[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_EQ("0", FormatTimeInMillisAsSeconds(0));
+}
+
+TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {
+  EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3));
+  EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10));
+  EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200));
+  EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200));
+  EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000));
+}
+
+TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
+  EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3));
+  EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10));
+  EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200));
+  EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200));
+  EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000));
+}
+
+#if GTEST_CAN_COMPARE_NULL
+
+# 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));
+
+# 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));
+
+# 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" suppressed them.
+#  pragma option pop
+# endif
+
+#endif  // GTEST_CAN_COMPARE_NULL
+//
+// 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
+  // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints
+  // in wide strings and wide chars. In order to accomodate them, we have to
+  // introduce such character constants as integers.
+  EXPECT_STREQ("\xD5\xB6",
+               CodePointToUtf8(static_cast<wchar_t>(0x576), 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(static_cast<wchar_t>(0x8D3), buffer));
+
+  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
+  EXPECT_STREQ("\xEC\x9D\x8D",
+               CodePointToUtf8(static_cast<wchar_t>(0xC74D), 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
+  const wchar_t s[] = { 0x576, '\0' };
+  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str());
+  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -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
+  const wchar_t s1[] = { 0x8D3, '\0' };
+  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str());
+  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str());
+
+  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
+  const wchar_t s2[] = { 0xC74D, '\0' };
+  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str());
+  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -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) {
+  const wchar_t s[] = { 0xD801, 0xDC00, '\0' };
+  EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -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.
+  const wchar_t s1[] = { 0xD800, '\0' };
+  EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str());
+  // Leading surrogate is not followed by the trailing surrogate.
+  const wchar_t s2[] = { 0xD800, 'M', '\0' };
+  EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str());
+  // Trailing surrogate appearas without a leading surrogate.
+  const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' };
+  EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str());
+}
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
+
+// Tests that codepoint concatenation works correctly.
+#if !GTEST_WIDE_STRING_USES_UTF16_
+TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
+  const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
+  EXPECT_STREQ(
+      "\xF4\x88\x98\xB4"
+          "\xEC\x9D\x8D"
+          "\n"
+          "\xD5\xB6"
+          "\xE0\xA3\x93"
+          "\xF4\x88\x98\xB4",
+      WideStringToUtf8(s, -1).c_str());
+}
+#else
+TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
+  const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'};
+  EXPECT_STREQ(
+      "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
+      WideStringToUtf8(s, -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 STL container utilities.
+
+// Tests CountIf().
+
+static bool IsPositive(int n) { return n > 0; }
+
+TEST(ContainerUtilityTest, CountIf) {
+  std::vector<int> v;
+  EXPECT_EQ(0, CountIf(v, IsPositive));  // Works for an empty container.
+
+  v.push_back(-1);
+  v.push_back(0);
+  EXPECT_EQ(0, CountIf(v, IsPositive));  // Works when no value satisfies.
+
+  v.push_back(2);
+  v.push_back(-10);
+  v.push_back(10);
+  EXPECT_EQ(2, CountIf(v, IsPositive));
+}
+
+// Tests ForEach().
+
+static int g_sum = 0;
+static void Accumulate(int n) { g_sum += n; }
+
+TEST(ContainerUtilityTest, ForEach) {
+  std::vector<int> v;
+  g_sum = 0;
+  ForEach(v, Accumulate);
+  EXPECT_EQ(0, g_sum);  // Works for an empty container;
+
+  g_sum = 0;
+  v.push_back(1);
+  ForEach(v, Accumulate);
+  EXPECT_EQ(1, g_sum);  // Works for a container with one element.
+
+  g_sum = 0;
+  v.push_back(20);
+  v.push_back(300);
+  ForEach(v, Accumulate);
+  EXPECT_EQ(321, g_sum);
+}
+
+// Tests GetElementOr().
+TEST(ContainerUtilityTest, GetElementOr) {
+  std::vector<char> a;
+  EXPECT_EQ('x', GetElementOr(a, 0, 'x'));
+
+  a.push_back('a');
+  a.push_back('b');
+  EXPECT_EQ('a', GetElementOr(a, 0, 'x'));
+  EXPECT_EQ('b', GetElementOr(a, 1, 'x'));
+  EXPECT_EQ('x', GetElementOr(a, -2, 'x'));
+  EXPECT_EQ('x', GetElementOr(a, 2, 'x'));
+}
+
+TEST(ContainerUtilityDeathTest, ShuffleRange) {
+  std::vector<int> a;
+  a.push_back(0);
+  a.push_back(1);
+  a.push_back(2);
+  testing::internal::Random random(1);
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      ShuffleRange(&random, -1, 1, &a),
+      "Invalid shuffle range start -1: must be in range \\[0, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      ShuffleRange(&random, 4, 4, &a),
+      "Invalid shuffle range start 4: must be in range \\[0, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      ShuffleRange(&random, 3, 2, &a),
+      "Invalid shuffle range finish 2: must be in range \\[3, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      ShuffleRange(&random, 3, 4, &a),
+      "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_.push_back(i);
+    }
+  }
+
+  static bool VectorIsCorrupt(const TestingVector& vector) {
+    if (kVectorSize != static_cast<int>(vector.size())) {
+      return true;
+    }
+
+    bool found_in_vector[kVectorSize] = { false };
+    for (size_t i = 0; i < vector.size(); i++) {
+      const int e = vector[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[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, static_cast<int>(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...
+  ShuffleRange(&random_, 0, 0, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...in the middle...
+  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...at the end...
+  ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...and past the end.
+  ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+}
+
+TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
+  // Tests a size one range at the beginning...
+  ShuffleRange(&random_, 0, 1, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...in the middle...
+  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...and at the end.
+  ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_);
+  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) {
+  Shuffle(&random_, &vector_);
+  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_[0]);
+  EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]);
+}
+
+TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
+  const int kRangeSize = kVectorSize/2;
+
+  ShuffleRange(&random_, 0, kRangeSize, &vector_);
+
+  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;
+  ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
+  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize);
+}
+
+TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
+  int kRangeSize = kVectorSize/3;
+  ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_);
+
+  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.push_back(i);
+  }
+
+  random_.Reseed(1234);
+  Shuffle(&random_, &vector_);
+  random_.Reseed(1234);
+  Shuffle(&random_, &vector2);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector2);
+
+  for (int i = 0; i < kVectorSize; i++) {
+    EXPECT_EQ(vector_[i], vector2[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]);
+}
+
+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);
+}
+
+#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");
+
+  // Use explicit function call notation here to suppress self-assign warning.
+  dest.operator=(dest);
+  EXPECT_STREQ("hello", dest.c_str());
+}
+
+// Sun Studio < 12 incorrectly rejects this code due to an overloading
+// ambiguity.
+#if !(defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
+// 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");
+}
+#endif
+
+// 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
+
+class ScopedFakeTestPartResultReporterWithThreadsTest
+  : public ScopedFakeTestPartResultReporterTest {
+ protected:
+  static void AddFailureInOtherThread(FailureMode failure) {
+    ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
+    thread.Join();
+  }
+};
+
+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
+
+// 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.");
+}
+
+#if GTEST_HAS_GLOBAL_STRING
+TEST_F(ExpectFatalFailureTest, AcceptsStringObject) {
+  EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure."));
+}
+#endif
+
+TEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) {
+  EXPECT_FATAL_FAILURE(AddFatalFailure(),
+                       ::std::string("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" suppressed 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.
+  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.");
+}
+
+#if GTEST_HAS_GLOBAL_STRING
+TEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) {
+  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
+                          ::string("Expected non-fatal failure."));
+}
+#endif
+
+TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {
+  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
+                          ::std::string("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
+
+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
+
+// 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 TestResult class
+
+// The test fixture for testing TestResult.
+class TestResultTest : public Test {
+ protected:
+  typedef std::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<TPRVector*>(
+        &TestResultAccessor::test_part_results(*r1));
+    TPRVector* results2 = const_cast<TPRVector*>(
+        &TestResultAccessor::test_part_results(*r2));
+
+    // r0 is an empty TestResult.
+
+    // r1 contains a single SUCCESS TestPartResult.
+    results1->push_back(*pr1);
+
+    // r2 contains a SUCCESS, and a FAILURE.
+    results2->push_back(*pr1);
+    results2->push_back(*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), "");
+  EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-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), "");
+  EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), "");
+}
+
+// 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(stack_trace_depth) = kMaxStackTraceDepth;
+    GTEST_FLAG(stream_result_to) = "";
+    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_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth));
+    EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str());
+    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(stack_trace_depth) = 1;
+    GTEST_FLAG(stream_result_to) = "localhost:1234";
+    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__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
+  // 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());
+
+  // The standard signature of putenv accepts a 'char*' argument. Other
+  // implementations, like C++Builder's, accept a 'const char*'.
+  // We cast away the 'const' since that would work for both variants.
+  putenv(const_cast<char*>(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 function that returns AssertionResult for use in
+// EXPECT/ASSERT_TRUE/FALSE.
+AssertionResult ResultIsEven(int n) {
+  if (IsEven(n))
+    return AssertionSuccess() << n << " is even";
+  else
+    return AssertionFailure() << n << " is odd";
+}
+
+// A predicate function that returns AssertionResult but gives no
+// explanation why it succeeds. Needed for testing that
+// EXPECT/ASSERT_FALSE handles such functions correctly.
+AssertionResult ResultIsEvenNoExplanation(int n) {
+  if (IsEven(n))
+    return AssertionSuccess();
+  else
+    return AssertionFailure() << n << " is odd";
+}
+
+// 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(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());
+}
+
+// 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")));
+}
+
+#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());
+}
+
+// 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());
+}
+
+#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.
+  // We use the assignment syntax since some compilers, like Sun Studio,
+  // don't allow initializing references using construction syntax
+  // (parentheses).
+  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.
+  // We use the assignment syntax since some compilers, like Sun Studio,
+  // don't allow initializing references using construction syntax
+  // (parentheses).
+  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.5f, 0.25f),  // NOLINT
+                          "The difference between 1.0f and 1.5f is 0.5, "
+                          "which exceeds 0.25f");
+  // 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.5f, 0.25f),  // NOLINT
+                       "The difference between 1.0f and 1.5f is 0.5, "
+                       "which exceeds 0.25f");
+  // 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.
+  // We use the assignment syntax since some compilers, like Sun Studio,
+  // don't allow initializing references using construction syntax
+  // (parentheses).
+  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.
+  // We use the assignment syntax since some compilers, like Sun Studio,
+  // don't allow initializing references using construction syntax
+  // (parentheses).
+  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.5, 0.25),  // NOLINT
+                          "The difference between 1.0 and 1.5 is 0.5, "
+                          "which exceeds 0.25");
+  // 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.5, 0.25),  // NOLINT
+                       "The difference between 1.0 and 1.5 is 0.5, "
+                       "which exceeds 0.25");
+  // 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_TRUE(predicate) for predicates returning AssertionResult.
+TEST(AssertionTest, AssertTrueWithAssertionResult) {
+  ASSERT_TRUE(ResultIsEven(2));
+#ifndef __BORLANDC__
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)),
+                       "Value of: ResultIsEven(3)\n"
+                       "  Actual: false (3 is odd)\n"
+                       "Expected: true");
+#endif
+  ASSERT_TRUE(ResultIsEvenNoExplanation(2));
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)),
+                       "Value of: ResultIsEvenNoExplanation(3)\n"
+                       "  Actual: false (3 is odd)\n"
+                       "Expected: true");
+}
+
+// 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");
+}
+
+// Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult.
+TEST(AssertionTest, AssertFalseWithAssertionResult) {
+  ASSERT_FALSE(ResultIsEven(3));
+#ifndef __BORLANDC__
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)),
+                       "Value of: ResultIsEven(2)\n"
+                       "  Actual: true (2 is even)\n"
+                       "Expected: false");
+#endif
+  ASSERT_FALSE(ResultIsEvenNoExplanation(3));
+  EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)),
+                       "Value of: ResultIsEvenNoExplanation(2)\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_CAN_COMPARE_NULL
+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_CAN_COMPARE_NULL
+
+// 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);
+
+# ifndef __BORLANDC__
+
+  // ICE's in C++Builder 2007 and 2009.
+  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);
+  bool false_value = false;
+  ASSERT_EQ(true && false_value, 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 a_value) : value_(a_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");
+}
+
+enum NamedEnum {
+  kE1 = 0,
+  kE2 = 1
+};
+
+TEST(AssertionTest, NamedEnum) {
+  EXPECT_EQ(kE1, kE1);
+  EXPECT_LT(kE1, kE2);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Actual: 1");
+}
+
+// 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.
+// Sun Studio and HP aCC also reject this code.
+#if !GTEST_OS_MAC && !defined(__SUNPRO_CC) && !defined(__HP_aCC)
+
+// Tests using assertions with anonymous enums.
+enum {
+  kCaseA = -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, kCaseB and kCaseA have the same value when truncated to
+  // int size.  We want to test whether this will confuse the
+  // assertions.
+  kCaseB = testing::internal::kMaxBiggestInt,
+
+# else
+
+  kCaseB = INT_MAX,
+
+# endif  // GTEST_OS_LINUX
+
+  kCaseC = 42
+};
+
+TEST(AssertionTest, AnonymousEnum) {
+# if GTEST_OS_LINUX
+
+  EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));
+
+# endif  // GTEST_OS_LINUX
+
+  EXPECT_EQ(kCaseA, kCaseA);
+  EXPECT_NE(kCaseA, kCaseB);
+  EXPECT_LT(kCaseA, kCaseB);
+  EXPECT_LE(kCaseA, kCaseB);
+  EXPECT_GT(kCaseB, kCaseA);
+  EXPECT_GE(kCaseA, kCaseA);
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB),
+                          "(kCaseA) >= (kCaseB)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC),
+                          "-1 vs 42");
+
+  ASSERT_EQ(kCaseA, kCaseA);
+  ASSERT_NE(kCaseA, kCaseB);
+  ASSERT_LT(kCaseA, kCaseB);
+  ASSERT_LE(kCaseA, kCaseB);
+  ASSERT_GT(kCaseB, kCaseA);
+  ASSERT_GE(kCaseA, kCaseA);
+
+# ifndef __BORLANDC__
+
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
+                       "Value of: kCaseB");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
+                       "Actual: 42");
+# endif
+
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
+                       "Which is: -1");
+}
+
+#endif  // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
+
+#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_TRUE(predicate) for predicates returning AssertionResult.
+TEST(ExpectTest, ExpectTrueWithAssertionResult) {
+  EXPECT_TRUE(ResultIsEven(2));
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)),
+                          "Value of: ResultIsEven(3)\n"
+                          "  Actual: false (3 is odd)\n"
+                          "Expected: true");
+  EXPECT_TRUE(ResultIsEvenNoExplanation(2));
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)),
+                          "Value of: ResultIsEvenNoExplanation(3)\n"
+                          "  Actual: false (3 is odd)\n"
+                          "Expected: true");
+}
+
+// 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");
+}
+
+// Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult.
+TEST(ExpectTest, ExpectFalseWithAssertionResult) {
+  EXPECT_FALSE(ResultIsEven(3));
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)),
+                          "Value of: ResultIsEven(2)\n"
+                          "  Actual: true (2 is even)\n"
+                          "Expected: false");
+  EXPECT_FALSE(ResultIsEvenNoExplanation(3));
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)),
+                          "Value of: ResultIsEvenNoExplanation(2)\n"
+                          "  Actual: true\n"
+                          "Expected: false");
+}
+
+#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_CAN_COMPARE_NULL
+// Tests EXPECT_EQ(NULL, pointer).
+TEST(ExpectTest, EXPECT_EQ_NULL) {
+  // A success.
+  const char* p = NULL;
+  // Some older GCC versions may issue a spurious warning 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_CAN_COMPARE_NULL
+
+// 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.
+
+// 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");
+}
+
+// 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 ADD_FAILURE_AT.
+TEST(MacroTest, ADD_FAILURE_AT) {
+  // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and
+  // the failure message contains the user-streamed part.
+  EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!");
+
+  // Verifies that the user-streamed part is optional.
+  EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed");
+
+  // Unfortunately, we cannot verify that the failure message contains
+  // the right file path and line number the same way, as
+  // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and
+  // line number.  Instead, we do that in gtest_output_test_.cc.
+}
+
+// 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({
+      bool false_value = false;
+      ASSERT_EQ(false_value, 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 = 0x8119;
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
+                       "Value of: wchar");
+}
+
+// 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\"");
+}
+
+#if GTEST_HAS_STD_WSTRING
+
+// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, StdWideString) {
+  // 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 identical
+  // content.
+  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
+  EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119);
+
+  // Compares an std::wstring to a const wchar_t* that has different
+  // content.
+  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
+  }, "kTestX8120");
+
+  // 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 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 identical content.
+  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
+  ASSERT_EQ(kTestX8119, ::wstring(kTestX8119));
+
+  // Compares a const wchar_t* to a ::wstring that has different
+  // content.
+  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EQ(kTestX8120, ::wstring(kTestX8119));
+  }, "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");
+}
+
+// A class that supports binary comparison operators but not streaming.
+class UnprintableChar {
+ public:
+  explicit UnprintableChar(char ch) : char_(ch) {}
+
+  bool operator==(const UnprintableChar& rhs) const {
+    return char_ == rhs.char_;
+  }
+  bool operator!=(const UnprintableChar& rhs) const {
+    return char_ != rhs.char_;
+  }
+  bool operator<(const UnprintableChar& rhs) const {
+    return char_ < rhs.char_;
+  }
+  bool operator<=(const UnprintableChar& rhs) const {
+    return char_ <= rhs.char_;
+  }
+  bool operator>(const UnprintableChar& rhs) const {
+    return char_ > rhs.char_;
+  }
+  bool operator>=(const UnprintableChar& rhs) const {
+    return char_ >= rhs.char_;
+  }
+
+ private:
+  char char_;
+};
+
+// Tests that ASSERT_EQ() and friends don't require the arguments to
+// be printable.
+TEST(ComparisonAssertionTest, AcceptsUnprintableArgs) {
+  const UnprintableChar x('x'), y('y');
+  ASSERT_EQ(x, x);
+  EXPECT_NE(x, y);
+  ASSERT_LT(x, y);
+  EXPECT_LE(x, y);
+  ASSERT_GT(y, x);
+  EXPECT_GE(x, x);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>");
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>");
+
+  // Code tested by EXPECT_FATAL_FAILURE cannot reference local
+  // variables, so we have to write UnprintableChar('x') instead of x.
+#ifndef __BORLANDC__
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')),
+                       "1-byte object <78>");
+  EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
+                       "1-byte object <78>");
+#endif
+  EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
+                       "1-byte object <79>");
+  EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
+                       "1-byte object <78>");
+  EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
+                       "1-byte object <79>");
+}
+
+// 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 that the copy constructor works when it is NOT optimized away by
+// the compiler.
+TEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) {
+  // Checks that the copy constructor doesn't try to dereference NULL pointers
+  // in the source object.
+  AssertionResult r1 = AssertionSuccess();
+  AssertionResult r2 = r1;
+  // The following line is added to prevent the compiler from optimizing
+  // away the constructor call.
+  r1 << "abc";
+
+  AssertionResult r3 = r1;
+  EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1));
+  EXPECT_STREQ("abc", r1.message());
+}
+
+// Tests that AssertionSuccess and AssertionFailure construct
+// AssertionResult objects as expected.
+TEST(AssertionResultTest, ConstructionWorks) {
+  AssertionResult r1 = AssertionSuccess();
+  EXPECT_TRUE(r1);
+  EXPECT_STREQ("", r1.message());
+
+  AssertionResult r2 = AssertionSuccess() << "abc";
+  EXPECT_TRUE(r2);
+  EXPECT_STREQ("abc", r2.message());
+
+  AssertionResult r3 = AssertionFailure();
+  EXPECT_FALSE(r3);
+  EXPECT_STREQ("", r3.message());
+
+  AssertionResult r4 = AssertionFailure() << "def";
+  EXPECT_FALSE(r4);
+  EXPECT_STREQ("def", r4.message());
+
+  AssertionResult r5 = AssertionFailure(Message() << "ghi");
+  EXPECT_FALSE(r5);
+  EXPECT_STREQ("ghi", r5.message());
+}
+
+// Tests that the negation flips the predicate result but keeps the message.
+TEST(AssertionResultTest, NegationWorks) {
+  AssertionResult r1 = AssertionSuccess() << "abc";
+  EXPECT_FALSE(!r1);
+  EXPECT_STREQ("abc", (!r1).message());
+
+  AssertionResult r2 = AssertionFailure() << "def";
+  EXPECT_TRUE(!r2);
+  EXPECT_STREQ("def", (!r2).message());
+}
+
+TEST(AssertionResultTest, StreamingWorks) {
+  AssertionResult r = AssertionSuccess();
+  r << "abc" << 'd' << 0 << true;
+  EXPECT_STREQ("abcd0true", r.message());
+}
+
+TEST(AssertionResultTest, CanStreamOstreamManipulators) {
+  AssertionResult r = AssertionSuccess();
+  r << "Data" << std::endl << std::flush << std::ends << "Will be visible";
+  EXPECT_STREQ("Data\n\\0Will be visible", r.message());
+}
+
+// Tests streaming a user type whose definition and operator << are
+// both in the global namespace.
+class Base {
+ public:
+  explicit Base(int an_x) : x_(an_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 an_x): Base(an_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 an_x): Base(an_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 an_x): Base(an_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),
+            stack_trace_depth(kMaxStackTraceDepth),
+            stream_result_to(""),
+            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_FLAG(stack_trace_depth) flag has
+  // the given value.
+  static Flags StackTraceDepth(Int32 stack_trace_depth) {
+    Flags flags;
+    flags.stack_trace_depth = stack_trace_depth;
+    return flags;
+  }
+
+  // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has
+  // the given value.
+  static Flags StreamResultTo(const char* stream_result_to) {
+    Flags flags;
+    flags.stream_result_to = stream_result_to;
+    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;
+  Int32 stack_trace_depth;
+  const char* stream_result_to;
+  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(stack_trace_depth) = kMaxStackTraceDepth;
+    GTEST_FLAG(stream_result_to) = "";
+    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.stack_trace_depth, GTEST_FLAG(stack_trace_depth));
+    EXPECT_STREQ(expected.stream_result_to,
+                 GTEST_FLAG(stream_result_to).c_str());
+    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, bool should_print_help) {
+    const bool saved_help_flag = ::testing::internal::g_help_flag;
+    ::testing::internal::g_help_flag = false;
+
+#if GTEST_HAS_STREAM_REDIRECTION
+    CaptureStdout();
+#endif
+
+    // Parses the command line.
+    internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
+
+#if GTEST_HAS_STREAM_REDIRECTION
+    const String captured_stdout = GetCapturedStdout();
+#endif
+
+    // Verifies the flag values.
+    CheckFlags(expected);
+
+    // Verifies that the recognized flags are removed from the command
+    // line.
+    AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);
+
+    // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the
+    // help message for the flags it recognizes.
+    EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
+
+#if GTEST_HAS_STREAM_REDIRECTION
+    const char* const expected_help_fragment =
+        "This program contains tests written using";
+    if (should_print_help) {
+      EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);
+    } else {
+      EXPECT_PRED_FORMAT2(IsNotSubstring,
+                          expected_help_fragment, captured_stdout);
+    }
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+    ::testing::internal::g_help_flag = saved_help_flag;
+  }
+
+  // This macro wraps TestParsingFlags s.t. the user doesn't need
+  // to specify the array sizes.
+
+#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
+  TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
+                   sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
+                   expected, should_print_help)
+};
+
+// 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(), false);
+}
+
+// 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(), false);
+}
+
+// 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(""), true);
+}
+
+// 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(""), false);
+}
+
+// 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"), false);
+}
+
+// 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), false);
+}
+
+// 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), 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), 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), 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), false);
+}
+
+// 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), false);
+}
+
+// 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), false);
+}
+
+// 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"), false);
+}
+
+// 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, false);
+}
+
+// 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), false);
+}
+
+// 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), false);
+}
+
+// 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), 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), 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), 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(), true);
+}
+
+// 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"), false);
+}
+
+// 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"), false);
+}
+
+// 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/"), false);
+}
+
+// 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), false);
+}
+
+// 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), false);
+}
+
+// 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), 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), 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), 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), false);
+}
+
+// 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), false);
+}
+
+// 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), false);
+}
+
+// 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), false);
+}
+
+// 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), 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), false);
+}
+
+// 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), 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), false);
+}
+
+// Tests parsing --gtest_stack_trace_depth=number.
+TEST_F(InitGoogleTestTest, StackTraceDepth) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_stack_trace_depth=5",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
+}
+
+TEST_F(InitGoogleTestTest, StreamResultTo) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_stream_result_to=localhost:1234",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(
+      argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
+}
+
+// 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), false);
+}
+
+// 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), 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), false);
+}
+
+#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, false);
+}
+#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", "xterm-256color");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "screen");  // 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.
+
+  SetEnv("TERM", "cygwin");  // 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 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>();
+static bool dummy2 GTEST_ATTRIBUTE_UNUSED_ =
+    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(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(std::vector<String>* vector, const char* id)
+      : vector_(vector), id_(id) {}
+
+ protected:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
+    vector_->push_back(GetEventDescription("OnTestProgramStart"));
+  }
+
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
+    vector_->push_back(GetEventDescription("OnTestProgramEnd"));
+  }
+
+  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                                    int /*iteration*/) {
+    vector_->push_back(GetEventDescription("OnTestIterationStart"));
+  }
+
+  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                                  int /*iteration*/) {
+    vector_->push_back(GetEventDescription("OnTestIterationEnd"));
+  }
+
+ private:
+  String GetEventDescription(const char* method) {
+    Message message;
+    message << id_ << "." << method;
+    return message.GetString();
+  }
+
+  std::vector<String>* vector_;
+  const char* const id_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);
+};
+
+TEST(EventListenerTest, AppendKeepsOrder) {
+  std::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(3U, vec.size());
+  EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());
+  EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());
+  EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());
+
+  vec.clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
+      *UnitTest::GetInstance());
+  ASSERT_EQ(3U, vec.size());
+  EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());
+  EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());
+  EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());
+
+  vec.clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
+      *UnitTest::GetInstance(), 0);
+  ASSERT_EQ(3U, vec.size());
+  EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());
+  EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());
+  EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());
+
+  vec.clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
+      *UnitTest::GetInstance(), 0);
+  ASSERT_EQ(3U, vec.size());
+  EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());
+  EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());
+  EXPECT_STREQ("1st.OnTestIterationEnd", vec[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;
+}
+
+// Sanity tests to ensure that the alternative, verbose spellings of
+// some of the macros work.  We don't test them thoroughly as that
+// would be quite involved.  Since their implementations are
+// straightforward, and they are rarely used, we'll just rely on the
+// users to tell us when they are broken.
+GTEST_TEST(AlternativeNameTest, Works) {  // GTEST_TEST is the same as TEST.
+  GTEST_SUCCEED() << "OK";  // GTEST_SUCCEED is the same as SUCCEED.
+
+  // GTEST_FAIL is the same as FAIL.
+  EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure",
+                       "An expected failure");
+
+  // GTEST_ASSERT_XY is the same as ASSERT_XY.
+
+  GTEST_ASSERT_EQ(0, 0);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure",
+                       "An expected failure");
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_NE(0, 1);
+  GTEST_ASSERT_NE(1, 0);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_LE(0, 0);
+  GTEST_ASSERT_LE(0, 1);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_LT(0, 1);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure",
+                       "An expected failure");
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_GE(0, 0);
+  GTEST_ASSERT_GE(1, 0);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_GT(1, 0);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure",
+                       "An expected failure");
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure",
+                       "An expected failure");
+}
+
+// Tests for internal utilities necessary for implementation of the universal
+// printing.
+// TODO(vladl@google.com): Find a better home for them.
+
+class ConversionHelperBase {};
+class ConversionHelperDerived : public ConversionHelperBase {};
+
+// Tests that IsAProtocolMessage<T>::value is a compile-time constant.
+TEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) {
+  GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value,
+                        const_true);
+  GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false);
+}
+
+// Tests that IsAProtocolMessage<T>::value is true when T is
+// proto2::Message or a sub-class of it.
+TEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) {
+  EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value);
+  EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value);
+}
+
+// Tests that IsAProtocolMessage<T>::value is false when T is neither
+// ProtocolMessage nor a sub-class of it.
+TEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) {
+  EXPECT_FALSE(IsAProtocolMessage<int>::value);
+  EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value);
+}
+
+// Tests that CompileAssertTypesEqual compiles when the type arguments are
+// equal.
+TEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) {
+  CompileAssertTypesEqual<void, void>();
+  CompileAssertTypesEqual<int*, int*>();
+}
+
+// Tests that RemoveReference does not affect non-reference types.
+TEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) {
+  CompileAssertTypesEqual<int, RemoveReference<int>::type>();
+  CompileAssertTypesEqual<const char, RemoveReference<const char>::type>();
+}
+
+// Tests that RemoveReference removes reference from reference types.
+TEST(RemoveReferenceTest, RemovesReference) {
+  CompileAssertTypesEqual<int, RemoveReference<int&>::type>();
+  CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>();
+}
+
+// Tests GTEST_REMOVE_REFERENCE_.
+
+template <typename T1, typename T2>
+void TestGTestRemoveReference() {
+  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>();
+}
+
+TEST(RemoveReferenceTest, MacroVersion) {
+  TestGTestRemoveReference<int, int>();
+  TestGTestRemoveReference<const char, const char&>();
+}
+
+
+// Tests that RemoveConst does not affect non-const types.
+TEST(RemoveConstTest, DoesNotAffectNonConstType) {
+  CompileAssertTypesEqual<int, RemoveConst<int>::type>();
+  CompileAssertTypesEqual<char&, RemoveConst<char&>::type>();
+}
+
+// Tests that RemoveConst removes const from const types.
+TEST(RemoveConstTest, RemovesConst) {
+  CompileAssertTypesEqual<int, RemoveConst<const int>::type>();
+  CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>();
+  CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>();
+}
+
+// Tests GTEST_REMOVE_CONST_.
+
+template <typename T1, typename T2>
+void TestGTestRemoveConst() {
+  CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>();
+}
+
+TEST(RemoveConstTest, MacroVersion) {
+  TestGTestRemoveConst<int, int>();
+  TestGTestRemoveConst<double&, double&>();
+  TestGTestRemoveConst<char, const char>();
+}
+
+// Tests GTEST_REMOVE_REFERENCE_AND_CONST_.
+
+template <typename T1, typename T2>
+void TestGTestRemoveReferenceAndConst() {
+  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>();
+}
+
+TEST(RemoveReferenceToConstTest, Works) {
+  TestGTestRemoveReferenceAndConst<int, int>();
+  TestGTestRemoveReferenceAndConst<double, double&>();
+  TestGTestRemoveReferenceAndConst<char, const char>();
+  TestGTestRemoveReferenceAndConst<char, const char&>();
+  TestGTestRemoveReferenceAndConst<const char*, const char*>();
+}
+
+// Tests that AddReference does not affect reference types.
+TEST(AddReferenceTest, DoesNotAffectReferenceType) {
+  CompileAssertTypesEqual<int&, AddReference<int&>::type>();
+  CompileAssertTypesEqual<const char&, AddReference<const char&>::type>();
+}
+
+// Tests that AddReference adds reference to non-reference types.
+TEST(AddReferenceTest, AddsReference) {
+  CompileAssertTypesEqual<int&, AddReference<int>::type>();
+  CompileAssertTypesEqual<const char&, AddReference<const char>::type>();
+}
+
+// Tests GTEST_ADD_REFERENCE_.
+
+template <typename T1, typename T2>
+void TestGTestAddReference() {
+  CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>();
+}
+
+TEST(AddReferenceTest, MacroVersion) {
+  TestGTestAddReference<int&, int>();
+  TestGTestAddReference<const char&, const char&>();
+}
+
+// Tests GTEST_REFERENCE_TO_CONST_.
+
+template <typename T1, typename T2>
+void TestGTestReferenceToConst() {
+  CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>();
+}
+
+TEST(GTestReferenceToConstTest, Works) {
+  TestGTestReferenceToConst<const char&, char>();
+  TestGTestReferenceToConst<const int&, const int>();
+  TestGTestReferenceToConst<const double&, double>();
+  TestGTestReferenceToConst<const String&, const String&>();
+}
+
+// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant.
+TEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) {
+  GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true);
+  GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value),
+                        const_false);
+}
+
+// Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can
+// be implicitly converted to T2.
+TEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) {
+  EXPECT_TRUE((ImplicitlyConvertible<int, double>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<double, int>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&,
+                                     const ConversionHelperBase&>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase,
+                                     ConversionHelperBase>::value));
+}
+
+// Tests that ImplicitlyConvertible<T1, T2>::value is false when T1
+// cannot be implicitly converted to T2.
+TEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) {
+  EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value));
+  EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value));
+  EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value));
+  EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&,
+                                      ConversionHelperDerived&>::value));
+}
+
+// Tests IsContainerTest.
+
+class NonContainer {};
+
+TEST(IsContainerTestTest, WorksForNonContainer) {
+  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0)));
+  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0)));
+  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0)));
+}
+
+TEST(IsContainerTestTest, WorksForContainer) {
+  EXPECT_EQ(sizeof(IsContainer),
+            sizeof(IsContainerTest<std::vector<bool> >(0)));
+  EXPECT_EQ(sizeof(IsContainer),
+            sizeof(IsContainerTest<std::map<int, double> >(0)));
+}
+
+// Tests ArrayEq().
+
+TEST(ArrayEqTest, WorksForDegeneratedArrays) {
+  EXPECT_TRUE(ArrayEq(5, 5L));
+  EXPECT_FALSE(ArrayEq('a', 0));
+}
+
+TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
+  const int a[] = { 0, 1 };
+  long b[] = { 0, 1 };
+  EXPECT_TRUE(ArrayEq(a, b));
+  EXPECT_TRUE(ArrayEq(a, 2, b));
+
+  b[0] = 2;
+  EXPECT_FALSE(ArrayEq(a, b));
+  EXPECT_FALSE(ArrayEq(a, 1, b));
+}
+
+TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {
+  const char a[][3] = { "hi", "lo" };
+  const char b[][3] = { "hi", "lo" };
+  const char c[][3] = { "hi", "li" };
+
+  EXPECT_TRUE(ArrayEq(a, b));
+  EXPECT_TRUE(ArrayEq(a, 2, b));
+
+  EXPECT_FALSE(ArrayEq(a, c));
+  EXPECT_FALSE(ArrayEq(a, 2, c));
+}
+
+// Tests ArrayAwareFind().
+
+TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {
+  const char a[] = "hello";
+  EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o'));
+  EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x'));
+}
+
+TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {
+  int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
+  const int b[2] = { 2, 3 };
+  EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));
+
+  const int c[2] = { 6, 7 };
+  EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));
+}
+
+// Tests CopyArray().
+
+TEST(CopyArrayTest, WorksForDegeneratedArrays) {
+  int n = 0;
+  CopyArray('a', &n);
+  EXPECT_EQ('a', n);
+}
+
+TEST(CopyArrayTest, WorksForOneDimensionalArrays) {
+  const char a[3] = "hi";
+  int b[3];
+#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
+  CopyArray(a, &b);
+  EXPECT_TRUE(ArrayEq(a, b));
+#endif
+
+  int c[3];
+  CopyArray(a, 3, c);
+  EXPECT_TRUE(ArrayEq(a, c));
+}
+
+TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
+  const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };
+  int b[2][3];
+#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
+  CopyArray(a, &b);
+  EXPECT_TRUE(ArrayEq(a, b));
+#endif
+
+  int c[2][3];
+  CopyArray(a, 2, c);
+  EXPECT_TRUE(ArrayEq(a, c));
+}
+
+// Tests NativeArray.
+
+TEST(NativeArrayTest, ConstructorFromArrayWorks) {
+  const int a[3] = { 0, 1, 2 };
+  NativeArray<int> na(a, 3, kReference);
+  EXPECT_EQ(3U, na.size());
+  EXPECT_EQ(a, na.begin());
+}
+
+TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) {
+  typedef int Array[2];
+  Array* a = new Array[1];
+  (*a)[0] = 0;
+  (*a)[1] = 1;
+  NativeArray<int> na(*a, 2, kCopy);
+  EXPECT_NE(*a, na.begin());
+  delete[] a;
+  EXPECT_EQ(0, na.begin()[0]);
+  EXPECT_EQ(1, na.begin()[1]);
+
+  // We rely on the heap checker to verify that na deletes the copy of
+  // array.
+}
+
+TEST(NativeArrayTest, TypeMembersAreCorrect) {
+  StaticAssertTypeEq<char, NativeArray<char>::value_type>();
+  StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>();
+
+  StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>();
+  StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>();
+}
+
+TEST(NativeArrayTest, MethodsWork) {
+  const int a[3] = { 0, 1, 2 };
+  NativeArray<int> na(a, 3, kCopy);
+  ASSERT_EQ(3U, na.size());
+  EXPECT_EQ(3, na.end() - na.begin());
+
+  NativeArray<int>::const_iterator it = na.begin();
+  EXPECT_EQ(0, *it);
+  ++it;
+  EXPECT_EQ(1, *it);
+  it++;
+  EXPECT_EQ(2, *it);
+  ++it;
+  EXPECT_EQ(na.end(), it);
+
+  EXPECT_TRUE(na == na);
+
+  NativeArray<int> na2(a, 3, kReference);
+  EXPECT_TRUE(na == na2);
+
+  const int b1[3] = { 0, 1, 1 };
+  const int b2[4] = { 0, 1, 2, 3 };
+  EXPECT_FALSE(na == NativeArray<int>(b1, 3, kReference));
+  EXPECT_FALSE(na == NativeArray<int>(b2, 4, kCopy));
+}
+
+TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
+  const char a[2][3] = { "hi", "lo" };
+  NativeArray<char[3]> na(a, 2, kReference);
+  ASSERT_EQ(2U, na.size());
+  EXPECT_EQ(a, na.begin());
+}
+
+// Tests SkipPrefix().
+
+TEST(SkipPrefixTest, SkipsWhenPrefixMatches) {
+  const char* const str = "hello";
+
+  const char* p = str;
+  EXPECT_TRUE(SkipPrefix("", &p));
+  EXPECT_EQ(str, p);
+
+  p = str;
+  EXPECT_TRUE(SkipPrefix("hell", &p));
+  EXPECT_EQ(str + 4, p);
+}
+
+TEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) {
+  const char* const str = "world";
+
+  const char* p = str;
+  EXPECT_FALSE(SkipPrefix("W", &p));
+  EXPECT_EQ(str, p);
+
+  p = str;
+  EXPECT_FALSE(SkipPrefix("world!", &p));
+  EXPECT_EQ(str, p);
+}
diff --git a/gtest-1.6.0/test/gtest_xml_outfile1_test_.cc b/gtest-1.6.0/test/gtest_xml_outfile1_test_.cc
index 7de43c7..531ced4 100644
--- a/gtest-1.6.0/test/gtest_xml_outfile1_test_.cc
+++ b/gtest-1.6.0/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: keith.ray@gmail.com (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: keith.ray@gmail.com (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/gtest-1.6.0/test/gtest_xml_outfile2_test_.cc b/gtest-1.6.0/test/gtest_xml_outfile2_test_.cc
index 662e66c..7b400b2 100644
--- a/gtest-1.6.0/test/gtest_xml_outfile2_test_.cc
+++ b/gtest-1.6.0/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: keith.ray@gmail.com (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: keith.ray@gmail.com (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/gtest-1.6.0/test/gtest_xml_outfiles_test.py b/gtest-1.6.0/test/gtest_xml_outfiles_test.py
index c50201f..0fe947f 100755
--- a/gtest-1.6.0/test/gtest_xml_outfiles_test.py
+++ b/gtest-1.6.0/test/gtest_xml_outfiles_test.py
@@ -1,132 +1,132 @@
-#!/usr/bin/env python

-#

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

-

-"""Unit test for the gtest_xml_output module."""

-

-__author__ = "keith.ray@gmail.com (Keith Ray)"

-

-import os

-from xml.dom import minidom, Node

-

-import gtest_test_utils

-import gtest_xml_test_utils

-

-

-GTEST_OUTPUT_SUBDIR = "xml_outfiles"

-GTEST_OUTPUT_1_TEST = "gtest_xml_outfile1_test_"

-GTEST_OUTPUT_2_TEST = "gtest_xml_outfile2_test_"

-

-EXPECTED_XML_1 = """<?xml version="1.0" encoding="UTF-8"?>

-<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" name="AllTests">

-  <testsuite name="PropertyOne" tests="1" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="TestSomeProperties" status="run" time="*" classname="PropertyOne" SetUpProp="1" TestSomeProperty="1" TearDownProp="1" />

-  </testsuite>

-</testsuites>

-"""

-

-EXPECTED_XML_2 = """<?xml version="1.0" encoding="UTF-8"?>

-<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" name="AllTests">

-  <testsuite name="PropertyTwo" tests="1" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="TestSomeProperties" status="run" time="*" classname="PropertyTwo" SetUpProp="2" TestSomeProperty="2" TearDownProp="2" />

-  </testsuite>

-</testsuites>

-"""

-

-

-class GTestXMLOutFilesTest(gtest_xml_test_utils.GTestXMLTestCase):

-  """Unit test for Google Test's XML output functionality."""

-

-  def setUp(self):

-    # We want the trailing '/' that the last "" provides in os.path.join, for

-    # telling Google Test to create an output directory instead of a single file

-    # for xml output.

-    self.output_dir_ = os.path.join(gtest_test_utils.GetTempDir(),

-                                    GTEST_OUTPUT_SUBDIR, "")

-    self.DeleteFilesAndDir()

-

-  def tearDown(self):

-    self.DeleteFilesAndDir()

-

-  def DeleteFilesAndDir(self):

-    try:

-      os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_1_TEST + ".xml"))

-    except os.error:

-      pass

-    try:

-      os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_2_TEST + ".xml"))

-    except os.error:

-      pass

-    try:

-      os.rmdir(self.output_dir_)

-    except os.error:

-      pass

-

-  def testOutfile1(self):

-    self._TestOutFile(GTEST_OUTPUT_1_TEST, EXPECTED_XML_1)

-

-  def testOutfile2(self):

-    self._TestOutFile(GTEST_OUTPUT_2_TEST, EXPECTED_XML_2)

-

-  def _TestOutFile(self, test_name, expected_xml):

-    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(test_name)

-    command = [gtest_prog_path, "--gtest_output=xml:%s" % self.output_dir_]

-    p = gtest_test_utils.Subprocess(command,

-                                    working_dir=gtest_test_utils.GetTempDir())

-    self.assert_(p.exited)

-    self.assertEquals(0, p.exit_code)

-

-    # TODO(wan@google.com): libtool causes the built test binary to be

-    #   named lt-gtest_xml_outfiles_test_ instead of

-    #   gtest_xml_outfiles_test_.  To account for this possibillity, we

-    #   allow both names in the following code.  We should remove this

-    #   hack when Chandler Carruth's libtool replacement tool is ready.

-    output_file_name1 = test_name + ".xml"

-    output_file1 = os.path.join(self.output_dir_, output_file_name1)

-    output_file_name2 = 'lt-' + output_file_name1

-    output_file2 = os.path.join(self.output_dir_, output_file_name2)

-    self.assert_(os.path.isfile(output_file1) or os.path.isfile(output_file2),

-                 output_file1)

-

-    expected = minidom.parseString(expected_xml)

-    if os.path.isfile(output_file1):

-      actual = minidom.parse(output_file1)

-    else:

-      actual = minidom.parse(output_file2)

-    self.NormalizeXml(actual.documentElement)

-    self.AssertEquivalentNodes(expected.documentElement,

-                               actual.documentElement)

-    expected.unlink()

-    actual.unlink()

-

-

-if __name__ == "__main__":

-  os.environ["GTEST_STACK_TRACE_DEPTH"] = "0"

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Unit test for the gtest_xml_output module."""
+
+__author__ = "keith.ray@gmail.com (Keith Ray)"
+
+import os
+from xml.dom import minidom, Node
+
+import gtest_test_utils
+import gtest_xml_test_utils
+
+
+GTEST_OUTPUT_SUBDIR = "xml_outfiles"
+GTEST_OUTPUT_1_TEST = "gtest_xml_outfile1_test_"
+GTEST_OUTPUT_2_TEST = "gtest_xml_outfile2_test_"
+
+EXPECTED_XML_1 = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" name="AllTests">
+  <testsuite name="PropertyOne" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="TestSomeProperties" status="run" time="*" classname="PropertyOne" SetUpProp="1" TestSomeProperty="1" TearDownProp="1" />
+  </testsuite>
+</testsuites>
+"""
+
+EXPECTED_XML_2 = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" name="AllTests">
+  <testsuite name="PropertyTwo" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="TestSomeProperties" status="run" time="*" classname="PropertyTwo" SetUpProp="2" TestSomeProperty="2" TearDownProp="2" />
+  </testsuite>
+</testsuites>
+"""
+
+
+class GTestXMLOutFilesTest(gtest_xml_test_utils.GTestXMLTestCase):
+  """Unit test for Google Test's XML output functionality."""
+
+  def setUp(self):
+    # We want the trailing '/' that the last "" provides in os.path.join, for
+    # telling Google Test to create an output directory instead of a single file
+    # for xml output.
+    self.output_dir_ = os.path.join(gtest_test_utils.GetTempDir(),
+                                    GTEST_OUTPUT_SUBDIR, "")
+    self.DeleteFilesAndDir()
+
+  def tearDown(self):
+    self.DeleteFilesAndDir()
+
+  def DeleteFilesAndDir(self):
+    try:
+      os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_1_TEST + ".xml"))
+    except os.error:
+      pass
+    try:
+      os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_2_TEST + ".xml"))
+    except os.error:
+      pass
+    try:
+      os.rmdir(self.output_dir_)
+    except os.error:
+      pass
+
+  def testOutfile1(self):
+    self._TestOutFile(GTEST_OUTPUT_1_TEST, EXPECTED_XML_1)
+
+  def testOutfile2(self):
+    self._TestOutFile(GTEST_OUTPUT_2_TEST, EXPECTED_XML_2)
+
+  def _TestOutFile(self, test_name, expected_xml):
+    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(test_name)
+    command = [gtest_prog_path, "--gtest_output=xml:%s" % self.output_dir_]
+    p = gtest_test_utils.Subprocess(command,
+                                    working_dir=gtest_test_utils.GetTempDir())
+    self.assert_(p.exited)
+    self.assertEquals(0, p.exit_code)
+
+    # TODO(wan@google.com): libtool causes the built test binary to be
+    #   named lt-gtest_xml_outfiles_test_ instead of
+    #   gtest_xml_outfiles_test_.  To account for this possibillity, we
+    #   allow both names in the following code.  We should remove this
+    #   hack when Chandler Carruth's libtool replacement tool is ready.
+    output_file_name1 = test_name + ".xml"
+    output_file1 = os.path.join(self.output_dir_, output_file_name1)
+    output_file_name2 = 'lt-' + output_file_name1
+    output_file2 = os.path.join(self.output_dir_, output_file_name2)
+    self.assert_(os.path.isfile(output_file1) or os.path.isfile(output_file2),
+                 output_file1)
+
+    expected = minidom.parseString(expected_xml)
+    if os.path.isfile(output_file1):
+      actual = minidom.parse(output_file1)
+    else:
+      actual = minidom.parse(output_file2)
+    self.NormalizeXml(actual.documentElement)
+    self.AssertEquivalentNodes(expected.documentElement,
+                               actual.documentElement)
+    expected.unlink()
+    actual.unlink()
+
+
+if __name__ == "__main__":
+  os.environ["GTEST_STACK_TRACE_DEPTH"] = "0"
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_xml_output_unittest.py b/gtest-1.6.0/test/gtest_xml_output_unittest.py
index 32e3b3f..bdd5035 100755
--- a/gtest-1.6.0/test/gtest_xml_output_unittest.py
+++ b/gtest-1.6.0/test/gtest_xml_output_unittest.py
@@ -1,242 +1,242 @@
-#!/usr/bin/env python

-#

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

-

-"""Unit test for the gtest_xml_output module"""

-

-__author__ = 'eefacm@gmail.com (Sean Mcafee)'

-

-import errno

-import os

-import sys

-from xml.dom import minidom, Node

-

-import gtest_test_utils

-import gtest_xml_test_utils

-

-

-GTEST_OUTPUT_FLAG         = "--gtest_output"

-GTEST_DEFAULT_OUTPUT_FILE = "test_detail.xml"

-GTEST_PROGRAM_NAME = "gtest_xml_output_unittest_"

-

-SUPPORTS_STACK_TRACES = False

-

-if SUPPORTS_STACK_TRACES:

-  STACK_TRACE_TEMPLATE = "\nStack trace:\n*"

-else:

-  STACK_TRACE_TEMPLATE = ""

-

-EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>

-<testsuites tests="23" failures="4" disabled="2" errors="0" time="*" name="AllTests">

-  <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="Succeeds" status="run" time="*" classname="SuccessfulTest"/>

-  </testsuite>

-  <testsuite name="FailedTest" tests="1" failures="1" disabled="0" errors="0" time="*">

-    <testcase name="Fails" status="run" time="*" classname="FailedTest">

-      <failure message="Value of: 2&#x0A;Expected: 1" type=""><![CDATA[gtest_xml_output_unittest_.cc:*

-Value of: 2

-Expected: 1%(stack)s]]></failure>

-    </testcase>

-  </testsuite>

-  <testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" errors="0" time="*">

-    <testcase name="Succeeds" status="run" time="*" classname="MixedResultTest"/>

-    <testcase name="Fails" status="run" time="*" classname="MixedResultTest">

-      <failure message="Value of: 2&#x0A;Expected: 1" type=""><![CDATA[gtest_xml_output_unittest_.cc:*

-Value of: 2

-Expected: 1%(stack)s]]></failure>

-      <failure message="Value of: 3&#x0A;Expected: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*

-Value of: 3

-Expected: 2%(stack)s]]></failure>

-    </testcase>

-    <testcase name="DISABLED_test" status="notrun" time="*" classname="MixedResultTest"/>

-  </testsuite>

-  <testsuite name="XmlQuotingTest" tests="1" failures="1" disabled="0" errors="0" time="*">

-    <testcase name="OutputsCData" status="run" time="*" classname="XmlQuotingTest">

-      <failure message="Failed&#x0A;XML output: &lt;?xml encoding=&quot;utf-8&quot;&gt;&lt;top&gt;&lt;![CDATA[cdata text]]&gt;&lt;/top&gt;" type=""><![CDATA[gtest_xml_output_unittest_.cc:*

-Failed

-XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]>]]&gt;<![CDATA[</top>%(stack)s]]></failure>

-    </testcase>

-  </testsuite>

-  <testsuite name="InvalidCharactersTest" tests="1" failures="1" disabled="0" errors="0" time="*">

-    <testcase name="InvalidCharactersInMessage" status="run" time="*" classname="InvalidCharactersTest">

-      <failure message="Failed&#x0A;Invalid characters in brackets []" type=""><![CDATA[gtest_xml_output_unittest_.cc:*

-Failed

-Invalid characters in brackets []%(stack)s]]></failure>

-    </testcase>

-  </testsuite>

-  <testsuite name="DisabledTest" tests="1" failures="0" disabled="1" errors="0" time="*">

-    <testcase name="DISABLED_test_not_run" status="notrun" time="*" classname="DisabledTest"/>

-  </testsuite>

-  <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="OneProperty" status="run" time="*" classname="PropertyRecordingTest" key_1="1"/>

-    <testcase name="IntValuedProperty" status="run" time="*" classname="PropertyRecordingTest" key_int="1"/>

-    <testcase name="ThreeProperties" status="run" time="*" classname="PropertyRecordingTest" key_1="1" key_2="2" key_3="3"/>

-    <testcase name="TwoValuesForOneKeyUsesLastValue" status="run" time="*" classname="PropertyRecordingTest" key_1="2"/>

-  </testsuite>

-  <testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" errors="0" time="*">

-     <testcase name="RecordProperty" status="run" time="*" classname="NoFixtureTest" key="1"/>

-     <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_int="1"/>

-     <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_string="1"/>

-  </testsuite>

-  <testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="HasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />

-    <testcase name="HasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />

-    <testcase name="AnotherTestThatHasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />

-    <testcase name="AnotherTestThatHasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />

-  </testsuite>

-  <testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/0" />

-  </testsuite>

-  <testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/1" />

-  </testsuite>

-  <testsuite name="Single/TypeParameterizedTestCase/0" tests="1" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/0" />

-  </testsuite>

-  <testsuite name="Single/TypeParameterizedTestCase/1" tests="1" failures="0" disabled="0" errors="0" time="*">

-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/1" />

-  </testsuite>

-</testsuites>""" % {'stack': STACK_TRACE_TEMPLATE}

-

-

-EXPECTED_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>

-<testsuites tests="0" failures="0" disabled="0" errors="0" time="*" name="AllTests">

-</testsuites>"""

-

-

-class GTestXMLOutputUnitTest(gtest_xml_test_utils.GTestXMLTestCase):

-  """

-  Unit test for Google Test's XML output functionality.

-  """

-

-  def testNonEmptyXmlOutput(self):

-    """

-    Runs a test program that generates a non-empty XML output, and

-    tests that the XML output is expected.

-    """

-    self._TestXmlOutput(GTEST_PROGRAM_NAME, EXPECTED_NON_EMPTY_XML, 1)

-

-  def testEmptyXmlOutput(self):

-    """

-    Runs a test program that generates an empty XML output, and

-    tests that the XML output is expected.

-    """

-

-    self._TestXmlOutput("gtest_no_test_unittest",

-                        EXPECTED_EMPTY_XML, 0)

-

-  def testDefaultOutputFile(self):

-    """

-    Confirms that Google Test produces an XML output file with the expected

-    default name if no name is explicitly specified.

-    """

-    output_file = os.path.join(gtest_test_utils.GetTempDir(),

-                               GTEST_DEFAULT_OUTPUT_FILE)

-    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(

-        "gtest_no_test_unittest")

-    try:

-      os.remove(output_file)

-    except OSError, e:

-      if e.errno != errno.ENOENT:

-        raise

-

-    p = gtest_test_utils.Subprocess(

-        [gtest_prog_path, "%s=xml" % GTEST_OUTPUT_FLAG],

-        working_dir=gtest_test_utils.GetTempDir())

-    self.assert_(p.exited)

-    self.assertEquals(0, p.exit_code)

-    self.assert_(os.path.isfile(output_file))

-

-  def testSuppressedXmlOutput(self):

-    """

-    Tests that no XML file is generated if the default XML listener is

-    shut down before RUN_ALL_TESTS is invoked.

-    """

-

-    xml_path = os.path.join(gtest_test_utils.GetTempDir(),

-                            GTEST_PROGRAM_NAME + "out.xml")

-    if os.path.isfile(xml_path):

-      os.remove(xml_path)

-

-    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(GTEST_PROGRAM_NAME)

-

-    command = [gtest_prog_path,

-               "%s=xml:%s" % (GTEST_OUTPUT_FLAG, xml_path),

-               "--shut_down_xml"]

-    p = gtest_test_utils.Subprocess(command)

-    if p.terminated_by_signal:

-      self.assert_(False,

-                   "%s was killed by signal %d" % (gtest_prog_name, p.signal))

-    else:

-      self.assert_(p.exited)

-      self.assertEquals(1, p.exit_code,

-                        "'%s' exited with code %s, which doesn't match "

-                        "the expected exit code %s."

-                        % (command, p.exit_code, 1))

-

-    self.assert_(not os.path.isfile(xml_path))

-

-

-  def _TestXmlOutput(self, gtest_prog_name, expected_xml, expected_exit_code):

-    """

-    Asserts that the XML document generated by running the program

-    gtest_prog_name matches expected_xml, a string containing another

-    XML document.  Furthermore, the program's exit code must be

-    expected_exit_code.

-    """

-    xml_path = os.path.join(gtest_test_utils.GetTempDir(),

-                            gtest_prog_name + "out.xml")

-    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(gtest_prog_name)

-

-    command = [gtest_prog_path, "%s=xml:%s" % (GTEST_OUTPUT_FLAG, xml_path)]

-    p = gtest_test_utils.Subprocess(command)

-    if p.terminated_by_signal:

-      self.assert_(False,

-                   "%s was killed by signal %d" % (gtest_prog_name, p.signal))

-    else:

-      self.assert_(p.exited)

-      self.assertEquals(expected_exit_code, p.exit_code,

-                        "'%s' exited with code %s, which doesn't match "

-                        "the expected exit code %s."

-                        % (command, p.exit_code, expected_exit_code))

-

-    expected = minidom.parseString(expected_xml)

-    actual   = minidom.parse(xml_path)

-    self.NormalizeXml(actual.documentElement)

-    self.AssertEquivalentNodes(expected.documentElement,

-                               actual.documentElement)

-    expected.unlink()

-    actual  .unlink()

-

-

-

-if __name__ == '__main__':

-  os.environ['GTEST_STACK_TRACE_DEPTH'] = '1'

-  gtest_test_utils.Main()

+#!/usr/bin/env python
+#
+# 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.
+
+"""Unit test for the gtest_xml_output module"""
+
+__author__ = 'eefacm@gmail.com (Sean Mcafee)'
+
+import errno
+import os
+import sys
+from xml.dom import minidom, Node
+
+import gtest_test_utils
+import gtest_xml_test_utils
+
+
+GTEST_OUTPUT_FLAG         = "--gtest_output"
+GTEST_DEFAULT_OUTPUT_FILE = "test_detail.xml"
+GTEST_PROGRAM_NAME = "gtest_xml_output_unittest_"
+
+SUPPORTS_STACK_TRACES = False
+
+if SUPPORTS_STACK_TRACES:
+  STACK_TRACE_TEMPLATE = "\nStack trace:\n*"
+else:
+  STACK_TRACE_TEMPLATE = ""
+
+EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="23" failures="4" disabled="2" errors="0" time="*" name="AllTests">
+  <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="Succeeds" status="run" time="*" classname="SuccessfulTest"/>
+  </testsuite>
+  <testsuite name="FailedTest" tests="1" failures="1" disabled="0" errors="0" time="*">
+    <testcase name="Fails" status="run" time="*" classname="FailedTest">
+      <failure message="Value of: 2&#x0A;Expected: 1" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Value of: 2
+Expected: 1%(stack)s]]></failure>
+    </testcase>
+  </testsuite>
+  <testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" errors="0" time="*">
+    <testcase name="Succeeds" status="run" time="*" classname="MixedResultTest"/>
+    <testcase name="Fails" status="run" time="*" classname="MixedResultTest">
+      <failure message="Value of: 2&#x0A;Expected: 1" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Value of: 2
+Expected: 1%(stack)s]]></failure>
+      <failure message="Value of: 3&#x0A;Expected: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Value of: 3
+Expected: 2%(stack)s]]></failure>
+    </testcase>
+    <testcase name="DISABLED_test" status="notrun" time="*" classname="MixedResultTest"/>
+  </testsuite>
+  <testsuite name="XmlQuotingTest" tests="1" failures="1" disabled="0" errors="0" time="*">
+    <testcase name="OutputsCData" status="run" time="*" classname="XmlQuotingTest">
+      <failure message="Failed&#x0A;XML output: &lt;?xml encoding=&quot;utf-8&quot;&gt;&lt;top&gt;&lt;![CDATA[cdata text]]&gt;&lt;/top&gt;" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Failed
+XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]>]]&gt;<![CDATA[</top>%(stack)s]]></failure>
+    </testcase>
+  </testsuite>
+  <testsuite name="InvalidCharactersTest" tests="1" failures="1" disabled="0" errors="0" time="*">
+    <testcase name="InvalidCharactersInMessage" status="run" time="*" classname="InvalidCharactersTest">
+      <failure message="Failed&#x0A;Invalid characters in brackets []" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Failed
+Invalid characters in brackets []%(stack)s]]></failure>
+    </testcase>
+  </testsuite>
+  <testsuite name="DisabledTest" tests="1" failures="0" disabled="1" errors="0" time="*">
+    <testcase name="DISABLED_test_not_run" status="notrun" time="*" classname="DisabledTest"/>
+  </testsuite>
+  <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="OneProperty" status="run" time="*" classname="PropertyRecordingTest" key_1="1"/>
+    <testcase name="IntValuedProperty" status="run" time="*" classname="PropertyRecordingTest" key_int="1"/>
+    <testcase name="ThreeProperties" status="run" time="*" classname="PropertyRecordingTest" key_1="1" key_2="2" key_3="3"/>
+    <testcase name="TwoValuesForOneKeyUsesLastValue" status="run" time="*" classname="PropertyRecordingTest" key_1="2"/>
+  </testsuite>
+  <testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" errors="0" time="*">
+     <testcase name="RecordProperty" status="run" time="*" classname="NoFixtureTest" key="1"/>
+     <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_int="1"/>
+     <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_string="1"/>
+  </testsuite>
+  <testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />
+    <testcase name="HasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />
+    <testcase name="AnotherTestThatHasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />
+    <testcase name="AnotherTestThatHasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />
+  </testsuite>
+  <testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/0" />
+  </testsuite>
+  <testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/1" />
+  </testsuite>
+  <testsuite name="Single/TypeParameterizedTestCase/0" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/0" />
+  </testsuite>
+  <testsuite name="Single/TypeParameterizedTestCase/1" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/1" />
+  </testsuite>
+</testsuites>""" % {'stack': STACK_TRACE_TEMPLATE}
+
+
+EXPECTED_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="0" failures="0" disabled="0" errors="0" time="*" name="AllTests">
+</testsuites>"""
+
+
+class GTestXMLOutputUnitTest(gtest_xml_test_utils.GTestXMLTestCase):
+  """
+  Unit test for Google Test's XML output functionality.
+  """
+
+  def testNonEmptyXmlOutput(self):
+    """
+    Runs a test program that generates a non-empty XML output, and
+    tests that the XML output is expected.
+    """
+    self._TestXmlOutput(GTEST_PROGRAM_NAME, EXPECTED_NON_EMPTY_XML, 1)
+
+  def testEmptyXmlOutput(self):
+    """
+    Runs a test program that generates an empty XML output, and
+    tests that the XML output is expected.
+    """
+
+    self._TestXmlOutput("gtest_no_test_unittest",
+                        EXPECTED_EMPTY_XML, 0)
+
+  def testDefaultOutputFile(self):
+    """
+    Confirms that Google Test produces an XML output file with the expected
+    default name if no name is explicitly specified.
+    """
+    output_file = os.path.join(gtest_test_utils.GetTempDir(),
+                               GTEST_DEFAULT_OUTPUT_FILE)
+    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(
+        "gtest_no_test_unittest")
+    try:
+      os.remove(output_file)
+    except OSError, e:
+      if e.errno != errno.ENOENT:
+        raise
+
+    p = gtest_test_utils.Subprocess(
+        [gtest_prog_path, "%s=xml" % GTEST_OUTPUT_FLAG],
+        working_dir=gtest_test_utils.GetTempDir())
+    self.assert_(p.exited)
+    self.assertEquals(0, p.exit_code)
+    self.assert_(os.path.isfile(output_file))
+
+  def testSuppressedXmlOutput(self):
+    """
+    Tests that no XML file is generated if the default XML listener is
+    shut down before RUN_ALL_TESTS is invoked.
+    """
+
+    xml_path = os.path.join(gtest_test_utils.GetTempDir(),
+                            GTEST_PROGRAM_NAME + "out.xml")
+    if os.path.isfile(xml_path):
+      os.remove(xml_path)
+
+    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(GTEST_PROGRAM_NAME)
+
+    command = [gtest_prog_path,
+               "%s=xml:%s" % (GTEST_OUTPUT_FLAG, xml_path),
+               "--shut_down_xml"]
+    p = gtest_test_utils.Subprocess(command)
+    if p.terminated_by_signal:
+      self.assert_(False,
+                   "%s was killed by signal %d" % (gtest_prog_name, p.signal))
+    else:
+      self.assert_(p.exited)
+      self.assertEquals(1, p.exit_code,
+                        "'%s' exited with code %s, which doesn't match "
+                        "the expected exit code %s."
+                        % (command, p.exit_code, 1))
+
+    self.assert_(not os.path.isfile(xml_path))
+
+
+  def _TestXmlOutput(self, gtest_prog_name, expected_xml, expected_exit_code):
+    """
+    Asserts that the XML document generated by running the program
+    gtest_prog_name matches expected_xml, a string containing another
+    XML document.  Furthermore, the program's exit code must be
+    expected_exit_code.
+    """
+    xml_path = os.path.join(gtest_test_utils.GetTempDir(),
+                            gtest_prog_name + "out.xml")
+    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(gtest_prog_name)
+
+    command = [gtest_prog_path, "%s=xml:%s" % (GTEST_OUTPUT_FLAG, xml_path)]
+    p = gtest_test_utils.Subprocess(command)
+    if p.terminated_by_signal:
+      self.assert_(False,
+                   "%s was killed by signal %d" % (gtest_prog_name, p.signal))
+    else:
+      self.assert_(p.exited)
+      self.assertEquals(expected_exit_code, p.exit_code,
+                        "'%s' exited with code %s, which doesn't match "
+                        "the expected exit code %s."
+                        % (command, p.exit_code, expected_exit_code))
+
+    expected = minidom.parseString(expected_xml)
+    actual   = minidom.parse(xml_path)
+    self.NormalizeXml(actual.documentElement)
+    self.AssertEquivalentNodes(expected.documentElement,
+                               actual.documentElement)
+    expected.unlink()
+    actual  .unlink()
+
+
+
+if __name__ == '__main__':
+  os.environ['GTEST_STACK_TRACE_DEPTH'] = '1'
+  gtest_test_utils.Main()
diff --git a/gtest-1.6.0/test/gtest_xml_output_unittest_.cc b/gtest-1.6.0/test/gtest_xml_output_unittest_.cc
index 43a873d..741a887 100644
--- a/gtest-1.6.0/test/gtest_xml_output_unittest_.cc
+++ b/gtest-1.6.0/test/gtest_xml_output_unittest_.cc
@@ -1,174 +1,174 @@
-// 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: eefacm@gmail.com (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::TestWithParam;

-using ::testing::UnitTest;

-using ::testing::Test;

-using ::testing::Types;

-using ::testing::Values;

-

-class SuccessfulTest : public Test {

-};

-

-TEST_F(SuccessfulTest, Succeeds) {

-  SUCCEED() << "This is a success.";

-  ASSERT_EQ(1, 1);

-}

-

-class FailedTest : public Test {

-};

-

-TEST_F(FailedTest, Fails) {

-  ASSERT_EQ(1, 2);

-}

-

-class DisabledTest : public 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 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");

-}

-

-// Verifies that the test parameter value is output in the 'value_param'

-// XML attribute for value-parameterized tests.

-class ValueParamTest : public TestWithParam<int> {};

-TEST_P(ValueParamTest, HasValueParamAttribute) {}

-TEST_P(ValueParamTest, AnotherTestThatHasValueParamAttribute) {}

-INSTANTIATE_TEST_CASE_P(Single, ValueParamTest, Values(33, 42));

-

-// Verifies that the type parameter name is output in the 'type_param'

-// XML attribute for typed tests.

-template <typename T> class TypedTest : public Test {};

-typedef Types<int, long> TypedTestTypes;

-TYPED_TEST_CASE(TypedTest, TypedTestTypes);

-TYPED_TEST(TypedTest, HasTypeParamAttribute) {}

-

-// Verifies that the type parameter name is output in the 'type_param'

-// XML attribute for type-parameterized tests.

-template <typename T> class TypeParameterizedTestCase : public Test {};

-TYPED_TEST_CASE_P(TypeParameterizedTestCase);

-TYPED_TEST_P(TypeParameterizedTestCase, HasTypeParamAttribute) {}

-REGISTER_TYPED_TEST_CASE_P(TypeParameterizedTestCase, HasTypeParamAttribute);

-typedef Types<int, long> TypeParameterizedTestCaseTypes;

-INSTANTIATE_TYPED_TEST_CASE_P(Single,

-                              TypeParameterizedTestCase,

-                              TypeParameterizedTestCaseTypes);

-

-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: eefacm@gmail.com (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::TestWithParam;
+using ::testing::UnitTest;
+using ::testing::Test;
+using ::testing::Types;
+using ::testing::Values;
+
+class SuccessfulTest : public Test {
+};
+
+TEST_F(SuccessfulTest, Succeeds) {
+  SUCCEED() << "This is a success.";
+  ASSERT_EQ(1, 1);
+}
+
+class FailedTest : public Test {
+};
+
+TEST_F(FailedTest, Fails) {
+  ASSERT_EQ(1, 2);
+}
+
+class DisabledTest : public 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 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");
+}
+
+// Verifies that the test parameter value is output in the 'value_param'
+// XML attribute for value-parameterized tests.
+class ValueParamTest : public TestWithParam<int> {};
+TEST_P(ValueParamTest, HasValueParamAttribute) {}
+TEST_P(ValueParamTest, AnotherTestThatHasValueParamAttribute) {}
+INSTANTIATE_TEST_CASE_P(Single, ValueParamTest, Values(33, 42));
+
+// Verifies that the type parameter name is output in the 'type_param'
+// XML attribute for typed tests.
+template <typename T> class TypedTest : public Test {};
+typedef Types<int, long> TypedTestTypes;
+TYPED_TEST_CASE(TypedTest, TypedTestTypes);
+TYPED_TEST(TypedTest, HasTypeParamAttribute) {}
+
+// Verifies that the type parameter name is output in the 'type_param'
+// XML attribute for type-parameterized tests.
+template <typename T> class TypeParameterizedTestCase : public Test {};
+TYPED_TEST_CASE_P(TypeParameterizedTestCase);
+TYPED_TEST_P(TypeParameterizedTestCase, HasTypeParamAttribute) {}
+REGISTER_TYPED_TEST_CASE_P(TypeParameterizedTestCase, HasTypeParamAttribute);
+typedef Types<int, long> TypeParameterizedTestCaseTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(Single,
+                              TypeParameterizedTestCase,
+                              TypeParameterizedTestCaseTypes);
+
+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/gtest-1.6.0/test/gtest_xml_test_utils.py b/gtest-1.6.0/test/gtest_xml_test_utils.py
index 37162af..0f55c16 100755
--- a/gtest-1.6.0/test/gtest_xml_test_utils.py
+++ b/gtest-1.6.0/test/gtest_xml_test_utils.py
@@ -1,179 +1,179 @@
-#!/usr/bin/env python

-#

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

-

-"""Unit test utilities for gtest_xml_output"""

-

-__author__ = 'eefacm@gmail.com (Sean Mcafee)'

-

-import re

-from xml.dom import minidom, Node

-

-import gtest_test_utils

-

-

-GTEST_OUTPUT_FLAG         = "--gtest_output"

-GTEST_DEFAULT_OUTPUT_FILE = "test_detail.xml"

-

-class GTestXMLTestCase(gtest_test_utils.TestCase):

-  """

-  Base class for tests of Google Test's XML output functionality.

-  """

-

-

-  def AssertEquivalentNodes(self, expected_node, actual_node):

-    """

-    Asserts that actual_node (a DOM node object) is equivalent to

-    expected_node (another DOM node object), in that either both of

-    them are CDATA nodes and have the same value, or both are DOM

-    elements and actual_node meets all of the following conditions:

-

-    *  It has the same tag name as expected_node.

-    *  It has the same set of attributes as expected_node, each with

-       the same value as the corresponding attribute of expected_node.

-       Exceptions are any attribute named "time", which needs only be

-       convertible to a floating-point number and any attribute named

-       "type_param" which only has to be non-empty.

-    *  It has an equivalent set of child nodes (including elements and

-       CDATA sections) as expected_node.  Note that we ignore the

-       order of the children as they are not guaranteed to be in any

-       particular order.

-    """

-

-    if expected_node.nodeType == Node.CDATA_SECTION_NODE:

-      self.assertEquals(Node.CDATA_SECTION_NODE, actual_node.nodeType)

-      self.assertEquals(expected_node.nodeValue, actual_node.nodeValue)

-      return

-

-    self.assertEquals(Node.ELEMENT_NODE, actual_node.nodeType)

-    self.assertEquals(Node.ELEMENT_NODE, expected_node.nodeType)

-    self.assertEquals(expected_node.tagName, actual_node.tagName)

-

-    expected_attributes = expected_node.attributes

-    actual_attributes   = actual_node  .attributes

-    self.assertEquals(

-        expected_attributes.length, actual_attributes.length,

-        "attribute numbers differ in element " + actual_node.tagName)

-    for i in range(expected_attributes.length):

-      expected_attr = expected_attributes.item(i)

-      actual_attr   = actual_attributes.get(expected_attr.name)

-      self.assert_(

-          actual_attr is not None,

-          "expected attribute %s not found in element %s" %

-          (expected_attr.name, actual_node.tagName))

-      self.assertEquals(expected_attr.value, actual_attr.value,

-                        " values of attribute %s in element %s differ" %

-                        (expected_attr.name, actual_node.tagName))

-

-    expected_children = self._GetChildren(expected_node)

-    actual_children = self._GetChildren(actual_node)

-    self.assertEquals(

-        len(expected_children), len(actual_children),

-        "number of child elements differ in element " + actual_node.tagName)

-    for child_id, child in expected_children.iteritems():

-      self.assert_(child_id in actual_children,

-                   '<%s> is not in <%s> (in element %s)' %

-                   (child_id, actual_children, actual_node.tagName))

-      self.AssertEquivalentNodes(child, actual_children[child_id])

-

-  identifying_attribute = {

-    "testsuites": "name",

-    "testsuite": "name",

-    "testcase":  "name",

-    "failure":   "message",

-    }

-

-  def _GetChildren(self, element):

-    """

-    Fetches all of the child nodes of element, a DOM Element object.

-    Returns them as the values of a dictionary keyed by the IDs of the

-    children.  For <testsuites>, <testsuite> and <testcase> elements, the ID

-    is the value of their "name" attribute; for <failure> elements, it is

-    the value of the "message" attribute; CDATA sections and non-whitespace

-    text nodes are concatenated into a single CDATA section with ID

-    "detail".  An exception is raised if any element other than the above

-    four is encountered, if two child elements with the same identifying

-    attributes are encountered, or if any other type of node is encountered.

-    """

-

-    children = {}

-    for child in element.childNodes:

-      if child.nodeType == Node.ELEMENT_NODE:

-        self.assert_(child.tagName in self.identifying_attribute,

-                     "Encountered unknown element <%s>" % child.tagName)

-        childID = child.getAttribute(self.identifying_attribute[child.tagName])

-        self.assert_(childID not in children)

-        children[childID] = child

-      elif child.nodeType in [Node.TEXT_NODE, Node.CDATA_SECTION_NODE]:

-        if "detail" not in children:

-          if (child.nodeType == Node.CDATA_SECTION_NODE or

-              not child.nodeValue.isspace()):

-            children["detail"] = child.ownerDocument.createCDATASection(

-                child.nodeValue)

-        else:

-          children["detail"].nodeValue += child.nodeValue

-      else:

-        self.fail("Encountered unexpected node type %d" % child.nodeType)

-    return children

-

-  def NormalizeXml(self, element):

-    """

-    Normalizes Google Test's XML output to eliminate references to transient

-    information that may change from run to run.

-

-    *  The "time" attribute of <testsuites>, <testsuite> and <testcase>

-       elements is replaced with a single asterisk, if it contains

-       only digit characters.

-    *  The "type_param" attribute of <testcase> elements is replaced with a

-       single asterisk (if it sn non-empty) as it is the type name returned

-       by the compiler and is platform dependent.

-    *  The line number reported in the first line of the "message"

-       attribute of <failure> elements is replaced with a single asterisk.

-    *  The directory names in file paths are removed.

-    *  The stack traces are removed.

-    """

-

-    if element.tagName in ("testsuites", "testsuite", "testcase"):

-      time = element.getAttributeNode("time")

-      time.value = re.sub(r"^\d+(\.\d+)?$", "*", time.value)

-      type_param = element.getAttributeNode("type_param")

-      if type_param and type_param.value:

-        type_param.value = "*"

-    elif element.tagName == "failure":

-      for child in element.childNodes:

-        if child.nodeType == Node.CDATA_SECTION_NODE:

-          # Removes the source line number.

-          cdata = re.sub(r"^.*[/\\](.*:)\d+\n", "\\1*\n", child.nodeValue)

-          # Removes the actual stack trace.

-          child.nodeValue = re.sub(r"\nStack trace:\n(.|\n)*",

-                                   "", cdata)

-    for child in element.childNodes:

-      if child.nodeType == Node.ELEMENT_NODE:

-        self.NormalizeXml(child)

+#!/usr/bin/env python
+#
+# 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.
+
+"""Unit test utilities for gtest_xml_output"""
+
+__author__ = 'eefacm@gmail.com (Sean Mcafee)'
+
+import re
+from xml.dom import minidom, Node
+
+import gtest_test_utils
+
+
+GTEST_OUTPUT_FLAG         = "--gtest_output"
+GTEST_DEFAULT_OUTPUT_FILE = "test_detail.xml"
+
+class GTestXMLTestCase(gtest_test_utils.TestCase):
+  """
+  Base class for tests of Google Test's XML output functionality.
+  """
+
+
+  def AssertEquivalentNodes(self, expected_node, actual_node):
+    """
+    Asserts that actual_node (a DOM node object) is equivalent to
+    expected_node (another DOM node object), in that either both of
+    them are CDATA nodes and have the same value, or both are DOM
+    elements and actual_node meets all of the following conditions:
+
+    *  It has the same tag name as expected_node.
+    *  It has the same set of attributes as expected_node, each with
+       the same value as the corresponding attribute of expected_node.
+       Exceptions are any attribute named "time", which needs only be
+       convertible to a floating-point number and any attribute named
+       "type_param" which only has to be non-empty.
+    *  It has an equivalent set of child nodes (including elements and
+       CDATA sections) as expected_node.  Note that we ignore the
+       order of the children as they are not guaranteed to be in any
+       particular order.
+    """
+
+    if expected_node.nodeType == Node.CDATA_SECTION_NODE:
+      self.assertEquals(Node.CDATA_SECTION_NODE, actual_node.nodeType)
+      self.assertEquals(expected_node.nodeValue, actual_node.nodeValue)
+      return
+
+    self.assertEquals(Node.ELEMENT_NODE, actual_node.nodeType)
+    self.assertEquals(Node.ELEMENT_NODE, expected_node.nodeType)
+    self.assertEquals(expected_node.tagName, actual_node.tagName)
+
+    expected_attributes = expected_node.attributes
+    actual_attributes   = actual_node  .attributes
+    self.assertEquals(
+        expected_attributes.length, actual_attributes.length,
+        "attribute numbers differ in element " + actual_node.tagName)
+    for i in range(expected_attributes.length):
+      expected_attr = expected_attributes.item(i)
+      actual_attr   = actual_attributes.get(expected_attr.name)
+      self.assert_(
+          actual_attr is not None,
+          "expected attribute %s not found in element %s" %
+          (expected_attr.name, actual_node.tagName))
+      self.assertEquals(expected_attr.value, actual_attr.value,
+                        " values of attribute %s in element %s differ" %
+                        (expected_attr.name, actual_node.tagName))
+
+    expected_children = self._GetChildren(expected_node)
+    actual_children = self._GetChildren(actual_node)
+    self.assertEquals(
+        len(expected_children), len(actual_children),
+        "number of child elements differ in element " + actual_node.tagName)
+    for child_id, child in expected_children.iteritems():
+      self.assert_(child_id in actual_children,
+                   '<%s> is not in <%s> (in element %s)' %
+                   (child_id, actual_children, actual_node.tagName))
+      self.AssertEquivalentNodes(child, actual_children[child_id])
+
+  identifying_attribute = {
+    "testsuites": "name",
+    "testsuite": "name",
+    "testcase":  "name",
+    "failure":   "message",
+    }
+
+  def _GetChildren(self, element):
+    """
+    Fetches all of the child nodes of element, a DOM Element object.
+    Returns them as the values of a dictionary keyed by the IDs of the
+    children.  For <testsuites>, <testsuite> and <testcase> elements, the ID
+    is the value of their "name" attribute; for <failure> elements, it is
+    the value of the "message" attribute; CDATA sections and non-whitespace
+    text nodes are concatenated into a single CDATA section with ID
+    "detail".  An exception is raised if any element other than the above
+    four is encountered, if two child elements with the same identifying
+    attributes are encountered, or if any other type of node is encountered.
+    """
+
+    children = {}
+    for child in element.childNodes:
+      if child.nodeType == Node.ELEMENT_NODE:
+        self.assert_(child.tagName in self.identifying_attribute,
+                     "Encountered unknown element <%s>" % child.tagName)
+        childID = child.getAttribute(self.identifying_attribute[child.tagName])
+        self.assert_(childID not in children)
+        children[childID] = child
+      elif child.nodeType in [Node.TEXT_NODE, Node.CDATA_SECTION_NODE]:
+        if "detail" not in children:
+          if (child.nodeType == Node.CDATA_SECTION_NODE or
+              not child.nodeValue.isspace()):
+            children["detail"] = child.ownerDocument.createCDATASection(
+                child.nodeValue)
+        else:
+          children["detail"].nodeValue += child.nodeValue
+      else:
+        self.fail("Encountered unexpected node type %d" % child.nodeType)
+    return children
+
+  def NormalizeXml(self, element):
+    """
+    Normalizes Google Test's XML output to eliminate references to transient
+    information that may change from run to run.
+
+    *  The "time" attribute of <testsuites>, <testsuite> and <testcase>
+       elements is replaced with a single asterisk, if it contains
+       only digit characters.
+    *  The "type_param" attribute of <testcase> elements is replaced with a
+       single asterisk (if it sn non-empty) as it is the type name returned
+       by the compiler and is platform dependent.
+    *  The line number reported in the first line of the "message"
+       attribute of <failure> elements is replaced with a single asterisk.
+    *  The directory names in file paths are removed.
+    *  The stack traces are removed.
+    """
+
+    if element.tagName in ("testsuites", "testsuite", "testcase"):
+      time = element.getAttributeNode("time")
+      time.value = re.sub(r"^\d+(\.\d+)?$", "*", time.value)
+      type_param = element.getAttributeNode("type_param")
+      if type_param and type_param.value:
+        type_param.value = "*"
+    elif element.tagName == "failure":
+      for child in element.childNodes:
+        if child.nodeType == Node.CDATA_SECTION_NODE:
+          # Removes the source line number.
+          cdata = re.sub(r"^.*[/\\](.*:)\d+\n", "\\1*\n", child.nodeValue)
+          # Removes the actual stack trace.
+          child.nodeValue = re.sub(r"\nStack trace:\n(.|\n)*",
+                                   "", cdata)
+    for child in element.childNodes:
+      if child.nodeType == Node.ELEMENT_NODE:
+        self.NormalizeXml(child)
diff --git a/gtest-1.6.0/test/production.cc b/gtest-1.6.0/test/production.cc
index dd80aa9..8b8a40b 100644
--- a/gtest-1.6.0/test/production.cc
+++ b/gtest-1.6.0/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: wan@google.com (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: wan@google.com (Zhanyong Wan)
+//
+// This is part of the unit test for include/gtest/gtest_prod.h.
+
+#include "production.h"
+
+PrivateCode::PrivateCode() : x_(0) {}
diff --git a/gtest-1.6.0/test/production.h b/gtest-1.6.0/test/production.h
index 62a266a..98fd5e4 100644
--- a/gtest-1.6.0/test/production.h
+++ b/gtest-1.6.0/test/production.h
@@ -1,55 +1,55 @@
-// 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: wan@google.com (Zhanyong Wan)

-//

-// This is part of the unit test for include/gtest/gtest_prod.h.

-

-#ifndef GTEST_TEST_PRODUCTION_H_

-#define GTEST_TEST_PRODUCTION_H_

-

-#include "gtest/gtest_prod.h"

-

-class PrivateCode {

- public:

-  // Declares a friend test that does not use a fixture.

-  FRIEND_TEST(PrivateCodeTest, CanAccessPrivateMembers);

-

-  // Declares a friend test that uses a fixture.

-  FRIEND_TEST(PrivateCodeFixtureTest, CanAccessPrivateMembers);

-

-  PrivateCode();

-

-  int x() const { return x_; }

- private:

-  void set_x(int an_x) { x_ = an_x; }

-  int x_;

-};

-

-#endif  // GTEST_TEST_PRODUCTION_H_

+// 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: wan@google.com (Zhanyong Wan)
+//
+// This is part of the unit test for include/gtest/gtest_prod.h.
+
+#ifndef GTEST_TEST_PRODUCTION_H_
+#define GTEST_TEST_PRODUCTION_H_
+
+#include "gtest/gtest_prod.h"
+
+class PrivateCode {
+ public:
+  // Declares a friend test that does not use a fixture.
+  FRIEND_TEST(PrivateCodeTest, CanAccessPrivateMembers);
+
+  // Declares a friend test that uses a fixture.
+  FRIEND_TEST(PrivateCodeFixtureTest, CanAccessPrivateMembers);
+
+  PrivateCode();
+
+  int x() const { return x_; }
+ private:
+  void set_x(int an_x) { x_ = an_x; }
+  int x_;
+};
+
+#endif  // GTEST_TEST_PRODUCTION_H_
diff --git a/gtest-1.6.0/xcode/Config/DebugProject.xcconfig b/gtest-1.6.0/xcode/Config/DebugProject.xcconfig
index eb0bf50..3d68157 100644
--- a/gtest-1.6.0/xcode/Config/DebugProject.xcconfig
+++ b/gtest-1.6.0/xcode/Config/DebugProject.xcconfig
@@ -1,30 +1,30 @@
-//

-//  DebugProject.xcconfig

-//

-//  These are Debug Configuration project settings for the gtest framework and

-//  examples. It is set in the "Based On:" dropdown in the "Project" info

-//  dialog.

-//  This file is based on the Xcode Configuration files in:

-//  http://code.google.com/p/google-toolbox-for-mac/

-// 

-

-#include "General.xcconfig"

-

-// No optimization

-GCC_OPTIMIZATION_LEVEL = 0

-

-// Deployment postprocessing is what triggers Xcode to strip, turn it off

-DEPLOYMENT_POSTPROCESSING = NO

-

-// Dead code stripping off

-DEAD_CODE_STRIPPING = NO

-

-// Debug symbols should be on obviously

-GCC_GENERATE_DEBUGGING_SYMBOLS = YES

-

-// Define the DEBUG macro in all debug builds

-OTHER_CFLAGS = $(OTHER_CFLAGS) -DDEBUG=1

-

-// These are turned off to avoid STL incompatibilities with client code

-// // Turns on special C++ STL checks to "encourage" good STL use

-// GCC_PREPROCESSOR_DEFINITIONS = $(GCC_PREPROCESSOR_DEFINITIONS) _GLIBCXX_DEBUG_PEDANTIC _GLIBCXX_DEBUG _GLIBCPP_CONCEPT_CHECKS

+//
+//  DebugProject.xcconfig
+//
+//  These are Debug Configuration project settings for the gtest framework and
+//  examples. It is set in the "Based On:" dropdown in the "Project" info
+//  dialog.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+#include "General.xcconfig"
+
+// No optimization
+GCC_OPTIMIZATION_LEVEL = 0
+
+// Deployment postprocessing is what triggers Xcode to strip, turn it off
+DEPLOYMENT_POSTPROCESSING = NO
+
+// Dead code stripping off
+DEAD_CODE_STRIPPING = NO
+
+// Debug symbols should be on obviously
+GCC_GENERATE_DEBUGGING_SYMBOLS = YES
+
+// Define the DEBUG macro in all debug builds
+OTHER_CFLAGS = $(OTHER_CFLAGS) -DDEBUG=1
+
+// These are turned off to avoid STL incompatibilities with client code
+// // Turns on special C++ STL checks to "encourage" good STL use
+// GCC_PREPROCESSOR_DEFINITIONS = $(GCC_PREPROCESSOR_DEFINITIONS) _GLIBCXX_DEBUG_PEDANTIC _GLIBCXX_DEBUG _GLIBCPP_CONCEPT_CHECKS
diff --git a/gtest-1.6.0/xcode/Config/FrameworkTarget.xcconfig b/gtest-1.6.0/xcode/Config/FrameworkTarget.xcconfig
index 42811b4..357b1c8 100644
--- a/gtest-1.6.0/xcode/Config/FrameworkTarget.xcconfig
+++ b/gtest-1.6.0/xcode/Config/FrameworkTarget.xcconfig
@@ -1,17 +1,17 @@
-//

-//  FrameworkTarget.xcconfig

-//

-//  These are Framework target settings for the gtest framework and examples. It

-//  is set in the "Based On:" dropdown in the "Target" info dialog.

-//  This file is based on the Xcode Configuration files in:

-//  http://code.google.com/p/google-toolbox-for-mac/

-// 

-

-// Dynamic libs need to be position independent

-GCC_DYNAMIC_NO_PIC = NO

-

-// Dynamic libs should not have their external symbols stripped.

-STRIP_STYLE = non-global

-

-// Let the user install by specifying the $DSTROOT with xcodebuild

-SKIP_INSTALL = NO

+//
+//  FrameworkTarget.xcconfig
+//
+//  These are Framework target settings for the gtest framework and examples. It
+//  is set in the "Based On:" dropdown in the "Target" info dialog.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+// Dynamic libs need to be position independent
+GCC_DYNAMIC_NO_PIC = NO
+
+// Dynamic libs should not have their external symbols stripped.
+STRIP_STYLE = non-global
+
+// Let the user install by specifying the $DSTROOT with xcodebuild
+SKIP_INSTALL = NO
diff --git a/gtest-1.6.0/xcode/Config/General.xcconfig b/gtest-1.6.0/xcode/Config/General.xcconfig
index 1212ae7..f23e322 100644
--- a/gtest-1.6.0/xcode/Config/General.xcconfig
+++ b/gtest-1.6.0/xcode/Config/General.xcconfig
@@ -1,41 +1,41 @@
-//

-//  General.xcconfig

-//

-//  These are General configuration settings for the gtest framework and

-//  examples.

-//  This file is based on the Xcode Configuration files in:

-//  http://code.google.com/p/google-toolbox-for-mac/

-// 

-

-// Build for PPC and Intel, 32- and 64-bit

-ARCHS = i386 x86_64 ppc ppc64

-

-// Zerolink prevents link warnings so turn it off

-ZERO_LINK = NO

-

-// Prebinding considered unhelpful in 10.3 and later

-PREBINDING = NO

-

-// Strictest warning policy

-WARNING_CFLAGS = -Wall -Werror -Wendif-labels -Wnewline-eof -Wno-sign-compare -Wshadow

-

-// Work around Xcode bugs by using external strip. See:

-// http://lists.apple.com/archives/Xcode-users/2006/Feb/msg00050.html

-SEPARATE_STRIP = YES

-

-// Force C99 dialect

-GCC_C_LANGUAGE_STANDARD = c99

-

-// not sure why apple defaults this on, but it's pretty risky

-ALWAYS_SEARCH_USER_PATHS = NO

-

-// Turn on position dependent code for most cases (overridden where appropriate)

-GCC_DYNAMIC_NO_PIC = YES

-

-// Default SDK and minimum OS version is 10.4

-SDKROOT = $(DEVELOPER_SDK_DIR)/MacOSX10.4u.sdk

-MACOSX_DEPLOYMENT_TARGET = 10.4

-GCC_VERSION = 4.0

-

-// VERSIONING BUILD SETTINGS (used in Info.plist)

-GTEST_VERSIONINFO_ABOUT =  © 2008 Google Inc.

+//
+//  General.xcconfig
+//
+//  These are General configuration settings for the gtest framework and
+//  examples.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+// Build for PPC and Intel, 32- and 64-bit
+ARCHS = i386 x86_64 ppc ppc64
+
+// Zerolink prevents link warnings so turn it off
+ZERO_LINK = NO
+
+// Prebinding considered unhelpful in 10.3 and later
+PREBINDING = NO
+
+// Strictest warning policy
+WARNING_CFLAGS = -Wall -Werror -Wendif-labels -Wnewline-eof -Wno-sign-compare -Wshadow
+
+// Work around Xcode bugs by using external strip. See:
+// http://lists.apple.com/archives/Xcode-users/2006/Feb/msg00050.html
+SEPARATE_STRIP = YES
+
+// Force C99 dialect
+GCC_C_LANGUAGE_STANDARD = c99
+
+// not sure why apple defaults this on, but it's pretty risky
+ALWAYS_SEARCH_USER_PATHS = NO
+
+// Turn on position dependent code for most cases (overridden where appropriate)
+GCC_DYNAMIC_NO_PIC = YES
+
+// Default SDK and minimum OS version is 10.4
+SDKROOT = $(DEVELOPER_SDK_DIR)/MacOSX10.4u.sdk
+MACOSX_DEPLOYMENT_TARGET = 10.4
+GCC_VERSION = 4.0
+
+// VERSIONING BUILD SETTINGS (used in Info.plist)
+GTEST_VERSIONINFO_ABOUT =  © 2008 Google Inc.
diff --git a/gtest-1.6.0/xcode/Config/ReleaseProject.xcconfig b/gtest-1.6.0/xcode/Config/ReleaseProject.xcconfig
index 6c8d12e..5349f0a 100644
--- a/gtest-1.6.0/xcode/Config/ReleaseProject.xcconfig
+++ b/gtest-1.6.0/xcode/Config/ReleaseProject.xcconfig
@@ -1,32 +1,32 @@
-//

-//  ReleaseProject.xcconfig

-//

-//  These are Release Configuration project settings for the gtest framework

-//  and examples. It is set in the "Based On:" dropdown in the "Project" info

-//  dialog.

-//  This file is based on the Xcode Configuration files in:

-//  http://code.google.com/p/google-toolbox-for-mac/

-// 

-

-#include "General.xcconfig"

-

-// subconfig/Release.xcconfig

-

-// Optimize for space and size (Apple recommendation)

-GCC_OPTIMIZATION_LEVEL = s

-

-// Deploment postprocessing is what triggers Xcode to strip

-DEPLOYMENT_POSTPROCESSING = YES

-

-// No symbols

-GCC_GENERATE_DEBUGGING_SYMBOLS = NO

-

-// Dead code strip does not affect ObjC code but can help for C

-DEAD_CODE_STRIPPING = YES

-

-// NDEBUG is used by things like assert.h, so define it for general compat.

-// ASSERT going away in release tends to create unused vars.

-OTHER_CFLAGS = $(OTHER_CFLAGS) -DNDEBUG=1 -Wno-unused-variable

-

-// When we strip we want to strip all symbols in release, but save externals.

-STRIP_STYLE = all

+//
+//  ReleaseProject.xcconfig
+//
+//  These are Release Configuration project settings for the gtest framework
+//  and examples. It is set in the "Based On:" dropdown in the "Project" info
+//  dialog.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+#include "General.xcconfig"
+
+// subconfig/Release.xcconfig
+
+// Optimize for space and size (Apple recommendation)
+GCC_OPTIMIZATION_LEVEL = s
+
+// Deploment postprocessing is what triggers Xcode to strip
+DEPLOYMENT_POSTPROCESSING = YES
+
+// No symbols
+GCC_GENERATE_DEBUGGING_SYMBOLS = NO
+
+// Dead code strip does not affect ObjC code but can help for C
+DEAD_CODE_STRIPPING = YES
+
+// NDEBUG is used by things like assert.h, so define it for general compat.
+// ASSERT going away in release tends to create unused vars.
+OTHER_CFLAGS = $(OTHER_CFLAGS) -DNDEBUG=1 -Wno-unused-variable
+
+// When we strip we want to strip all symbols in release, but save externals.
+STRIP_STYLE = all
diff --git a/gtest-1.6.0/xcode/Config/StaticLibraryTarget.xcconfig b/gtest-1.6.0/xcode/Config/StaticLibraryTarget.xcconfig
index f69e1c2..3922fa5 100644
--- a/gtest-1.6.0/xcode/Config/StaticLibraryTarget.xcconfig
+++ b/gtest-1.6.0/xcode/Config/StaticLibraryTarget.xcconfig
@@ -1,18 +1,18 @@
-//

-//  StaticLibraryTarget.xcconfig

-//

-//  These are static library target settings for libgtest.a. It

-//  is set in the "Based On:" dropdown in the "Target" info dialog.

-//  This file is based on the Xcode Configuration files in:

-//  http://code.google.com/p/google-toolbox-for-mac/

-// 

-

-// Static libs can be included in bundles so make them position independent

-GCC_DYNAMIC_NO_PIC = NO

-

-// Static libs should not have their internal globals or external symbols

-// stripped.

-STRIP_STYLE = debugging

-

-// Let the user install by specifying the $DSTROOT with xcodebuild

-SKIP_INSTALL = NO

+//
+//  StaticLibraryTarget.xcconfig
+//
+//  These are static library target settings for libgtest.a. It
+//  is set in the "Based On:" dropdown in the "Target" info dialog.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+// Static libs can be included in bundles so make them position independent
+GCC_DYNAMIC_NO_PIC = NO
+
+// Static libs should not have their internal globals or external symbols
+// stripped.
+STRIP_STYLE = debugging
+
+// Let the user install by specifying the $DSTROOT with xcodebuild
+SKIP_INSTALL = NO
diff --git a/gtest-1.6.0/xcode/Config/TestTarget.xcconfig b/gtest-1.6.0/xcode/Config/TestTarget.xcconfig
index 9dd13ae..e6652ba 100644
--- a/gtest-1.6.0/xcode/Config/TestTarget.xcconfig
+++ b/gtest-1.6.0/xcode/Config/TestTarget.xcconfig
@@ -1,8 +1,8 @@
-//

-//  TestTarget.xcconfig

-//

-//  These are Test target settings for the gtest framework and examples. It

-//  is set in the "Based On:" dropdown in the "Target" info dialog.

-

-PRODUCT_NAME = $(TARGET_NAME)

-HEADER_SEARCH_PATHS = ../include

+//
+//  TestTarget.xcconfig
+//
+//  These are Test target settings for the gtest framework and examples. It
+//  is set in the "Based On:" dropdown in the "Target" info dialog.
+
+PRODUCT_NAME = $(TARGET_NAME)
+HEADER_SEARCH_PATHS = ../include
diff --git a/gtest-1.6.0/xcode/Resources/Info.plist b/gtest-1.6.0/xcode/Resources/Info.plist
index 3788888..9dd28ea 100644
--- a/gtest-1.6.0/xcode/Resources/Info.plist
+++ b/gtest-1.6.0/xcode/Resources/Info.plist
@@ -1,30 +1,30 @@
-<?xml version="1.0" encoding="UTF-8"?>

-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

-<plist version="1.0">

-<dict>

-	<key>CFBundleDevelopmentRegion</key>

-	<string>English</string>

-	<key>CFBundleExecutable</key>

-	<string>${EXECUTABLE_NAME}</string>

-	<key>CFBundleIconFile</key>

-	<string></string>

-	<key>CFBundleIdentifier</key>

-	<string>com.google.${PRODUCT_NAME}</string>

-	<key>CFBundleInfoDictionaryVersion</key>

-	<string>6.0</string>

-	<key>CFBundlePackageType</key>

-	<string>FMWK</string>

-	<key>CFBundleSignature</key>

-	<string>????</string>

-	<key>CFBundleVersion</key>

-	<string>GTEST_VERSIONINFO_LONG</string>

-	<key>CFBundleShortVersionString</key>

-	<string>GTEST_VERSIONINFO_SHORT</string>

-	<key>CFBundleGetInfoString</key>

-	<string>${PRODUCT_NAME} GTEST_VERSIONINFO_LONG, ${GTEST_VERSIONINFO_ABOUT}</string>

-	<key>NSHumanReadableCopyright</key>

-	<string>${GTEST_VERSIONINFO_ABOUT}</string>

-	<key>CSResourcesFileMapped</key>

-	<true/>

-</dict>

-</plist>

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>com.google.${PRODUCT_NAME}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>GTEST_VERSIONINFO_LONG</string>
+	<key>CFBundleShortVersionString</key>
+	<string>GTEST_VERSIONINFO_SHORT</string>
+	<key>CFBundleGetInfoString</key>
+	<string>${PRODUCT_NAME} GTEST_VERSIONINFO_LONG, ${GTEST_VERSIONINFO_ABOUT}</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>${GTEST_VERSIONINFO_ABOUT}</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+</dict>
+</plist>
diff --git a/gtest-1.6.0/xcode/Samples/FrameworkSample/Info.plist b/gtest-1.6.0/xcode/Samples/FrameworkSample/Info.plist
index 0f32858..f3852ed 100644
--- a/gtest-1.6.0/xcode/Samples/FrameworkSample/Info.plist
+++ b/gtest-1.6.0/xcode/Samples/FrameworkSample/Info.plist
@@ -1,28 +1,28 @@
-<?xml version="1.0" encoding="UTF-8"?>

-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

-<plist version="1.0">

-<dict>

-	<key>CFBundleDevelopmentRegion</key>

-	<string>English</string>

-	<key>CFBundleExecutable</key>

-	<string>${EXECUTABLE_NAME}</string>

-	<key>CFBundleIconFile</key>

-	<string></string>

-	<key>CFBundleIdentifier</key>

-	<string>com.google.gtest.${PRODUCT_NAME:identifier}</string>

-	<key>CFBundleInfoDictionaryVersion</key>

-	<string>6.0</string>

-	<key>CFBundleName</key>

-	<string>${PRODUCT_NAME}</string>

-	<key>CFBundlePackageType</key>

-	<string>FMWK</string>

-	<key>CFBundleShortVersionString</key>

-	<string>1.0</string>

-	<key>CFBundleSignature</key>

-	<string>????</string>

-	<key>CFBundleVersion</key>

-	<string>1.0</string>

-	<key>CSResourcesFileMapped</key>

-	<true/>

-</dict>

-</plist>

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>com.google.gtest.${PRODUCT_NAME:identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+</dict>
+</plist>
diff --git a/gtest-1.6.0/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj b/gtest-1.6.0/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
index edf971b..497617e 100644
--- a/gtest-1.6.0/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
+++ b/gtest-1.6.0/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
@@ -1,457 +1,457 @@
-// !$*UTF8*$!

-{

-	archiveVersion = 1;

-	classes = {

-	};

-	objectVersion = 42;

-	objects = {

-

-/* Begin PBXAggregateTarget section */

-		4024D162113D7D2400C7059E /* Test */ = {

-			isa = PBXAggregateTarget;

-			buildConfigurationList = 4024D169113D7D4600C7059E /* Build configuration list for PBXAggregateTarget "Test" */;

-			buildPhases = (

-				4024D161113D7D2400C7059E /* ShellScript */,

-			);

-			dependencies = (

-				4024D166113D7D3100C7059E /* PBXTargetDependency */,

-			);

-			name = Test;

-			productName = TestAndBuild;

-		};

-		4024D1E9113D83FF00C7059E /* TestAndBuild */ = {

-			isa = PBXAggregateTarget;

-			buildConfigurationList = 4024D1F0113D842B00C7059E /* Build configuration list for PBXAggregateTarget "TestAndBuild" */;

-			buildPhases = (

-			);

-			dependencies = (

-				4024D1ED113D840900C7059E /* PBXTargetDependency */,

-				4024D1EF113D840D00C7059E /* PBXTargetDependency */,

-			);

-			name = TestAndBuild;

-			productName = TestAndBuild;

-		};

-/* End PBXAggregateTarget section */

-

-/* Begin PBXBuildFile section */

-		3B7EB1250E5AEE3500C7F239 /* widget.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B7EB1230E5AEE3500C7F239 /* widget.cc */; };

-		3B7EB1260E5AEE3500C7F239 /* widget.h in Headers */ = {isa = PBXBuildFile; fileRef = 3B7EB1240E5AEE3500C7F239 /* widget.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		3B7EB1280E5AEE4600C7F239 /* widget_test.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B7EB1270E5AEE4600C7F239 /* widget_test.cc */; };

-		3B7EB1480E5AF3B400C7F239 /* Widget.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8D07F2C80486CC7A007CD1D0 /* Widget.framework */; };

-		4024D188113D7D7800C7059E /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4024D185113D7D5500C7059E /* libgtest.a */; };

-		4024D189113D7D7A00C7059E /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4024D183113D7D5500C7059E /* libgtest_main.a */; };

-/* End PBXBuildFile section */

-

-/* Begin PBXContainerItemProxy section */

-		3B07BDF00E3F3FAE00647869 /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;

-			remoteInfo = gTestExample;

-		};

-		4024D165113D7D3100C7059E /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 3B07BDE90E3F3F9E00647869;

-			remoteInfo = WidgetFrameworkTest;

-		};

-		4024D1EC113D840900C7059E /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;

-			remoteInfo = WidgetFramework;

-		};

-		4024D1EE113D840D00C7059E /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 4024D162113D7D2400C7059E;

-			remoteInfo = Test;

-		};

-/* End PBXContainerItemProxy section */

-

-/* Begin PBXFileReference section */

-		3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = WidgetFrameworkTest; sourceTree = BUILT_PRODUCTS_DIR; };

-		3B7EB1230E5AEE3500C7F239 /* widget.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = widget.cc; sourceTree = "<group>"; };

-		3B7EB1240E5AEE3500C7F239 /* widget.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = widget.h; sourceTree = "<group>"; };

-		3B7EB1270E5AEE4600C7F239 /* widget_test.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = widget_test.cc; sourceTree = "<group>"; };

-		4024D183113D7D5500C7059E /* libgtest_main.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgtest_main.a; path = /usr/local/lib/libgtest_main.a; sourceTree = "<absolute>"; };

-		4024D185113D7D5500C7059E /* libgtest.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgtest.a; path = /usr/local/lib/libgtest.a; sourceTree = "<absolute>"; };

-		4024D1E2113D838200C7059E /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };

-		8D07F2C70486CC7A007CD1D0 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };

-		8D07F2C80486CC7A007CD1D0 /* Widget.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Widget.framework; sourceTree = BUILT_PRODUCTS_DIR; };

-/* End PBXFileReference section */

-

-/* Begin PBXFrameworksBuildPhase section */

-		3B07BDE80E3F3F9E00647869 /* Frameworks */ = {

-			isa = PBXFrameworksBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				4024D189113D7D7A00C7059E /* libgtest_main.a in Frameworks */,

-				4024D188113D7D7800C7059E /* libgtest.a in Frameworks */,

-				3B7EB1480E5AF3B400C7F239 /* Widget.framework in Frameworks */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		8D07F2C30486CC7A007CD1D0 /* Frameworks */ = {

-			isa = PBXFrameworksBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXFrameworksBuildPhase section */

-

-/* Begin PBXGroup section */

-		034768DDFF38A45A11DB9C8B /* Products */ = {

-			isa = PBXGroup;

-			children = (

-				8D07F2C80486CC7A007CD1D0 /* Widget.framework */,

-				3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */,

-			);

-			name = Products;

-			sourceTree = "<group>";

-		};

-		0867D691FE84028FC02AAC07 /* gTestExample */ = {

-			isa = PBXGroup;

-			children = (

-				4024D1E1113D836C00C7059E /* Scripts */,

-				08FB77ACFE841707C02AAC07 /* Source */,

-				089C1665FE841158C02AAC07 /* Resources */,

-				3B07BE350E4094E400647869 /* Test */,

-				0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */,

-				034768DDFF38A45A11DB9C8B /* Products */,

-			);

-			name = gTestExample;

-			sourceTree = "<group>";

-		};

-		0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */ = {

-			isa = PBXGroup;

-			children = (

-				4024D183113D7D5500C7059E /* libgtest_main.a */,

-				4024D185113D7D5500C7059E /* libgtest.a */,

-			);

-			name = "External Frameworks and Libraries";

-			sourceTree = "<group>";

-		};

-		089C1665FE841158C02AAC07 /* Resources */ = {

-			isa = PBXGroup;

-			children = (

-				8D07F2C70486CC7A007CD1D0 /* Info.plist */,

-			);

-			name = Resources;

-			sourceTree = "<group>";

-		};

-		08FB77ACFE841707C02AAC07 /* Source */ = {

-			isa = PBXGroup;

-			children = (

-				3B7EB1230E5AEE3500C7F239 /* widget.cc */,

-				3B7EB1240E5AEE3500C7F239 /* widget.h */,

-			);

-			name = Source;

-			sourceTree = "<group>";

-		};

-		3B07BE350E4094E400647869 /* Test */ = {

-			isa = PBXGroup;

-			children = (

-				3B7EB1270E5AEE4600C7F239 /* widget_test.cc */,

-			);

-			name = Test;

-			sourceTree = "<group>";

-		};

-		4024D1E1113D836C00C7059E /* Scripts */ = {

-			isa = PBXGroup;

-			children = (

-				4024D1E2113D838200C7059E /* runtests.sh */,

-			);

-			name = Scripts;

-			sourceTree = "<group>";

-		};

-/* End PBXGroup section */

-

-/* Begin PBXHeadersBuildPhase section */

-		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {

-			isa = PBXHeadersBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				3B7EB1260E5AEE3500C7F239 /* widget.h in Headers */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXHeadersBuildPhase section */

-

-/* Begin PBXNativeTarget section */

-		3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 3B07BDF40E3F3FB600647869 /* Build configuration list for PBXNativeTarget "WidgetFrameworkTest" */;

-			buildPhases = (

-				3B07BDE70E3F3F9E00647869 /* Sources */,

-				3B07BDE80E3F3F9E00647869 /* Frameworks */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-				3B07BDF10E3F3FAE00647869 /* PBXTargetDependency */,

-			);

-			name = WidgetFrameworkTest;

-			productName = gTestExampleTest;

-			productReference = 3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */;

-			productType = "com.apple.product-type.tool";

-		};

-		8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "WidgetFramework" */;

-			buildPhases = (

-				8D07F2C10486CC7A007CD1D0 /* Sources */,

-				8D07F2C30486CC7A007CD1D0 /* Frameworks */,

-				8D07F2BD0486CC7A007CD1D0 /* Headers */,

-				8D07F2BF0486CC7A007CD1D0 /* Resources */,

-				8D07F2C50486CC7A007CD1D0 /* Rez */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-			);

-			name = WidgetFramework;

-			productInstallPath = "$(HOME)/Library/Frameworks";

-			productName = gTestExample;

-			productReference = 8D07F2C80486CC7A007CD1D0 /* Widget.framework */;

-			productType = "com.apple.product-type.framework";

-		};

-/* End PBXNativeTarget section */

-

-/* Begin PBXProject section */

-		0867D690FE84028FC02AAC07 /* Project object */ = {

-			isa = PBXProject;

-			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "WidgetFramework" */;

-			compatibilityVersion = "Xcode 2.4";

-			hasScannedForEncodings = 1;

-			mainGroup = 0867D691FE84028FC02AAC07 /* gTestExample */;

-			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;

-			projectDirPath = "";

-			projectRoot = "";

-			targets = (

-				8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */,

-				3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */,

-				4024D162113D7D2400C7059E /* Test */,

-				4024D1E9113D83FF00C7059E /* TestAndBuild */,

-			);

-		};

-/* End PBXProject section */

-

-/* Begin PBXResourcesBuildPhase section */

-		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {

-			isa = PBXResourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXResourcesBuildPhase section */

-

-/* Begin PBXRezBuildPhase section */

-		8D07F2C50486CC7A007CD1D0 /* Rez */ = {

-			isa = PBXRezBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXRezBuildPhase section */

-

-/* Begin PBXShellScriptBuildPhase section */

-		4024D161113D7D2400C7059E /* ShellScript */ = {

-			isa = PBXShellScriptBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-			);

-			inputPaths = (

-			);

-			outputPaths = (

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-			shellPath = /bin/sh;

-			shellScript = "/bin/bash $SRCROOT/runtests.sh $BUILT_PRODUCTS_DIR/WidgetFrameworkTest\n";

-		};

-/* End PBXShellScriptBuildPhase section */

-

-/* Begin PBXSourcesBuildPhase section */

-		3B07BDE70E3F3F9E00647869 /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				3B7EB1280E5AEE4600C7F239 /* widget_test.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		8D07F2C10486CC7A007CD1D0 /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				3B7EB1250E5AEE3500C7F239 /* widget.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXSourcesBuildPhase section */

-

-/* Begin PBXTargetDependency section */

-		3B07BDF10E3F3FAE00647869 /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */;

-			targetProxy = 3B07BDF00E3F3FAE00647869 /* PBXContainerItemProxy */;

-		};

-		4024D166113D7D3100C7059E /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */;

-			targetProxy = 4024D165113D7D3100C7059E /* PBXContainerItemProxy */;

-		};

-		4024D1ED113D840900C7059E /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */;

-			targetProxy = 4024D1EC113D840900C7059E /* PBXContainerItemProxy */;

-		};

-		4024D1EF113D840D00C7059E /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 4024D162113D7D2400C7059E /* Test */;

-			targetProxy = 4024D1EE113D840D00C7059E /* PBXContainerItemProxy */;

-		};

-/* End PBXTargetDependency section */

-

-/* Begin XCBuildConfiguration section */

-		3B07BDEC0E3F3F9F00647869 /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = WidgetFrameworkTest;

-			};

-			name = Debug;

-		};

-		3B07BDED0E3F3F9F00647869 /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = WidgetFrameworkTest;

-			};

-			name = Release;

-		};

-		4024D163113D7D2400C7059E /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = TestAndBuild;

-			};

-			name = Debug;

-		};

-		4024D164113D7D2400C7059E /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = TestAndBuild;

-			};

-			name = Release;

-		};

-		4024D1EA113D83FF00C7059E /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = TestAndBuild;

-			};

-			name = Debug;

-		};

-		4024D1EB113D83FF00C7059E /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = TestAndBuild;

-			};

-			name = Release;

-		};

-		4FADC24308B4156D00ABE55E /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				DYLIB_COMPATIBILITY_VERSION = 1;

-				DYLIB_CURRENT_VERSION = 1;

-				FRAMEWORK_VERSION = A;

-				INFOPLIST_FILE = Info.plist;

-				INSTALL_PATH = "@loader_path/../Frameworks";

-				PRODUCT_NAME = Widget;

-			};

-			name = Debug;

-		};

-		4FADC24408B4156D00ABE55E /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				DYLIB_COMPATIBILITY_VERSION = 1;

-				DYLIB_CURRENT_VERSION = 1;

-				FRAMEWORK_VERSION = A;

-				INFOPLIST_FILE = Info.plist;

-				INSTALL_PATH = "@loader_path/../Frameworks";

-				PRODUCT_NAME = Widget;

-			};

-			name = Release;

-		};

-		4FADC24708B4156D00ABE55E /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				GCC_VERSION = 4.0;

-				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;

-			};

-			name = Debug;

-		};

-		4FADC24808B4156D00ABE55E /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				GCC_VERSION = 4.0;

-				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;

-			};

-			name = Release;

-		};

-/* End XCBuildConfiguration section */

-

-/* Begin XCConfigurationList section */

-		3B07BDF40E3F3FB600647869 /* Build configuration list for PBXNativeTarget "WidgetFrameworkTest" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				3B07BDEC0E3F3F9F00647869 /* Debug */,

-				3B07BDED0E3F3F9F00647869 /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		4024D169113D7D4600C7059E /* Build configuration list for PBXAggregateTarget "Test" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				4024D163113D7D2400C7059E /* Debug */,

-				4024D164113D7D2400C7059E /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		4024D1F0113D842B00C7059E /* Build configuration list for PBXAggregateTarget "TestAndBuild" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				4024D1EA113D83FF00C7059E /* Debug */,

-				4024D1EB113D83FF00C7059E /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "WidgetFramework" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				4FADC24308B4156D00ABE55E /* Debug */,

-				4FADC24408B4156D00ABE55E /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "WidgetFramework" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				4FADC24708B4156D00ABE55E /* Debug */,

-				4FADC24808B4156D00ABE55E /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-/* End XCConfigurationList section */

-	};

-	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;

-}

+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 42;
+	objects = {
+
+/* Begin PBXAggregateTarget section */
+		4024D162113D7D2400C7059E /* Test */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 4024D169113D7D4600C7059E /* Build configuration list for PBXAggregateTarget "Test" */;
+			buildPhases = (
+				4024D161113D7D2400C7059E /* ShellScript */,
+			);
+			dependencies = (
+				4024D166113D7D3100C7059E /* PBXTargetDependency */,
+			);
+			name = Test;
+			productName = TestAndBuild;
+		};
+		4024D1E9113D83FF00C7059E /* TestAndBuild */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 4024D1F0113D842B00C7059E /* Build configuration list for PBXAggregateTarget "TestAndBuild" */;
+			buildPhases = (
+			);
+			dependencies = (
+				4024D1ED113D840900C7059E /* PBXTargetDependency */,
+				4024D1EF113D840D00C7059E /* PBXTargetDependency */,
+			);
+			name = TestAndBuild;
+			productName = TestAndBuild;
+		};
+/* End PBXAggregateTarget section */
+
+/* Begin PBXBuildFile section */
+		3B7EB1250E5AEE3500C7F239 /* widget.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B7EB1230E5AEE3500C7F239 /* widget.cc */; };
+		3B7EB1260E5AEE3500C7F239 /* widget.h in Headers */ = {isa = PBXBuildFile; fileRef = 3B7EB1240E5AEE3500C7F239 /* widget.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		3B7EB1280E5AEE4600C7F239 /* widget_test.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B7EB1270E5AEE4600C7F239 /* widget_test.cc */; };
+		3B7EB1480E5AF3B400C7F239 /* Widget.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8D07F2C80486CC7A007CD1D0 /* Widget.framework */; };
+		4024D188113D7D7800C7059E /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4024D185113D7D5500C7059E /* libgtest.a */; };
+		4024D189113D7D7A00C7059E /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4024D183113D7D5500C7059E /* libgtest_main.a */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		3B07BDF00E3F3FAE00647869 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
+			remoteInfo = gTestExample;
+		};
+		4024D165113D7D3100C7059E /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 3B07BDE90E3F3F9E00647869;
+			remoteInfo = WidgetFrameworkTest;
+		};
+		4024D1EC113D840900C7059E /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
+			remoteInfo = WidgetFramework;
+		};
+		4024D1EE113D840D00C7059E /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 4024D162113D7D2400C7059E;
+			remoteInfo = Test;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = WidgetFrameworkTest; sourceTree = BUILT_PRODUCTS_DIR; };
+		3B7EB1230E5AEE3500C7F239 /* widget.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = widget.cc; sourceTree = "<group>"; };
+		3B7EB1240E5AEE3500C7F239 /* widget.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = widget.h; sourceTree = "<group>"; };
+		3B7EB1270E5AEE4600C7F239 /* widget_test.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = widget_test.cc; sourceTree = "<group>"; };
+		4024D183113D7D5500C7059E /* libgtest_main.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgtest_main.a; path = /usr/local/lib/libgtest_main.a; sourceTree = "<absolute>"; };
+		4024D185113D7D5500C7059E /* libgtest.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgtest.a; path = /usr/local/lib/libgtest.a; sourceTree = "<absolute>"; };
+		4024D1E2113D838200C7059E /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };
+		8D07F2C70486CC7A007CD1D0 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };
+		8D07F2C80486CC7A007CD1D0 /* Widget.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Widget.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		3B07BDE80E3F3F9E00647869 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				4024D189113D7D7A00C7059E /* libgtest_main.a in Frameworks */,
+				4024D188113D7D7800C7059E /* libgtest.a in Frameworks */,
+				3B7EB1480E5AF3B400C7F239 /* Widget.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		8D07F2C30486CC7A007CD1D0 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		034768DDFF38A45A11DB9C8B /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				8D07F2C80486CC7A007CD1D0 /* Widget.framework */,
+				3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		0867D691FE84028FC02AAC07 /* gTestExample */ = {
+			isa = PBXGroup;
+			children = (
+				4024D1E1113D836C00C7059E /* Scripts */,
+				08FB77ACFE841707C02AAC07 /* Source */,
+				089C1665FE841158C02AAC07 /* Resources */,
+				3B07BE350E4094E400647869 /* Test */,
+				0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */,
+				034768DDFF38A45A11DB9C8B /* Products */,
+			);
+			name = gTestExample;
+			sourceTree = "<group>";
+		};
+		0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */ = {
+			isa = PBXGroup;
+			children = (
+				4024D183113D7D5500C7059E /* libgtest_main.a */,
+				4024D185113D7D5500C7059E /* libgtest.a */,
+			);
+			name = "External Frameworks and Libraries";
+			sourceTree = "<group>";
+		};
+		089C1665FE841158C02AAC07 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				8D07F2C70486CC7A007CD1D0 /* Info.plist */,
+			);
+			name = Resources;
+			sourceTree = "<group>";
+		};
+		08FB77ACFE841707C02AAC07 /* Source */ = {
+			isa = PBXGroup;
+			children = (
+				3B7EB1230E5AEE3500C7F239 /* widget.cc */,
+				3B7EB1240E5AEE3500C7F239 /* widget.h */,
+			);
+			name = Source;
+			sourceTree = "<group>";
+		};
+		3B07BE350E4094E400647869 /* Test */ = {
+			isa = PBXGroup;
+			children = (
+				3B7EB1270E5AEE4600C7F239 /* widget_test.cc */,
+			);
+			name = Test;
+			sourceTree = "<group>";
+		};
+		4024D1E1113D836C00C7059E /* Scripts */ = {
+			isa = PBXGroup;
+			children = (
+				4024D1E2113D838200C7059E /* runtests.sh */,
+			);
+			name = Scripts;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3B7EB1260E5AEE3500C7F239 /* widget.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 3B07BDF40E3F3FB600647869 /* Build configuration list for PBXNativeTarget "WidgetFrameworkTest" */;
+			buildPhases = (
+				3B07BDE70E3F3F9E00647869 /* Sources */,
+				3B07BDE80E3F3F9E00647869 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				3B07BDF10E3F3FAE00647869 /* PBXTargetDependency */,
+			);
+			name = WidgetFrameworkTest;
+			productName = gTestExampleTest;
+			productReference = 3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */;
+			productType = "com.apple.product-type.tool";
+		};
+		8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "WidgetFramework" */;
+			buildPhases = (
+				8D07F2C10486CC7A007CD1D0 /* Sources */,
+				8D07F2C30486CC7A007CD1D0 /* Frameworks */,
+				8D07F2BD0486CC7A007CD1D0 /* Headers */,
+				8D07F2BF0486CC7A007CD1D0 /* Resources */,
+				8D07F2C50486CC7A007CD1D0 /* Rez */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = WidgetFramework;
+			productInstallPath = "$(HOME)/Library/Frameworks";
+			productName = gTestExample;
+			productReference = 8D07F2C80486CC7A007CD1D0 /* Widget.framework */;
+			productType = "com.apple.product-type.framework";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		0867D690FE84028FC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "WidgetFramework" */;
+			compatibilityVersion = "Xcode 2.4";
+			hasScannedForEncodings = 1;
+			mainGroup = 0867D691FE84028FC02AAC07 /* gTestExample */;
+			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */,
+				3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */,
+				4024D162113D7D2400C7059E /* Test */,
+				4024D1E9113D83FF00C7059E /* TestAndBuild */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXRezBuildPhase section */
+		8D07F2C50486CC7A007CD1D0 /* Rez */ = {
+			isa = PBXRezBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXRezBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		4024D161113D7D2400C7059E /* ShellScript */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/bash $SRCROOT/runtests.sh $BUILT_PRODUCTS_DIR/WidgetFrameworkTest\n";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		3B07BDE70E3F3F9E00647869 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3B7EB1280E5AEE4600C7F239 /* widget_test.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		8D07F2C10486CC7A007CD1D0 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3B7EB1250E5AEE3500C7F239 /* widget.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		3B07BDF10E3F3FAE00647869 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */;
+			targetProxy = 3B07BDF00E3F3FAE00647869 /* PBXContainerItemProxy */;
+		};
+		4024D166113D7D3100C7059E /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */;
+			targetProxy = 4024D165113D7D3100C7059E /* PBXContainerItemProxy */;
+		};
+		4024D1ED113D840900C7059E /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */;
+			targetProxy = 4024D1EC113D840900C7059E /* PBXContainerItemProxy */;
+		};
+		4024D1EF113D840D00C7059E /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 4024D162113D7D2400C7059E /* Test */;
+			targetProxy = 4024D1EE113D840D00C7059E /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		3B07BDEC0E3F3F9F00647869 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = WidgetFrameworkTest;
+			};
+			name = Debug;
+		};
+		3B07BDED0E3F3F9F00647869 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = WidgetFrameworkTest;
+			};
+			name = Release;
+		};
+		4024D163113D7D2400C7059E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = TestAndBuild;
+			};
+			name = Debug;
+		};
+		4024D164113D7D2400C7059E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = TestAndBuild;
+			};
+			name = Release;
+		};
+		4024D1EA113D83FF00C7059E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = TestAndBuild;
+			};
+			name = Debug;
+		};
+		4024D1EB113D83FF00C7059E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = TestAndBuild;
+			};
+			name = Release;
+		};
+		4FADC24308B4156D00ABE55E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				FRAMEWORK_VERSION = A;
+				INFOPLIST_FILE = Info.plist;
+				INSTALL_PATH = "@loader_path/../Frameworks";
+				PRODUCT_NAME = Widget;
+			};
+			name = Debug;
+		};
+		4FADC24408B4156D00ABE55E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				FRAMEWORK_VERSION = A;
+				INFOPLIST_FILE = Info.plist;
+				INSTALL_PATH = "@loader_path/../Frameworks";
+				PRODUCT_NAME = Widget;
+			};
+			name = Release;
+		};
+		4FADC24708B4156D00ABE55E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = 4.0;
+				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
+			};
+			name = Debug;
+		};
+		4FADC24808B4156D00ABE55E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = 4.0;
+				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		3B07BDF40E3F3FB600647869 /* Build configuration list for PBXNativeTarget "WidgetFrameworkTest" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				3B07BDEC0E3F3F9F00647869 /* Debug */,
+				3B07BDED0E3F3F9F00647869 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4024D169113D7D4600C7059E /* Build configuration list for PBXAggregateTarget "Test" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4024D163113D7D2400C7059E /* Debug */,
+				4024D164113D7D2400C7059E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4024D1F0113D842B00C7059E /* Build configuration list for PBXAggregateTarget "TestAndBuild" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4024D1EA113D83FF00C7059E /* Debug */,
+				4024D1EB113D83FF00C7059E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "WidgetFramework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FADC24308B4156D00ABE55E /* Debug */,
+				4FADC24408B4156D00ABE55E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "WidgetFramework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FADC24708B4156D00ABE55E /* Debug */,
+				4FADC24808B4156D00ABE55E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
+}
diff --git a/gtest-1.6.0/xcode/Samples/FrameworkSample/runtests.sh b/gtest-1.6.0/xcode/Samples/FrameworkSample/runtests.sh
index 75378f7..4a0d413 100644
--- a/gtest-1.6.0/xcode/Samples/FrameworkSample/runtests.sh
+++ b/gtest-1.6.0/xcode/Samples/FrameworkSample/runtests.sh
@@ -1,62 +1,62 @@
-#!/bin/bash

-#

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

-

-# Executes the samples and tests for the Google Test Framework.

-

-# Help the dynamic linker find the path to the libraries.

-export DYLD_FRAMEWORK_PATH=$BUILT_PRODUCTS_DIR

-export DYLD_LIBRARY_PATH=$BUILT_PRODUCTS_DIR

-

-# Create some executables.

-test_executables=$@

-

-# Now execute each one in turn keeping track of how many succeeded and failed.

-succeeded=0

-failed=0

-failed_list=()

-for test in ${test_executables[*]}; do

-  "$test"

-  result=$?

-  if [ $result -eq 0 ]; then

-    succeeded=$(( $succeeded + 1 ))

-  else

-    failed=$(( failed + 1 ))

-    failed_list="$failed_list $test"

-  fi

-done

-

-# Report the successes and failures to the console.

-echo "Tests complete with $succeeded successes and $failed failures."

-if [ $failed -ne 0 ]; then

-  echo "The following tests failed:"

-  echo $failed_list

-fi

-exit $failed

+#!/bin/bash
+#
+# 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.
+
+# Executes the samples and tests for the Google Test Framework.
+
+# Help the dynamic linker find the path to the libraries.
+export DYLD_FRAMEWORK_PATH=$BUILT_PRODUCTS_DIR
+export DYLD_LIBRARY_PATH=$BUILT_PRODUCTS_DIR
+
+# Create some executables.
+test_executables=$@
+
+# Now execute each one in turn keeping track of how many succeeded and failed.
+succeeded=0
+failed=0
+failed_list=()
+for test in ${test_executables[*]}; do
+  "$test"
+  result=$?
+  if [ $result -eq 0 ]; then
+    succeeded=$(( $succeeded + 1 ))
+  else
+    failed=$(( failed + 1 ))
+    failed_list="$failed_list $test"
+  fi
+done
+
+# Report the successes and failures to the console.
+echo "Tests complete with $succeeded successes and $failed failures."
+if [ $failed -ne 0 ]; then
+  echo "The following tests failed:"
+  echo $failed_list
+fi
+exit $failed
diff --git a/gtest-1.6.0/xcode/Samples/FrameworkSample/widget.cc b/gtest-1.6.0/xcode/Samples/FrameworkSample/widget.cc
index 5c8db2f..bfc4e7f 100644
--- a/gtest-1.6.0/xcode/Samples/FrameworkSample/widget.cc
+++ b/gtest-1.6.0/xcode/Samples/FrameworkSample/widget.cc
@@ -1,63 +1,63 @@
-// 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: preston.a.jackson@gmail.com (Preston Jackson)

-//

-// Google Test - FrameworkSample

-// widget.cc

-//

-

-// Widget is a very simple class used for demonstrating the use of gtest

-

-#include "widget.h"

-

-Widget::Widget(int number, const std::string& name)

-    : number_(number),

-      name_(name) {}

-

-Widget::~Widget() {}

-

-float Widget::GetFloatValue() const {

-  return number_;

-}

-

-int Widget::GetIntValue() const {

-  return static_cast<int>(number_);

-}

-

-std::string Widget::GetStringValue() const {

-  return name_;

-}

-

-void Widget::GetCharPtrValue(char* buffer, size_t max_size) const {

-  // Copy the char* representation of name_ into buffer, up to max_size.

-  strncpy(buffer, name_.c_str(), max_size-1);

-  buffer[max_size-1] = '\0';

-  return;

-}

+// 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: preston.a.jackson@gmail.com (Preston Jackson)
+//
+// Google Test - FrameworkSample
+// widget.cc
+//
+
+// Widget is a very simple class used for demonstrating the use of gtest
+
+#include "widget.h"
+
+Widget::Widget(int number, const std::string& name)
+    : number_(number),
+      name_(name) {}
+
+Widget::~Widget() {}
+
+float Widget::GetFloatValue() const {
+  return number_;
+}
+
+int Widget::GetIntValue() const {
+  return static_cast<int>(number_);
+}
+
+std::string Widget::GetStringValue() const {
+  return name_;
+}
+
+void Widget::GetCharPtrValue(char* buffer, size_t max_size) const {
+  // Copy the char* representation of name_ into buffer, up to max_size.
+  strncpy(buffer, name_.c_str(), max_size-1);
+  buffer[max_size-1] = '\0';
+  return;
+}
diff --git a/gtest-1.6.0/xcode/Samples/FrameworkSample/widget.h b/gtest-1.6.0/xcode/Samples/FrameworkSample/widget.h
index e4bb074..0c55cdc 100644
--- a/gtest-1.6.0/xcode/Samples/FrameworkSample/widget.h
+++ b/gtest-1.6.0/xcode/Samples/FrameworkSample/widget.h
@@ -1,59 +1,59 @@
-// 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: preston.a.jackson@gmail.com (Preston Jackson)

-//

-// Google Test - FrameworkSample

-// widget.h

-//

-

-// Widget is a very simple class used for demonstrating the use of gtest. It

-// simply stores two values a string and an integer, which are returned via

-// public accessors in multiple forms.

-

-#import <string>

-

-class Widget {

- public:

-  Widget(int number, const std::string& name);

-  ~Widget();

-

-  // Public accessors to number data

-  float GetFloatValue() const;

-  int GetIntValue() const;

-

-  // Public accessors to the string data

-  std::string GetStringValue() const;

-  void GetCharPtrValue(char* buffer, size_t max_size) const;

-

- private:

-  // Data members

-  float number_;

-  std::string name_;

-};

+// 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: preston.a.jackson@gmail.com (Preston Jackson)
+//
+// Google Test - FrameworkSample
+// widget.h
+//
+
+// Widget is a very simple class used for demonstrating the use of gtest. It
+// simply stores two values a string and an integer, which are returned via
+// public accessors in multiple forms.
+
+#import <string>
+
+class Widget {
+ public:
+  Widget(int number, const std::string& name);
+  ~Widget();
+
+  // Public accessors to number data
+  float GetFloatValue() const;
+  int GetIntValue() const;
+
+  // Public accessors to the string data
+  std::string GetStringValue() const;
+  void GetCharPtrValue(char* buffer, size_t max_size) const;
+
+ private:
+  // Data members
+  float number_;
+  std::string name_;
+};
diff --git a/gtest-1.6.0/xcode/Samples/FrameworkSample/widget_test.cc b/gtest-1.6.0/xcode/Samples/FrameworkSample/widget_test.cc
index d0cbcb6..8725994 100644
--- a/gtest-1.6.0/xcode/Samples/FrameworkSample/widget_test.cc
+++ b/gtest-1.6.0/xcode/Samples/FrameworkSample/widget_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: preston.a.jackson@gmail.com (Preston Jackson)

-//

-// Google Test - FrameworkSample

-// widget_test.cc

-//

-

-// This is a simple test file for the Widget class in the Widget.framework

-

-#include <string>

-#include "gtest/gtest.h"

-

-#include <Widget/widget.h>

-

-// This test verifies that the constructor sets the internal state of the

-// Widget class correctly.

-TEST(WidgetInitializerTest, TestConstructor) {

-  Widget widget(1.0f, "name");

-  EXPECT_FLOAT_EQ(1.0f, widget.GetFloatValue());

-  EXPECT_EQ(std::string("name"), widget.GetStringValue());

-}

-

-// This test verifies the conversion of the float and string values to int and

-// char*, respectively.

-TEST(WidgetInitializerTest, TestConversion) {

-  Widget widget(1.0f, "name");

-  EXPECT_EQ(1, widget.GetIntValue());

-

-  size_t max_size = 128;

-  char buffer[max_size];

-  widget.GetCharPtrValue(buffer, max_size);

-  EXPECT_STREQ("name", buffer);

-}

-

-// Use the Google Test main that is linked into the framework. It does something

-// like this:

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

-//   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: preston.a.jackson@gmail.com (Preston Jackson)
+//
+// Google Test - FrameworkSample
+// widget_test.cc
+//
+
+// This is a simple test file for the Widget class in the Widget.framework
+
+#include <string>
+#include "gtest/gtest.h"
+
+#include <Widget/widget.h>
+
+// This test verifies that the constructor sets the internal state of the
+// Widget class correctly.
+TEST(WidgetInitializerTest, TestConstructor) {
+  Widget widget(1.0f, "name");
+  EXPECT_FLOAT_EQ(1.0f, widget.GetFloatValue());
+  EXPECT_EQ(std::string("name"), widget.GetStringValue());
+}
+
+// This test verifies the conversion of the float and string values to int and
+// char*, respectively.
+TEST(WidgetInitializerTest, TestConversion) {
+  Widget widget(1.0f, "name");
+  EXPECT_EQ(1, widget.GetIntValue());
+
+  size_t max_size = 128;
+  char buffer[max_size];
+  widget.GetCharPtrValue(buffer, max_size);
+  EXPECT_STREQ("name", buffer);
+}
+
+// Use the Google Test main that is linked into the framework. It does something
+// like this:
+// int main(int argc, char** argv) {
+//   testing::InitGoogleTest(&argc, argv);
+//   return RUN_ALL_TESTS();
+// }
diff --git a/gtest-1.6.0/xcode/Scripts/runtests.sh b/gtest-1.6.0/xcode/Scripts/runtests.sh
index 6e9865c..3fc229f 100644
--- a/gtest-1.6.0/xcode/Scripts/runtests.sh
+++ b/gtest-1.6.0/xcode/Scripts/runtests.sh
@@ -1,65 +1,65 @@
-#!/bin/bash

-#

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

-

-# Executes the samples and tests for the Google Test Framework.

-

-# Help the dynamic linker find the path to the libraries.

-export DYLD_FRAMEWORK_PATH=$BUILT_PRODUCTS_DIR

-export DYLD_LIBRARY_PATH=$BUILT_PRODUCTS_DIR

-

-# Create some executables.

-test_executables=("$BUILT_PRODUCTS_DIR/gtest_unittest-framework"

-                  "$BUILT_PRODUCTS_DIR/gtest_unittest"

-                  "$BUILT_PRODUCTS_DIR/sample1_unittest-framework"

-                  "$BUILT_PRODUCTS_DIR/sample1_unittest-static")

-

-# Now execute each one in turn keeping track of how many succeeded and failed. 

-succeeded=0

-failed=0

-failed_list=()

-for test in ${test_executables[*]}; do

-  "$test"

-  result=$?

-  if [ $result -eq 0 ]; then

-    succeeded=$(( $succeeded + 1 ))

-  else

-    failed=$(( failed + 1 ))

-    failed_list="$failed_list $test"

-  fi

-done

-

-# Report the successes and failures to the console.

-echo "Tests complete with $succeeded successes and $failed failures."

-if [ $failed -ne 0 ]; then

-  echo "The following tests failed:"

-  echo $failed_list

-fi

-exit $failed

+#!/bin/bash
+#
+# 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.
+
+# Executes the samples and tests for the Google Test Framework.
+
+# Help the dynamic linker find the path to the libraries.
+export DYLD_FRAMEWORK_PATH=$BUILT_PRODUCTS_DIR
+export DYLD_LIBRARY_PATH=$BUILT_PRODUCTS_DIR
+
+# Create some executables.
+test_executables=("$BUILT_PRODUCTS_DIR/gtest_unittest-framework"
+                  "$BUILT_PRODUCTS_DIR/gtest_unittest"
+                  "$BUILT_PRODUCTS_DIR/sample1_unittest-framework"
+                  "$BUILT_PRODUCTS_DIR/sample1_unittest-static")
+
+# Now execute each one in turn keeping track of how many succeeded and failed. 
+succeeded=0
+failed=0
+failed_list=()
+for test in ${test_executables[*]}; do
+  "$test"
+  result=$?
+  if [ $result -eq 0 ]; then
+    succeeded=$(( $succeeded + 1 ))
+  else
+    failed=$(( failed + 1 ))
+    failed_list="$failed_list $test"
+  fi
+done
+
+# Report the successes and failures to the console.
+echo "Tests complete with $succeeded successes and $failed failures."
+if [ $failed -ne 0 ]; then
+  echo "The following tests failed:"
+  echo $failed_list
+fi
+exit $failed
diff --git a/gtest-1.6.0/xcode/Scripts/versiongenerate.py b/gtest-1.6.0/xcode/Scripts/versiongenerate.py
index b65eac4..81de8c9 100755
--- a/gtest-1.6.0/xcode/Scripts/versiongenerate.py
+++ b/gtest-1.6.0/xcode/Scripts/versiongenerate.py
@@ -1,100 +1,100 @@
-#!/usr/bin/env python

-#

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

-

-"""A script to prepare version informtion for use the gtest Info.plist file.

-

-  This script extracts the version information from the configure.ac file and

-  uses it to generate a header file containing the same information. The

-  #defines in this header file will be included in during the generation of

-  the Info.plist of the framework, giving the correct value to the version

-  shown in the Finder.

-

-  This script makes the following assumptions (these are faults of the script,

-  not problems with the Autoconf):

-    1. The AC_INIT macro will be contained within the first 1024 characters

-       of configure.ac

-    2. The version string will be 3 integers separated by periods and will be

-       surrounded by squre brackets, "[" and "]" (e.g. [1.0.1]). The first

-       segment represents the major version, the second represents the minor

-       version and the third represents the fix version.

-    3. No ")" character exists between the opening "(" and closing ")" of

-       AC_INIT, including in comments and character strings.

-"""

-

-import sys

-import re

-

-# Read the command line argument (the output directory for Version.h)

-if (len(sys.argv) < 3):

-  print "Usage: versiongenerate.py input_dir output_dir"

-  sys.exit(1)

-else:

-  input_dir = sys.argv[1]

-  output_dir = sys.argv[2]

-

-# Read the first 1024 characters of the configure.ac file

-config_file = open("%s/configure.ac" % input_dir, 'r')

-buffer_size = 1024

-opening_string = config_file.read(buffer_size)

-config_file.close()

-

-# Extract the version string from the AC_INIT macro

-#   The following init_expression means:

-#     Extract three integers separated by periods and surrounded by squre

-#     brackets(e.g. "[1.0.1]") between "AC_INIT(" and ")". Do not be greedy

-#     (*? is the non-greedy flag) since that would pull in everything between

-#     the first "(" and the last ")" in the file.

-version_expression = re.compile(r"AC_INIT\(.*?\[(\d+)\.(\d+)\.(\d+)\].*?\)",

-                                re.DOTALL)

-version_values = version_expression.search(opening_string)

-major_version = version_values.group(1)

-minor_version = version_values.group(2)

-fix_version = version_values.group(3)

-

-# Write the version information to a header file to be included in the

-# Info.plist file.

-file_data = """//

-// DO NOT MODIFY THIS FILE (but you can delete it)

-//

-// This file is autogenerated by the versiongenerate.py script. This script

-// is executed in a "Run Script" build phase when creating gtest.framework. This

-// header file is not used during compilation of C-source. Rather, it simply

-// defines some version strings for substitution in the Info.plist. Because of

-// this, we are not not restricted to C-syntax nor are we using include guards.

-//

-

-#define GTEST_VERSIONINFO_SHORT %s.%s

-#define GTEST_VERSIONINFO_LONG %s.%s.%s

-

-""" % (major_version, minor_version, major_version, minor_version, fix_version)

-version_file = open("%s/Version.h" % output_dir, 'w')

-version_file.write(file_data)

-version_file.close()

+#!/usr/bin/env python
+#
+# 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.
+
+"""A script to prepare version informtion for use the gtest Info.plist file.
+
+  This script extracts the version information from the configure.ac file and
+  uses it to generate a header file containing the same information. The
+  #defines in this header file will be included in during the generation of
+  the Info.plist of the framework, giving the correct value to the version
+  shown in the Finder.
+
+  This script makes the following assumptions (these are faults of the script,
+  not problems with the Autoconf):
+    1. The AC_INIT macro will be contained within the first 1024 characters
+       of configure.ac
+    2. The version string will be 3 integers separated by periods and will be
+       surrounded by squre brackets, "[" and "]" (e.g. [1.0.1]). The first
+       segment represents the major version, the second represents the minor
+       version and the third represents the fix version.
+    3. No ")" character exists between the opening "(" and closing ")" of
+       AC_INIT, including in comments and character strings.
+"""
+
+import sys
+import re
+
+# Read the command line argument (the output directory for Version.h)
+if (len(sys.argv) < 3):
+  print "Usage: versiongenerate.py input_dir output_dir"
+  sys.exit(1)
+else:
+  input_dir = sys.argv[1]
+  output_dir = sys.argv[2]
+
+# Read the first 1024 characters of the configure.ac file
+config_file = open("%s/configure.ac" % input_dir, 'r')
+buffer_size = 1024
+opening_string = config_file.read(buffer_size)
+config_file.close()
+
+# Extract the version string from the AC_INIT macro
+#   The following init_expression means:
+#     Extract three integers separated by periods and surrounded by squre
+#     brackets(e.g. "[1.0.1]") between "AC_INIT(" and ")". Do not be greedy
+#     (*? is the non-greedy flag) since that would pull in everything between
+#     the first "(" and the last ")" in the file.
+version_expression = re.compile(r"AC_INIT\(.*?\[(\d+)\.(\d+)\.(\d+)\].*?\)",
+                                re.DOTALL)
+version_values = version_expression.search(opening_string)
+major_version = version_values.group(1)
+minor_version = version_values.group(2)
+fix_version = version_values.group(3)
+
+# Write the version information to a header file to be included in the
+# Info.plist file.
+file_data = """//
+// DO NOT MODIFY THIS FILE (but you can delete it)
+//
+// This file is autogenerated by the versiongenerate.py script. This script
+// is executed in a "Run Script" build phase when creating gtest.framework. This
+// header file is not used during compilation of C-source. Rather, it simply
+// defines some version strings for substitution in the Info.plist. Because of
+// this, we are not not restricted to C-syntax nor are we using include guards.
+//
+
+#define GTEST_VERSIONINFO_SHORT %s.%s
+#define GTEST_VERSIONINFO_LONG %s.%s.%s
+
+""" % (major_version, minor_version, major_version, minor_version, fix_version)
+version_file = open("%s/Version.h" % output_dir, 'w')
+version_file.write(file_data)
+version_file.close()
diff --git a/gtest-1.6.0/xcode/gtest.xcodeproj/project.pbxproj b/gtest-1.6.0/xcode/gtest.xcodeproj/project.pbxproj
index 51ad43a..74a7815 100644
--- a/gtest-1.6.0/xcode/gtest.xcodeproj/project.pbxproj
+++ b/gtest-1.6.0/xcode/gtest.xcodeproj/project.pbxproj
@@ -1,1084 +1,1084 @@
-// !$*UTF8*$!

-{

-	archiveVersion = 1;

-	classes = {

-	};

-	objectVersion = 42;

-	objects = {

-

-/* Begin PBXAggregateTarget section */

-		3B238F5F0E828B5400846E11 /* Check */ = {

-			isa = PBXAggregateTarget;

-			buildConfigurationList = 3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */;

-			buildPhases = (

-				3B238F5E0E828B5400846E11 /* ShellScript */,

-			);

-			dependencies = (

-				40899F9D0FFA740F000B29AE /* PBXTargetDependency */,

-				40C849F7101A43440083642A /* PBXTargetDependency */,

-				4089A0980FFAD34A000B29AE /* PBXTargetDependency */,

-				40C849F9101A43490083642A /* PBXTargetDependency */,

-			);

-			name = Check;

-			productName = Check;

-		};

-		40C44ADC0E3798F4008FCC51 /* Version Info */ = {

-			isa = PBXAggregateTarget;

-			buildConfigurationList = 40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */;

-			buildPhases = (

-				40C44ADB0E3798F4008FCC51 /* Generate Version.h */,

-			);

-			comments = "The generation of Version.h must be performed in its own target. Since the Info.plist is preprocessed before any of the other build phases in gtest, the Version.h file would not be ready if included as a build phase of that target.";

-			dependencies = (

-			);

-			name = "Version Info";

-			productName = Version.h;

-		};

-/* End PBXAggregateTarget section */

-

-/* Begin PBXBuildFile section */

-		224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */ = {isa = PBXBuildFile; fileRef = 224A12A20E9EADCC00BD17FD /* gtest-test-part.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */; };

-		3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DB0E2F799B00CF7658 /* gtest-death-test.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		404884390E2F799B00CF7658 /* gtest-message.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DC0E2F799B00CF7658 /* gtest-message.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DD0E2F799B00CF7658 /* gtest-spi.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		4048843B0E2F799B00CF7658 /* gtest.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DE0E2F799B00CF7658 /* gtest.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883E00E2F799B00CF7658 /* gtest_prod.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		404884500E2F799B00CF7658 /* README in Resources */ = {isa = PBXBuildFile; fileRef = 404883F60E2F799B00CF7658 /* README */; };

-		404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */; };

-		404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E30E2F799B00CF7658 /* gtest-filepath.h */; };

-		404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E40E2F799B00CF7658 /* gtest-internal.h */; };

-		404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E50E2F799B00CF7658 /* gtest-port.h */; };

-		404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E60E2F799B00CF7658 /* gtest-string.h */; };

-		404884AC0E2F7CD900CF7658 /* CHANGES in Resources */ = {isa = PBXBuildFile; fileRef = 404884A90E2F7CD900CF7658 /* CHANGES */; };

-		404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */ = {isa = PBXBuildFile; fileRef = 404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */; };

-		404884AE0E2F7CD900CF7658 /* COPYING in Resources */ = {isa = PBXBuildFile; fileRef = 404884AB0E2F7CD900CF7658 /* COPYING */; };

-		40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };

-		40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 40899F4D0FFA7271000B29AE /* gtest-tuple.h */; };

-		40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };

-		4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };

-		4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };

-		40C848FF101A21150083642A /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };

-		40C84915101A21DF0083642A /* gtest_main.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4048840D0E2F799B00CF7658 /* gtest_main.cc */; };

-		40C84916101A235B0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };

-		40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };

-		40C84978101A36540083642A /* libgtest_main.a in Resources */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };

-		40C84980101A36850083642A /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };

-		40C84982101A36850083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };

-		40C84983101A36850083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };

-		40C8498F101A36A60083642A /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };

-		40C84990101A36A60083642A /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };

-		40C84992101A36A60083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };

-		40C84993101A36A60083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };

-		40C849A2101A37050083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };

-		40C849A4101A37150083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };

-		4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 4539C9330EC280AE00A70F4C /* gtest-param-test.h */; settings = {ATTRIBUTES = (Public, ); }; };

-		4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */; };

-		4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */; };

-		4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9370EC280E200A70F4C /* gtest-param-util.h */; };

-		4567C8181264FF71007740BE /* gtest-printers.h in Headers */ = {isa = PBXBuildFile; fileRef = 4567C8171264FF71007740BE /* gtest-printers.h */; settings = {ATTRIBUTES = (Public, ); }; };

-/* End PBXBuildFile section */

-

-/* Begin PBXContainerItemProxy section */

-		40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40899F420FFA7184000B29AE;

-			remoteInfo = gtest_unittest;

-		};

-		4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 4089A0120FFACEFC000B29AE;

-			remoteInfo = sample1_unittest;

-		};

-		408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C848F9101A209C0083642A;

-			remoteInfo = "gtest-static";

-		};

-		40C44AE50E379922008FCC51 /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C44ADC0E3798F4008FCC51;

-			remoteInfo = Version.h;

-		};

-		40C8497C101A36850083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C848F9101A209C0083642A;

-			remoteInfo = "gtest-static";

-		};

-		40C8497E101A36850083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C8490A101A217E0083642A;

-			remoteInfo = "gtest_main-static";

-		};

-		40C8498B101A36A60083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C848F9101A209C0083642A;

-			remoteInfo = "gtest-static";

-		};

-		40C8498D101A36A60083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C8490A101A217E0083642A;

-			remoteInfo = "gtest_main-static";

-		};

-		40C8499B101A36DC0083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C8490A101A217E0083642A;

-			remoteInfo = "gtest_main-static";

-		};

-		40C8499D101A36E50083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;

-			remoteInfo = "gtest-framework";

-		};

-		40C8499F101A36F10083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;

-			remoteInfo = "gtest-framework";

-		};

-		40C849F6101A43440083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C8497A101A36850083642A;

-			remoteInfo = "gtest_unittest-static";

-		};

-		40C849F8101A43490083642A /* PBXContainerItemProxy */ = {

-			isa = PBXContainerItemProxy;

-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

-			proxyType = 1;

-			remoteGlobalIDString = 40C84989101A36A60083642A;

-			remoteInfo = "sample1_unittest-static";

-		};

-/* End PBXContainerItemProxy section */

-

-/* Begin PBXCopyFilesBuildPhase section */

-		404884A50E2F7C0400CF7658 /* Copy Headers Internal */ = {

-			isa = PBXCopyFilesBuildPhase;

-			buildActionMask = 2147483647;

-			dstPath = Headers/internal;

-			dstSubfolderSpec = 6;

-			files = (

-				404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */,

-				404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */,

-				404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */,

-				4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */,

-				4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */,

-				4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */,

-				404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */,

-				404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */,

-				40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */,

-				3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */,

-			);

-			name = "Copy Headers Internal";

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXCopyFilesBuildPhase section */

-

-/* Begin PBXFileReference section */

-		224A12A10E9EADA700BD17FD /* gtest-all.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = "gtest-all.cc"; sourceTree = "<group>"; };

-		224A12A20E9EADCC00BD17FD /* gtest-test-part.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = "gtest-test-part.h"; sourceTree = "<group>"; };

-		3B238C120E7FE13C00846E11 /* gtest_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_unittest.cc; sourceTree = "<group>"; };

-		3B87D2100E96B92E000D1852 /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };

-		3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-type-util.h"; sourceTree = "<group>"; };

-		3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-typed-test.h"; sourceTree = "<group>"; };

-		403EE37C0E377822004BD1E2 /* versiongenerate.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = versiongenerate.py; sourceTree = "<group>"; };

-		404883DB0E2F799B00CF7658 /* gtest-death-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test.h"; sourceTree = "<group>"; };

-		404883DC0E2F799B00CF7658 /* gtest-message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-message.h"; sourceTree = "<group>"; };

-		404883DD0E2F799B00CF7658 /* gtest-spi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-spi.h"; sourceTree = "<group>"; };

-		404883DE0E2F799B00CF7658 /* gtest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest.h; sourceTree = "<group>"; };

-		404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_pred_impl.h; sourceTree = "<group>"; };

-		404883E00E2F799B00CF7658 /* gtest_prod.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_prod.h; sourceTree = "<group>"; };

-		404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test-internal.h"; sourceTree = "<group>"; };

-		404883E30E2F799B00CF7658 /* gtest-filepath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-filepath.h"; sourceTree = "<group>"; };

-		404883E40E2F799B00CF7658 /* gtest-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-internal.h"; sourceTree = "<group>"; };

-		404883E50E2F799B00CF7658 /* gtest-port.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-port.h"; sourceTree = "<group>"; };

-		404883E60E2F799B00CF7658 /* gtest-string.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-string.h"; sourceTree = "<group>"; };

-		404883F60E2F799B00CF7658 /* README */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = README; path = ../README; sourceTree = SOURCE_ROOT; };

-		4048840D0E2F799B00CF7658 /* gtest_main.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_main.cc; sourceTree = "<group>"; };

-		404884A90E2F7CD900CF7658 /* CHANGES */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CHANGES; path = ../CHANGES; sourceTree = SOURCE_ROOT; };

-		404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CONTRIBUTORS; path = ../CONTRIBUTORS; sourceTree = SOURCE_ROOT; };

-		404884AB0E2F7CD900CF7658 /* COPYING */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = COPYING; path = ../COPYING; sourceTree = SOURCE_ROOT; };

-		40899F430FFA7184000B29AE /* gtest_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "gtest_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };

-		40899F4D0FFA7271000B29AE /* gtest-tuple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-tuple.h"; sourceTree = "<group>"; };

-		40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = StaticLibraryTarget.xcconfig; sourceTree = "<group>"; };

-		4089A0130FFACEFC000B29AE /* sample1_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };

-		4089A02C0FFACF7F000B29AE /* sample1.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1.cc; sourceTree = "<group>"; };

-		4089A02D0FFACF7F000B29AE /* sample1.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sample1.h; sourceTree = "<group>"; };

-		4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1_unittest.cc; sourceTree = "<group>"; };

-		40C848FA101A209C0083642A /* libgtest.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest.a; sourceTree = BUILT_PRODUCTS_DIR; };

-		40C8490B101A217E0083642A /* libgtest_main.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest_main.a; sourceTree = BUILT_PRODUCTS_DIR; };

-		40C84987101A36850083642A /* gtest_unittest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = gtest_unittest; sourceTree = BUILT_PRODUCTS_DIR; };

-		40C84997101A36A60083642A /* sample1_unittest-static */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-static"; sourceTree = BUILT_PRODUCTS_DIR; };

-		40D4CDF10E30E07400294801 /* DebugProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = DebugProject.xcconfig; sourceTree = "<group>"; };

-		40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = FrameworkTarget.xcconfig; sourceTree = "<group>"; };

-		40D4CDF30E30E07400294801 /* General.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = General.xcconfig; sourceTree = "<group>"; };

-		40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = ReleaseProject.xcconfig; sourceTree = "<group>"; };

-		40D4CF510E30F5E200294801 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };

-		4539C8FF0EC27F6400A70F4C /* gtest.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = gtest.framework; sourceTree = BUILT_PRODUCTS_DIR; };

-		4539C9330EC280AE00A70F4C /* gtest-param-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-test.h"; sourceTree = "<group>"; };

-		4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-linked_ptr.h"; sourceTree = "<group>"; };

-		4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util-generated.h"; sourceTree = "<group>"; };

-		4539C9370EC280E200A70F4C /* gtest-param-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util.h"; sourceTree = "<group>"; };

-		4567C8171264FF71007740BE /* gtest-printers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-printers.h"; sourceTree = "<group>"; };

-/* End PBXFileReference section */

-

-/* Begin PBXFrameworksBuildPhase section */

-		40899F410FFA7184000B29AE /* Frameworks */ = {

-			isa = PBXFrameworksBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40C849A4101A37150083642A /* gtest.framework in Frameworks */,

-				40C84916101A235B0083642A /* libgtest_main.a in Frameworks */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		4089A0110FFACEFC000B29AE /* Frameworks */ = {

-			isa = PBXFrameworksBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40C849A2101A37050083642A /* gtest.framework in Frameworks */,

-				40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		40C84981101A36850083642A /* Frameworks */ = {

-			isa = PBXFrameworksBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40C84982101A36850083642A /* libgtest.a in Frameworks */,

-				40C84983101A36850083642A /* libgtest_main.a in Frameworks */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		40C84991101A36A60083642A /* Frameworks */ = {

-			isa = PBXFrameworksBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40C84992101A36A60083642A /* libgtest.a in Frameworks */,

-				40C84993101A36A60083642A /* libgtest_main.a in Frameworks */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXFrameworksBuildPhase section */

-

-/* Begin PBXGroup section */

-		034768DDFF38A45A11DB9C8B /* Products */ = {

-			isa = PBXGroup;

-			children = (

-				4539C8FF0EC27F6400A70F4C /* gtest.framework */,

-				40C848FA101A209C0083642A /* libgtest.a */,

-				40C8490B101A217E0083642A /* libgtest_main.a */,

-				40899F430FFA7184000B29AE /* gtest_unittest-framework */,

-				40C84987101A36850083642A /* gtest_unittest */,

-				4089A0130FFACEFC000B29AE /* sample1_unittest-framework */,

-				40C84997101A36A60083642A /* sample1_unittest-static */,

-			);

-			name = Products;

-			sourceTree = "<group>";

-		};

-		0867D691FE84028FC02AAC07 /* gtest */ = {

-			isa = PBXGroup;

-			children = (

-				40D4CDF00E30E07400294801 /* Config */,

-				08FB77ACFE841707C02AAC07 /* Source */,

-				40D4CF4E0E30F5E200294801 /* Resources */,

-				403EE37B0E377822004BD1E2 /* Scripts */,

-				034768DDFF38A45A11DB9C8B /* Products */,

-			);

-			name = gtest;

-			sourceTree = "<group>";

-		};

-		08FB77ACFE841707C02AAC07 /* Source */ = {

-			isa = PBXGroup;

-			children = (

-				404884A90E2F7CD900CF7658 /* CHANGES */,

-				404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */,

-				404884AB0E2F7CD900CF7658 /* COPYING */,

-				404883F60E2F799B00CF7658 /* README */,

-				404883D90E2F799B00CF7658 /* include */,

-				4089A02F0FFACF84000B29AE /* samples */,

-				404884070E2F799B00CF7658 /* src */,

-				3B238BF00E7FE13B00846E11 /* test */,

-			);

-			name = Source;

-			sourceTree = "<group>";

-		};

-		3B238BF00E7FE13B00846E11 /* test */ = {

-			isa = PBXGroup;

-			children = (

-				3B238C120E7FE13C00846E11 /* gtest_unittest.cc */,

-			);

-			name = test;

-			path = ../test;

-			sourceTree = SOURCE_ROOT;

-		};

-		403EE37B0E377822004BD1E2 /* Scripts */ = {

-			isa = PBXGroup;

-			children = (

-				403EE37C0E377822004BD1E2 /* versiongenerate.py */,

-				3B87D2100E96B92E000D1852 /* runtests.sh */,

-			);

-			path = Scripts;

-			sourceTree = "<group>";

-		};

-		404883D90E2F799B00CF7658 /* include */ = {

-			isa = PBXGroup;

-			children = (

-				404883DA0E2F799B00CF7658 /* gtest */,

-			);

-			name = include;

-			path = ../include;

-			sourceTree = SOURCE_ROOT;

-		};

-		404883DA0E2F799B00CF7658 /* gtest */ = {

-			isa = PBXGroup;

-			children = (

-				404883E10E2F799B00CF7658 /* internal */,

-				224A12A20E9EADCC00BD17FD /* gtest-test-part.h */,

-				404883DB0E2F799B00CF7658 /* gtest-death-test.h */,

-				404883DC0E2F799B00CF7658 /* gtest-message.h */,

-				4539C9330EC280AE00A70F4C /* gtest-param-test.h */,

-				4567C8171264FF71007740BE /* gtest-printers.h */,

-				404883DD0E2F799B00CF7658 /* gtest-spi.h */,

-				404883DE0E2F799B00CF7658 /* gtest.h */,

-				404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */,

-				404883E00E2F799B00CF7658 /* gtest_prod.h */,

-				3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */,

-			);

-			path = gtest;

-			sourceTree = "<group>";

-		};

-		404883E10E2F799B00CF7658 /* internal */ = {

-			isa = PBXGroup;

-			children = (

-				404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */,

-				404883E30E2F799B00CF7658 /* gtest-filepath.h */,

-				404883E40E2F799B00CF7658 /* gtest-internal.h */,

-				4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */,

-				4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */,

-				4539C9370EC280E200A70F4C /* gtest-param-util.h */,

-				404883E50E2F799B00CF7658 /* gtest-port.h */,

-				404883E60E2F799B00CF7658 /* gtest-string.h */,

-				40899F4D0FFA7271000B29AE /* gtest-tuple.h */,

-				3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */,

-			);

-			path = internal;

-			sourceTree = "<group>";

-		};

-		404884070E2F799B00CF7658 /* src */ = {

-			isa = PBXGroup;

-			children = (

-				224A12A10E9EADA700BD17FD /* gtest-all.cc */,

-				4048840D0E2F799B00CF7658 /* gtest_main.cc */,

-			);

-			name = src;

-			path = ../src;

-			sourceTree = SOURCE_ROOT;

-		};

-		4089A02F0FFACF84000B29AE /* samples */ = {

-			isa = PBXGroup;

-			children = (

-				4089A02C0FFACF7F000B29AE /* sample1.cc */,

-				4089A02D0FFACF7F000B29AE /* sample1.h */,

-				4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */,

-			);

-			name = samples;

-			path = ../samples;

-			sourceTree = SOURCE_ROOT;

-		};

-		40D4CDF00E30E07400294801 /* Config */ = {

-			isa = PBXGroup;

-			children = (

-				40D4CDF10E30E07400294801 /* DebugProject.xcconfig */,

-				40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */,

-				40D4CDF30E30E07400294801 /* General.xcconfig */,

-				40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */,

-				40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */,

-			);

-			path = Config;

-			sourceTree = "<group>";

-		};

-		40D4CF4E0E30F5E200294801 /* Resources */ = {

-			isa = PBXGroup;

-			children = (

-				40D4CF510E30F5E200294801 /* Info.plist */,

-			);

-			path = Resources;

-			sourceTree = "<group>";

-		};

-/* End PBXGroup section */

-

-/* Begin PBXHeadersBuildPhase section */

-		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {

-			isa = PBXHeadersBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */,

-				404884390E2F799B00CF7658 /* gtest-message.h in Headers */,

-				4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */,

-				4567C8181264FF71007740BE /* gtest-printers.h in Headers */,

-				3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */,

-				4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */,

-				4048843B0E2F799B00CF7658 /* gtest.h in Headers */,

-				4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */,

-				4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */,

-				224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXHeadersBuildPhase section */

-

-/* Begin PBXNativeTarget section */

-		40899F420FFA7184000B29AE /* gtest_unittest-framework */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */;

-			buildPhases = (

-				40899F400FFA7184000B29AE /* Sources */,

-				40899F410FFA7184000B29AE /* Frameworks */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-				40C849A0101A36F10083642A /* PBXTargetDependency */,

-			);

-			name = "gtest_unittest-framework";

-			productName = gtest_unittest;

-			productReference = 40899F430FFA7184000B29AE /* gtest_unittest-framework */;

-			productType = "com.apple.product-type.tool";

-		};

-		4089A0120FFACEFC000B29AE /* sample1_unittest-framework */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */;

-			buildPhases = (

-				4089A0100FFACEFC000B29AE /* Sources */,

-				4089A0110FFACEFC000B29AE /* Frameworks */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-				40C8499E101A36E50083642A /* PBXTargetDependency */,

-			);

-			name = "sample1_unittest-framework";

-			productName = sample1_unittest;

-			productReference = 4089A0130FFACEFC000B29AE /* sample1_unittest-framework */;

-			productType = "com.apple.product-type.tool";

-		};

-		40C848F9101A209C0083642A /* gtest-static */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */;

-			buildPhases = (

-				40C848F7101A209C0083642A /* Sources */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-			);

-			name = "gtest-static";

-			productName = "gtest-static";

-			productReference = 40C848FA101A209C0083642A /* libgtest.a */;

-			productType = "com.apple.product-type.library.static";

-		};

-		40C8490A101A217E0083642A /* gtest_main-static */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */;

-			buildPhases = (

-				40C84908101A217E0083642A /* Sources */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-			);

-			name = "gtest_main-static";

-			productName = "gtest_main-static";

-			productReference = 40C8490B101A217E0083642A /* libgtest_main.a */;

-			productType = "com.apple.product-type.library.static";

-		};

-		40C8497A101A36850083642A /* gtest_unittest-static */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */;

-			buildPhases = (

-				40C8497F101A36850083642A /* Sources */,

-				40C84981101A36850083642A /* Frameworks */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-				40C8497B101A36850083642A /* PBXTargetDependency */,

-				40C8497D101A36850083642A /* PBXTargetDependency */,

-			);

-			name = "gtest_unittest-static";

-			productName = gtest_unittest;

-			productReference = 40C84987101A36850083642A /* gtest_unittest */;

-			productType = "com.apple.product-type.tool";

-		};

-		40C84989101A36A60083642A /* sample1_unittest-static */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */;

-			buildPhases = (

-				40C8498E101A36A60083642A /* Sources */,

-				40C84991101A36A60083642A /* Frameworks */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-				40C8498A101A36A60083642A /* PBXTargetDependency */,

-				40C8498C101A36A60083642A /* PBXTargetDependency */,

-			);

-			name = "sample1_unittest-static";

-			productName = sample1_unittest;

-			productReference = 40C84997101A36A60083642A /* sample1_unittest-static */;

-			productType = "com.apple.product-type.tool";

-		};

-		8D07F2BC0486CC7A007CD1D0 /* gtest-framework */ = {

-			isa = PBXNativeTarget;

-			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */;

-			buildPhases = (

-				8D07F2C10486CC7A007CD1D0 /* Sources */,

-				8D07F2BD0486CC7A007CD1D0 /* Headers */,

-				404884A50E2F7C0400CF7658 /* Copy Headers Internal */,

-				8D07F2BF0486CC7A007CD1D0 /* Resources */,

-			);

-			buildRules = (

-			);

-			dependencies = (

-				40C44AE60E379922008FCC51 /* PBXTargetDependency */,

-				408BEC101046CFE900DEF522 /* PBXTargetDependency */,

-				40C8499C101A36DC0083642A /* PBXTargetDependency */,

-			);

-			name = "gtest-framework";

-			productInstallPath = "$(HOME)/Library/Frameworks";

-			productName = gtest;

-			productReference = 4539C8FF0EC27F6400A70F4C /* gtest.framework */;

-			productType = "com.apple.product-type.framework";

-		};

-/* End PBXNativeTarget section */

-

-/* Begin PBXProject section */

-		0867D690FE84028FC02AAC07 /* Project object */ = {

-			isa = PBXProject;

-			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */;

-			compatibilityVersion = "Xcode 2.4";

-			hasScannedForEncodings = 1;

-			knownRegions = (

-				English,

-				Japanese,

-				French,

-				German,

-				en,

-			);

-			mainGroup = 0867D691FE84028FC02AAC07 /* gtest */;

-			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;

-			projectDirPath = "";

-			projectRoot = "";

-			targets = (

-				8D07F2BC0486CC7A007CD1D0 /* gtest-framework */,

-				40C848F9101A209C0083642A /* gtest-static */,

-				40C8490A101A217E0083642A /* gtest_main-static */,

-				40899F420FFA7184000B29AE /* gtest_unittest-framework */,

-				40C8497A101A36850083642A /* gtest_unittest-static */,

-				4089A0120FFACEFC000B29AE /* sample1_unittest-framework */,

-				40C84989101A36A60083642A /* sample1_unittest-static */,

-				3B238F5F0E828B5400846E11 /* Check */,

-				40C44ADC0E3798F4008FCC51 /* Version Info */,

-			);

-		};

-/* End PBXProject section */

-

-/* Begin PBXResourcesBuildPhase section */

-		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {

-			isa = PBXResourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				404884500E2F799B00CF7658 /* README in Resources */,

-				404884AC0E2F7CD900CF7658 /* CHANGES in Resources */,

-				404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */,

-				404884AE0E2F7CD900CF7658 /* COPYING in Resources */,

-				40C84978101A36540083642A /* libgtest_main.a in Resources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXResourcesBuildPhase section */

-

-/* Begin PBXShellScriptBuildPhase section */

-		3B238F5E0E828B5400846E11 /* ShellScript */ = {

-			isa = PBXShellScriptBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-			);

-			inputPaths = (

-			);

-			outputPaths = (

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-			shellPath = /bin/sh;

-			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/bin/bash Scripts/runtests.sh";

-		};

-		40C44ADB0E3798F4008FCC51 /* Generate Version.h */ = {

-			isa = PBXShellScriptBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-			);

-			inputPaths = (

-				"$(SRCROOT)/Scripts/versiongenerate.py",

-				"$(SRCROOT)/../configure.ac",

-			);

-			name = "Generate Version.h";

-			outputPaths = (

-				"$(PROJECT_TEMP_DIR)/Version.h",

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-			shellPath = /bin/sh;

-			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/usr/bin/python Scripts/versiongenerate.py ../ $PROJECT_TEMP_DIR";

-		};

-/* End PBXShellScriptBuildPhase section */

-

-/* Begin PBXSourcesBuildPhase section */

-		40899F400FFA7184000B29AE /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		4089A0100FFACEFC000B29AE /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */,

-				4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		40C848F7101A209C0083642A /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40C848FF101A21150083642A /* gtest-all.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		40C84908101A217E0083642A /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40C84915101A21DF0083642A /* gtest_main.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		40C8497F101A36850083642A /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40C84980101A36850083642A /* gtest_unittest.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		40C8498E101A36A60083642A /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40C8498F101A36A60083642A /* sample1.cc in Sources */,

-				40C84990101A36A60083642A /* sample1_unittest.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-		8D07F2C10486CC7A007CD1D0 /* Sources */ = {

-			isa = PBXSourcesBuildPhase;

-			buildActionMask = 2147483647;

-			files = (

-				40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */,

-			);

-			runOnlyForDeploymentPostprocessing = 0;

-		};

-/* End PBXSourcesBuildPhase section */

-

-/* Begin PBXTargetDependency section */

-		40899F9D0FFA740F000B29AE /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40899F420FFA7184000B29AE /* gtest_unittest-framework */;

-			targetProxy = 40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */;

-		};

-		4089A0980FFAD34A000B29AE /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 4089A0120FFACEFC000B29AE /* sample1_unittest-framework */;

-			targetProxy = 4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */;

-		};

-		408BEC101046CFE900DEF522 /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C848F9101A209C0083642A /* gtest-static */;

-			targetProxy = 408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */;

-		};

-		40C44AE60E379922008FCC51 /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C44ADC0E3798F4008FCC51 /* Version Info */;

-			targetProxy = 40C44AE50E379922008FCC51 /* PBXContainerItemProxy */;

-		};

-		40C8497B101A36850083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C848F9101A209C0083642A /* gtest-static */;

-			targetProxy = 40C8497C101A36850083642A /* PBXContainerItemProxy */;

-		};

-		40C8497D101A36850083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C8490A101A217E0083642A /* gtest_main-static */;

-			targetProxy = 40C8497E101A36850083642A /* PBXContainerItemProxy */;

-		};

-		40C8498A101A36A60083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C848F9101A209C0083642A /* gtest-static */;

-			targetProxy = 40C8498B101A36A60083642A /* PBXContainerItemProxy */;

-		};

-		40C8498C101A36A60083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C8490A101A217E0083642A /* gtest_main-static */;

-			targetProxy = 40C8498D101A36A60083642A /* PBXContainerItemProxy */;

-		};

-		40C8499C101A36DC0083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C8490A101A217E0083642A /* gtest_main-static */;

-			targetProxy = 40C8499B101A36DC0083642A /* PBXContainerItemProxy */;

-		};

-		40C8499E101A36E50083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;

-			targetProxy = 40C8499D101A36E50083642A /* PBXContainerItemProxy */;

-		};

-		40C849A0101A36F10083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;

-			targetProxy = 40C8499F101A36F10083642A /* PBXContainerItemProxy */;

-		};

-		40C849F7101A43440083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C8497A101A36850083642A /* gtest_unittest-static */;

-			targetProxy = 40C849F6101A43440083642A /* PBXContainerItemProxy */;

-		};

-		40C849F9101A43490083642A /* PBXTargetDependency */ = {

-			isa = PBXTargetDependency;

-			target = 40C84989101A36A60083642A /* sample1_unittest-static */;

-			targetProxy = 40C849F8101A43490083642A /* PBXContainerItemProxy */;

-		};

-/* End PBXTargetDependency section */

-

-/* Begin XCBuildConfiguration section */

-		3B238F600E828B5400846E11 /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				COPY_PHASE_STRIP = NO;

-				GCC_DYNAMIC_NO_PIC = NO;

-				GCC_OPTIMIZATION_LEVEL = 0;

-				PRODUCT_NAME = Check;

-			};

-			name = Debug;

-		};

-		3B238F610E828B5400846E11 /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				COPY_PHASE_STRIP = YES;

-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";

-				GCC_ENABLE_FIX_AND_CONTINUE = NO;

-				PRODUCT_NAME = Check;

-				ZERO_LINK = NO;

-			};

-			name = Release;

-		};

-		40899F450FFA7185000B29AE /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				HEADER_SEARCH_PATHS = ../;

-				PRODUCT_NAME = "gtest_unittest-framework";

-			};

-			name = Debug;

-		};

-		40899F460FFA7185000B29AE /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				HEADER_SEARCH_PATHS = ../;

-				PRODUCT_NAME = "gtest_unittest-framework";

-			};

-			name = Release;

-		};

-		4089A0150FFACEFD000B29AE /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = "sample1_unittest-framework";

-			};

-			name = Debug;

-		};

-		4089A0160FFACEFD000B29AE /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = "sample1_unittest-framework";

-			};

-			name = Release;

-		};

-		40C44ADF0E3798F4008FCC51 /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = gtest;

-				TARGET_NAME = gtest;

-			};

-			name = Debug;

-		};

-		40C44AE00E3798F4008FCC51 /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = gtest;

-				TARGET_NAME = gtest;

-			};

-			name = Release;

-		};

-		40C848FB101A209D0083642A /* Debug */ = {

-			isa = XCBuildConfiguration;

-			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;

-			buildSettings = {

-				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;

-				GCC_SYMBOLS_PRIVATE_EXTERN = YES;

-				HEADER_SEARCH_PATHS = (

-					../,

-					../include/,

-				);

-				PRODUCT_NAME = gtest;

-			};

-			name = Debug;

-		};

-		40C848FC101A209D0083642A /* Release */ = {

-			isa = XCBuildConfiguration;

-			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;

-			buildSettings = {

-				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;

-				GCC_SYMBOLS_PRIVATE_EXTERN = YES;

-				HEADER_SEARCH_PATHS = (

-					../,

-					../include/,

-				);

-				PRODUCT_NAME = gtest;

-			};

-			name = Release;

-		};

-		40C8490E101A217F0083642A /* Debug */ = {

-			isa = XCBuildConfiguration;

-			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;

-			buildSettings = {

-				HEADER_SEARCH_PATHS = (

-					../,

-					../include/,

-				);

-				PRODUCT_NAME = gtest_main;

-			};

-			name = Debug;

-		};

-		40C8490F101A217F0083642A /* Release */ = {

-			isa = XCBuildConfiguration;

-			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;

-			buildSettings = {

-				HEADER_SEARCH_PATHS = (

-					../,

-					../include/,

-				);

-				PRODUCT_NAME = gtest_main;

-			};

-			name = Release;

-		};

-		40C84985101A36850083642A /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				HEADER_SEARCH_PATHS = ../;

-				PRODUCT_NAME = gtest_unittest;

-			};

-			name = Debug;

-		};

-		40C84986101A36850083642A /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				HEADER_SEARCH_PATHS = ../;

-				PRODUCT_NAME = gtest_unittest;

-			};

-			name = Release;

-		};

-		40C84995101A36A60083642A /* Debug */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = "sample1_unittest-static";

-			};

-			name = Debug;

-		};

-		40C84996101A36A60083642A /* Release */ = {

-			isa = XCBuildConfiguration;

-			buildSettings = {

-				PRODUCT_NAME = "sample1_unittest-static";

-			};

-			name = Release;

-		};

-		4FADC24308B4156D00ABE55E /* Debug */ = {

-			isa = XCBuildConfiguration;

-			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;

-			buildSettings = {

-				DYLIB_COMPATIBILITY_VERSION = 1;

-				DYLIB_CURRENT_VERSION = 1;

-				HEADER_SEARCH_PATHS = (

-					../,

-					../include/,

-				);

-				INFOPLIST_FILE = Resources/Info.plist;

-				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";

-				INFOPLIST_PREPROCESS = YES;

-				PRODUCT_NAME = gtest;

-				VERSIONING_SYSTEM = "apple-generic";

-			};

-			name = Debug;

-		};

-		4FADC24408B4156D00ABE55E /* Release */ = {

-			isa = XCBuildConfiguration;

-			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;

-			buildSettings = {

-				DYLIB_COMPATIBILITY_VERSION = 1;

-				DYLIB_CURRENT_VERSION = 1;

-				HEADER_SEARCH_PATHS = (

-					../,

-					../include/,

-				);

-				INFOPLIST_FILE = Resources/Info.plist;

-				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";

-				INFOPLIST_PREPROCESS = YES;

-				PRODUCT_NAME = gtest;

-				VERSIONING_SYSTEM = "apple-generic";

-			};

-			name = Release;

-		};

-		4FADC24708B4156D00ABE55E /* Debug */ = {

-			isa = XCBuildConfiguration;

-			baseConfigurationReference = 40D4CDF10E30E07400294801 /* DebugProject.xcconfig */;

-			buildSettings = {

-			};

-			name = Debug;

-		};

-		4FADC24808B4156D00ABE55E /* Release */ = {

-			isa = XCBuildConfiguration;

-			baseConfigurationReference = 40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */;

-			buildSettings = {

-			};

-			name = Release;

-		};

-/* End XCBuildConfiguration section */

-

-/* Begin XCConfigurationList section */

-		3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				3B238F600E828B5400846E11 /* Debug */,

-				3B238F610E828B5400846E11 /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				40899F450FFA7185000B29AE /* Debug */,

-				40899F460FFA7185000B29AE /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				4089A0150FFACEFD000B29AE /* Debug */,

-				4089A0160FFACEFD000B29AE /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				40C44ADF0E3798F4008FCC51 /* Debug */,

-				40C44AE00E3798F4008FCC51 /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				40C848FB101A209D0083642A /* Debug */,

-				40C848FC101A209D0083642A /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				40C8490E101A217F0083642A /* Debug */,

-				40C8490F101A217F0083642A /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				40C84985101A36850083642A /* Debug */,

-				40C84986101A36850083642A /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				40C84995101A36A60083642A /* Debug */,

-				40C84996101A36A60083642A /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				4FADC24308B4156D00ABE55E /* Debug */,

-				4FADC24408B4156D00ABE55E /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */ = {

-			isa = XCConfigurationList;

-			buildConfigurations = (

-				4FADC24708B4156D00ABE55E /* Debug */,

-				4FADC24808B4156D00ABE55E /* Release */,

-			);

-			defaultConfigurationIsVisible = 0;

-			defaultConfigurationName = Release;

-		};

-/* End XCConfigurationList section */

-	};

-	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;

-}

+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 42;
+	objects = {
+
+/* Begin PBXAggregateTarget section */
+		3B238F5F0E828B5400846E11 /* Check */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */;
+			buildPhases = (
+				3B238F5E0E828B5400846E11 /* ShellScript */,
+			);
+			dependencies = (
+				40899F9D0FFA740F000B29AE /* PBXTargetDependency */,
+				40C849F7101A43440083642A /* PBXTargetDependency */,
+				4089A0980FFAD34A000B29AE /* PBXTargetDependency */,
+				40C849F9101A43490083642A /* PBXTargetDependency */,
+			);
+			name = Check;
+			productName = Check;
+		};
+		40C44ADC0E3798F4008FCC51 /* Version Info */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */;
+			buildPhases = (
+				40C44ADB0E3798F4008FCC51 /* Generate Version.h */,
+			);
+			comments = "The generation of Version.h must be performed in its own target. Since the Info.plist is preprocessed before any of the other build phases in gtest, the Version.h file would not be ready if included as a build phase of that target.";
+			dependencies = (
+			);
+			name = "Version Info";
+			productName = Version.h;
+		};
+/* End PBXAggregateTarget section */
+
+/* Begin PBXBuildFile section */
+		224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */ = {isa = PBXBuildFile; fileRef = 224A12A20E9EADCC00BD17FD /* gtest-test-part.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */; };
+		3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DB0E2F799B00CF7658 /* gtest-death-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		404884390E2F799B00CF7658 /* gtest-message.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DC0E2F799B00CF7658 /* gtest-message.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DD0E2F799B00CF7658 /* gtest-spi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4048843B0E2F799B00CF7658 /* gtest.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DE0E2F799B00CF7658 /* gtest.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883E00E2F799B00CF7658 /* gtest_prod.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		404884500E2F799B00CF7658 /* README in Resources */ = {isa = PBXBuildFile; fileRef = 404883F60E2F799B00CF7658 /* README */; };
+		404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */; };
+		404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E30E2F799B00CF7658 /* gtest-filepath.h */; };
+		404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E40E2F799B00CF7658 /* gtest-internal.h */; };
+		404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E50E2F799B00CF7658 /* gtest-port.h */; };
+		404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E60E2F799B00CF7658 /* gtest-string.h */; };
+		404884AC0E2F7CD900CF7658 /* CHANGES in Resources */ = {isa = PBXBuildFile; fileRef = 404884A90E2F7CD900CF7658 /* CHANGES */; };
+		404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */ = {isa = PBXBuildFile; fileRef = 404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */; };
+		404884AE0E2F7CD900CF7658 /* COPYING in Resources */ = {isa = PBXBuildFile; fileRef = 404884AB0E2F7CD900CF7658 /* COPYING */; };
+		40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };
+		40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 40899F4D0FFA7271000B29AE /* gtest-tuple.h */; };
+		40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };
+		4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };
+		4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };
+		40C848FF101A21150083642A /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };
+		40C84915101A21DF0083642A /* gtest_main.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4048840D0E2F799B00CF7658 /* gtest_main.cc */; };
+		40C84916101A235B0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C84978101A36540083642A /* libgtest_main.a in Resources */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C84980101A36850083642A /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };
+		40C84982101A36850083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };
+		40C84983101A36850083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C8498F101A36A60083642A /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };
+		40C84990101A36A60083642A /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };
+		40C84992101A36A60083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };
+		40C84993101A36A60083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C849A2101A37050083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };
+		40C849A4101A37150083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };
+		4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 4539C9330EC280AE00A70F4C /* gtest-param-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */; };
+		4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */; };
+		4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9370EC280E200A70F4C /* gtest-param-util.h */; };
+		4567C8181264FF71007740BE /* gtest-printers.h in Headers */ = {isa = PBXBuildFile; fileRef = 4567C8171264FF71007740BE /* gtest-printers.h */; settings = {ATTRIBUTES = (Public, ); }; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40899F420FFA7184000B29AE;
+			remoteInfo = gtest_unittest;
+		};
+		4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 4089A0120FFACEFC000B29AE;
+			remoteInfo = sample1_unittest;
+		};
+		408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C848F9101A209C0083642A;
+			remoteInfo = "gtest-static";
+		};
+		40C44AE50E379922008FCC51 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C44ADC0E3798F4008FCC51;
+			remoteInfo = Version.h;
+		};
+		40C8497C101A36850083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C848F9101A209C0083642A;
+			remoteInfo = "gtest-static";
+		};
+		40C8497E101A36850083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C8490A101A217E0083642A;
+			remoteInfo = "gtest_main-static";
+		};
+		40C8498B101A36A60083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C848F9101A209C0083642A;
+			remoteInfo = "gtest-static";
+		};
+		40C8498D101A36A60083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C8490A101A217E0083642A;
+			remoteInfo = "gtest_main-static";
+		};
+		40C8499B101A36DC0083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C8490A101A217E0083642A;
+			remoteInfo = "gtest_main-static";
+		};
+		40C8499D101A36E50083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
+			remoteInfo = "gtest-framework";
+		};
+		40C8499F101A36F10083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
+			remoteInfo = "gtest-framework";
+		};
+		40C849F6101A43440083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C8497A101A36850083642A;
+			remoteInfo = "gtest_unittest-static";
+		};
+		40C849F8101A43490083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C84989101A36A60083642A;
+			remoteInfo = "sample1_unittest-static";
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		404884A50E2F7C0400CF7658 /* Copy Headers Internal */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = Headers/internal;
+			dstSubfolderSpec = 6;
+			files = (
+				404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */,
+				404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */,
+				404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */,
+				4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */,
+				4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */,
+				4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */,
+				404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */,
+				404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */,
+				40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */,
+				3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */,
+			);
+			name = "Copy Headers Internal";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		224A12A10E9EADA700BD17FD /* gtest-all.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = "gtest-all.cc"; sourceTree = "<group>"; };
+		224A12A20E9EADCC00BD17FD /* gtest-test-part.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = "gtest-test-part.h"; sourceTree = "<group>"; };
+		3B238C120E7FE13C00846E11 /* gtest_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_unittest.cc; sourceTree = "<group>"; };
+		3B87D2100E96B92E000D1852 /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };
+		3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-type-util.h"; sourceTree = "<group>"; };
+		3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-typed-test.h"; sourceTree = "<group>"; };
+		403EE37C0E377822004BD1E2 /* versiongenerate.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = versiongenerate.py; sourceTree = "<group>"; };
+		404883DB0E2F799B00CF7658 /* gtest-death-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test.h"; sourceTree = "<group>"; };
+		404883DC0E2F799B00CF7658 /* gtest-message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-message.h"; sourceTree = "<group>"; };
+		404883DD0E2F799B00CF7658 /* gtest-spi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-spi.h"; sourceTree = "<group>"; };
+		404883DE0E2F799B00CF7658 /* gtest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest.h; sourceTree = "<group>"; };
+		404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_pred_impl.h; sourceTree = "<group>"; };
+		404883E00E2F799B00CF7658 /* gtest_prod.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_prod.h; sourceTree = "<group>"; };
+		404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test-internal.h"; sourceTree = "<group>"; };
+		404883E30E2F799B00CF7658 /* gtest-filepath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-filepath.h"; sourceTree = "<group>"; };
+		404883E40E2F799B00CF7658 /* gtest-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-internal.h"; sourceTree = "<group>"; };
+		404883E50E2F799B00CF7658 /* gtest-port.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-port.h"; sourceTree = "<group>"; };
+		404883E60E2F799B00CF7658 /* gtest-string.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-string.h"; sourceTree = "<group>"; };
+		404883F60E2F799B00CF7658 /* README */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = README; path = ../README; sourceTree = SOURCE_ROOT; };
+		4048840D0E2F799B00CF7658 /* gtest_main.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_main.cc; sourceTree = "<group>"; };
+		404884A90E2F7CD900CF7658 /* CHANGES */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CHANGES; path = ../CHANGES; sourceTree = SOURCE_ROOT; };
+		404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CONTRIBUTORS; path = ../CONTRIBUTORS; sourceTree = SOURCE_ROOT; };
+		404884AB0E2F7CD900CF7658 /* COPYING */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = COPYING; path = ../COPYING; sourceTree = SOURCE_ROOT; };
+		40899F430FFA7184000B29AE /* gtest_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "gtest_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };
+		40899F4D0FFA7271000B29AE /* gtest-tuple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-tuple.h"; sourceTree = "<group>"; };
+		40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = StaticLibraryTarget.xcconfig; sourceTree = "<group>"; };
+		4089A0130FFACEFC000B29AE /* sample1_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };
+		4089A02C0FFACF7F000B29AE /* sample1.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1.cc; sourceTree = "<group>"; };
+		4089A02D0FFACF7F000B29AE /* sample1.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sample1.h; sourceTree = "<group>"; };
+		4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1_unittest.cc; sourceTree = "<group>"; };
+		40C848FA101A209C0083642A /* libgtest.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		40C8490B101A217E0083642A /* libgtest_main.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest_main.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		40C84987101A36850083642A /* gtest_unittest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = gtest_unittest; sourceTree = BUILT_PRODUCTS_DIR; };
+		40C84997101A36A60083642A /* sample1_unittest-static */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-static"; sourceTree = BUILT_PRODUCTS_DIR; };
+		40D4CDF10E30E07400294801 /* DebugProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = DebugProject.xcconfig; sourceTree = "<group>"; };
+		40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = FrameworkTarget.xcconfig; sourceTree = "<group>"; };
+		40D4CDF30E30E07400294801 /* General.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = General.xcconfig; sourceTree = "<group>"; };
+		40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = ReleaseProject.xcconfig; sourceTree = "<group>"; };
+		40D4CF510E30F5E200294801 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		4539C8FF0EC27F6400A70F4C /* gtest.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = gtest.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		4539C9330EC280AE00A70F4C /* gtest-param-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-test.h"; sourceTree = "<group>"; };
+		4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-linked_ptr.h"; sourceTree = "<group>"; };
+		4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util-generated.h"; sourceTree = "<group>"; };
+		4539C9370EC280E200A70F4C /* gtest-param-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util.h"; sourceTree = "<group>"; };
+		4567C8171264FF71007740BE /* gtest-printers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-printers.h"; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		40899F410FFA7184000B29AE /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C849A4101A37150083642A /* gtest.framework in Frameworks */,
+				40C84916101A235B0083642A /* libgtest_main.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		4089A0110FFACEFC000B29AE /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C849A2101A37050083642A /* gtest.framework in Frameworks */,
+				40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C84981101A36850083642A /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C84982101A36850083642A /* libgtest.a in Frameworks */,
+				40C84983101A36850083642A /* libgtest_main.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C84991101A36A60083642A /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C84992101A36A60083642A /* libgtest.a in Frameworks */,
+				40C84993101A36A60083642A /* libgtest_main.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		034768DDFF38A45A11DB9C8B /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				4539C8FF0EC27F6400A70F4C /* gtest.framework */,
+				40C848FA101A209C0083642A /* libgtest.a */,
+				40C8490B101A217E0083642A /* libgtest_main.a */,
+				40899F430FFA7184000B29AE /* gtest_unittest-framework */,
+				40C84987101A36850083642A /* gtest_unittest */,
+				4089A0130FFACEFC000B29AE /* sample1_unittest-framework */,
+				40C84997101A36A60083642A /* sample1_unittest-static */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		0867D691FE84028FC02AAC07 /* gtest */ = {
+			isa = PBXGroup;
+			children = (
+				40D4CDF00E30E07400294801 /* Config */,
+				08FB77ACFE841707C02AAC07 /* Source */,
+				40D4CF4E0E30F5E200294801 /* Resources */,
+				403EE37B0E377822004BD1E2 /* Scripts */,
+				034768DDFF38A45A11DB9C8B /* Products */,
+			);
+			name = gtest;
+			sourceTree = "<group>";
+		};
+		08FB77ACFE841707C02AAC07 /* Source */ = {
+			isa = PBXGroup;
+			children = (
+				404884A90E2F7CD900CF7658 /* CHANGES */,
+				404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */,
+				404884AB0E2F7CD900CF7658 /* COPYING */,
+				404883F60E2F799B00CF7658 /* README */,
+				404883D90E2F799B00CF7658 /* include */,
+				4089A02F0FFACF84000B29AE /* samples */,
+				404884070E2F799B00CF7658 /* src */,
+				3B238BF00E7FE13B00846E11 /* test */,
+			);
+			name = Source;
+			sourceTree = "<group>";
+		};
+		3B238BF00E7FE13B00846E11 /* test */ = {
+			isa = PBXGroup;
+			children = (
+				3B238C120E7FE13C00846E11 /* gtest_unittest.cc */,
+			);
+			name = test;
+			path = ../test;
+			sourceTree = SOURCE_ROOT;
+		};
+		403EE37B0E377822004BD1E2 /* Scripts */ = {
+			isa = PBXGroup;
+			children = (
+				403EE37C0E377822004BD1E2 /* versiongenerate.py */,
+				3B87D2100E96B92E000D1852 /* runtests.sh */,
+			);
+			path = Scripts;
+			sourceTree = "<group>";
+		};
+		404883D90E2F799B00CF7658 /* include */ = {
+			isa = PBXGroup;
+			children = (
+				404883DA0E2F799B00CF7658 /* gtest */,
+			);
+			name = include;
+			path = ../include;
+			sourceTree = SOURCE_ROOT;
+		};
+		404883DA0E2F799B00CF7658 /* gtest */ = {
+			isa = PBXGroup;
+			children = (
+				404883E10E2F799B00CF7658 /* internal */,
+				224A12A20E9EADCC00BD17FD /* gtest-test-part.h */,
+				404883DB0E2F799B00CF7658 /* gtest-death-test.h */,
+				404883DC0E2F799B00CF7658 /* gtest-message.h */,
+				4539C9330EC280AE00A70F4C /* gtest-param-test.h */,
+				4567C8171264FF71007740BE /* gtest-printers.h */,
+				404883DD0E2F799B00CF7658 /* gtest-spi.h */,
+				404883DE0E2F799B00CF7658 /* gtest.h */,
+				404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */,
+				404883E00E2F799B00CF7658 /* gtest_prod.h */,
+				3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */,
+			);
+			path = gtest;
+			sourceTree = "<group>";
+		};
+		404883E10E2F799B00CF7658 /* internal */ = {
+			isa = PBXGroup;
+			children = (
+				404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */,
+				404883E30E2F799B00CF7658 /* gtest-filepath.h */,
+				404883E40E2F799B00CF7658 /* gtest-internal.h */,
+				4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */,
+				4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */,
+				4539C9370EC280E200A70F4C /* gtest-param-util.h */,
+				404883E50E2F799B00CF7658 /* gtest-port.h */,
+				404883E60E2F799B00CF7658 /* gtest-string.h */,
+				40899F4D0FFA7271000B29AE /* gtest-tuple.h */,
+				3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */,
+			);
+			path = internal;
+			sourceTree = "<group>";
+		};
+		404884070E2F799B00CF7658 /* src */ = {
+			isa = PBXGroup;
+			children = (
+				224A12A10E9EADA700BD17FD /* gtest-all.cc */,
+				4048840D0E2F799B00CF7658 /* gtest_main.cc */,
+			);
+			name = src;
+			path = ../src;
+			sourceTree = SOURCE_ROOT;
+		};
+		4089A02F0FFACF84000B29AE /* samples */ = {
+			isa = PBXGroup;
+			children = (
+				4089A02C0FFACF7F000B29AE /* sample1.cc */,
+				4089A02D0FFACF7F000B29AE /* sample1.h */,
+				4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */,
+			);
+			name = samples;
+			path = ../samples;
+			sourceTree = SOURCE_ROOT;
+		};
+		40D4CDF00E30E07400294801 /* Config */ = {
+			isa = PBXGroup;
+			children = (
+				40D4CDF10E30E07400294801 /* DebugProject.xcconfig */,
+				40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */,
+				40D4CDF30E30E07400294801 /* General.xcconfig */,
+				40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */,
+				40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */,
+			);
+			path = Config;
+			sourceTree = "<group>";
+		};
+		40D4CF4E0E30F5E200294801 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				40D4CF510E30F5E200294801 /* Info.plist */,
+			);
+			path = Resources;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */,
+				404884390E2F799B00CF7658 /* gtest-message.h in Headers */,
+				4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */,
+				4567C8181264FF71007740BE /* gtest-printers.h in Headers */,
+				3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */,
+				4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */,
+				4048843B0E2F799B00CF7658 /* gtest.h in Headers */,
+				4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */,
+				4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */,
+				224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		40899F420FFA7184000B29AE /* gtest_unittest-framework */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */;
+			buildPhases = (
+				40899F400FFA7184000B29AE /* Sources */,
+				40899F410FFA7184000B29AE /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C849A0101A36F10083642A /* PBXTargetDependency */,
+			);
+			name = "gtest_unittest-framework";
+			productName = gtest_unittest;
+			productReference = 40899F430FFA7184000B29AE /* gtest_unittest-framework */;
+			productType = "com.apple.product-type.tool";
+		};
+		4089A0120FFACEFC000B29AE /* sample1_unittest-framework */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */;
+			buildPhases = (
+				4089A0100FFACEFC000B29AE /* Sources */,
+				4089A0110FFACEFC000B29AE /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C8499E101A36E50083642A /* PBXTargetDependency */,
+			);
+			name = "sample1_unittest-framework";
+			productName = sample1_unittest;
+			productReference = 4089A0130FFACEFC000B29AE /* sample1_unittest-framework */;
+			productType = "com.apple.product-type.tool";
+		};
+		40C848F9101A209C0083642A /* gtest-static */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */;
+			buildPhases = (
+				40C848F7101A209C0083642A /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "gtest-static";
+			productName = "gtest-static";
+			productReference = 40C848FA101A209C0083642A /* libgtest.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		40C8490A101A217E0083642A /* gtest_main-static */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */;
+			buildPhases = (
+				40C84908101A217E0083642A /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "gtest_main-static";
+			productName = "gtest_main-static";
+			productReference = 40C8490B101A217E0083642A /* libgtest_main.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		40C8497A101A36850083642A /* gtest_unittest-static */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */;
+			buildPhases = (
+				40C8497F101A36850083642A /* Sources */,
+				40C84981101A36850083642A /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C8497B101A36850083642A /* PBXTargetDependency */,
+				40C8497D101A36850083642A /* PBXTargetDependency */,
+			);
+			name = "gtest_unittest-static";
+			productName = gtest_unittest;
+			productReference = 40C84987101A36850083642A /* gtest_unittest */;
+			productType = "com.apple.product-type.tool";
+		};
+		40C84989101A36A60083642A /* sample1_unittest-static */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */;
+			buildPhases = (
+				40C8498E101A36A60083642A /* Sources */,
+				40C84991101A36A60083642A /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C8498A101A36A60083642A /* PBXTargetDependency */,
+				40C8498C101A36A60083642A /* PBXTargetDependency */,
+			);
+			name = "sample1_unittest-static";
+			productName = sample1_unittest;
+			productReference = 40C84997101A36A60083642A /* sample1_unittest-static */;
+			productType = "com.apple.product-type.tool";
+		};
+		8D07F2BC0486CC7A007CD1D0 /* gtest-framework */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */;
+			buildPhases = (
+				8D07F2C10486CC7A007CD1D0 /* Sources */,
+				8D07F2BD0486CC7A007CD1D0 /* Headers */,
+				404884A50E2F7C0400CF7658 /* Copy Headers Internal */,
+				8D07F2BF0486CC7A007CD1D0 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C44AE60E379922008FCC51 /* PBXTargetDependency */,
+				408BEC101046CFE900DEF522 /* PBXTargetDependency */,
+				40C8499C101A36DC0083642A /* PBXTargetDependency */,
+			);
+			name = "gtest-framework";
+			productInstallPath = "$(HOME)/Library/Frameworks";
+			productName = gtest;
+			productReference = 4539C8FF0EC27F6400A70F4C /* gtest.framework */;
+			productType = "com.apple.product-type.framework";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		0867D690FE84028FC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */;
+			compatibilityVersion = "Xcode 2.4";
+			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+				en,
+			);
+			mainGroup = 0867D691FE84028FC02AAC07 /* gtest */;
+			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				8D07F2BC0486CC7A007CD1D0 /* gtest-framework */,
+				40C848F9101A209C0083642A /* gtest-static */,
+				40C8490A101A217E0083642A /* gtest_main-static */,
+				40899F420FFA7184000B29AE /* gtest_unittest-framework */,
+				40C8497A101A36850083642A /* gtest_unittest-static */,
+				4089A0120FFACEFC000B29AE /* sample1_unittest-framework */,
+				40C84989101A36A60083642A /* sample1_unittest-static */,
+				3B238F5F0E828B5400846E11 /* Check */,
+				40C44ADC0E3798F4008FCC51 /* Version Info */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				404884500E2F799B00CF7658 /* README in Resources */,
+				404884AC0E2F7CD900CF7658 /* CHANGES in Resources */,
+				404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */,
+				404884AE0E2F7CD900CF7658 /* COPYING in Resources */,
+				40C84978101A36540083642A /* libgtest_main.a in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		3B238F5E0E828B5400846E11 /* ShellScript */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/bin/bash Scripts/runtests.sh";
+		};
+		40C44ADB0E3798F4008FCC51 /* Generate Version.h */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+				"$(SRCROOT)/Scripts/versiongenerate.py",
+				"$(SRCROOT)/../configure.ac",
+			);
+			name = "Generate Version.h";
+			outputPaths = (
+				"$(PROJECT_TEMP_DIR)/Version.h",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/usr/bin/python Scripts/versiongenerate.py ../ $PROJECT_TEMP_DIR";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		40899F400FFA7184000B29AE /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		4089A0100FFACEFC000B29AE /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */,
+				4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C848F7101A209C0083642A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C848FF101A21150083642A /* gtest-all.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C84908101A217E0083642A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C84915101A21DF0083642A /* gtest_main.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C8497F101A36850083642A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C84980101A36850083642A /* gtest_unittest.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C8498E101A36A60083642A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C8498F101A36A60083642A /* sample1.cc in Sources */,
+				40C84990101A36A60083642A /* sample1_unittest.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		8D07F2C10486CC7A007CD1D0 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		40899F9D0FFA740F000B29AE /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40899F420FFA7184000B29AE /* gtest_unittest-framework */;
+			targetProxy = 40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */;
+		};
+		4089A0980FFAD34A000B29AE /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 4089A0120FFACEFC000B29AE /* sample1_unittest-framework */;
+			targetProxy = 4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */;
+		};
+		408BEC101046CFE900DEF522 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C848F9101A209C0083642A /* gtest-static */;
+			targetProxy = 408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */;
+		};
+		40C44AE60E379922008FCC51 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C44ADC0E3798F4008FCC51 /* Version Info */;
+			targetProxy = 40C44AE50E379922008FCC51 /* PBXContainerItemProxy */;
+		};
+		40C8497B101A36850083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C848F9101A209C0083642A /* gtest-static */;
+			targetProxy = 40C8497C101A36850083642A /* PBXContainerItemProxy */;
+		};
+		40C8497D101A36850083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C8490A101A217E0083642A /* gtest_main-static */;
+			targetProxy = 40C8497E101A36850083642A /* PBXContainerItemProxy */;
+		};
+		40C8498A101A36A60083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C848F9101A209C0083642A /* gtest-static */;
+			targetProxy = 40C8498B101A36A60083642A /* PBXContainerItemProxy */;
+		};
+		40C8498C101A36A60083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C8490A101A217E0083642A /* gtest_main-static */;
+			targetProxy = 40C8498D101A36A60083642A /* PBXContainerItemProxy */;
+		};
+		40C8499C101A36DC0083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C8490A101A217E0083642A /* gtest_main-static */;
+			targetProxy = 40C8499B101A36DC0083642A /* PBXContainerItemProxy */;
+		};
+		40C8499E101A36E50083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;
+			targetProxy = 40C8499D101A36E50083642A /* PBXContainerItemProxy */;
+		};
+		40C849A0101A36F10083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;
+			targetProxy = 40C8499F101A36F10083642A /* PBXContainerItemProxy */;
+		};
+		40C849F7101A43440083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C8497A101A36850083642A /* gtest_unittest-static */;
+			targetProxy = 40C849F6101A43440083642A /* PBXContainerItemProxy */;
+		};
+		40C849F9101A43490083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C84989101A36A60083642A /* sample1_unittest-static */;
+			targetProxy = 40C849F8101A43490083642A /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		3B238F600E828B5400846E11 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = NO;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				PRODUCT_NAME = Check;
+			};
+			name = Debug;
+		};
+		3B238F610E828B5400846E11 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_ENABLE_FIX_AND_CONTINUE = NO;
+				PRODUCT_NAME = Check;
+				ZERO_LINK = NO;
+			};
+			name = Release;
+		};
+		40899F450FFA7185000B29AE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				HEADER_SEARCH_PATHS = ../;
+				PRODUCT_NAME = "gtest_unittest-framework";
+			};
+			name = Debug;
+		};
+		40899F460FFA7185000B29AE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				HEADER_SEARCH_PATHS = ../;
+				PRODUCT_NAME = "gtest_unittest-framework";
+			};
+			name = Release;
+		};
+		4089A0150FFACEFD000B29AE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = "sample1_unittest-framework";
+			};
+			name = Debug;
+		};
+		4089A0160FFACEFD000B29AE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = "sample1_unittest-framework";
+			};
+			name = Release;
+		};
+		40C44ADF0E3798F4008FCC51 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = gtest;
+				TARGET_NAME = gtest;
+			};
+			name = Debug;
+		};
+		40C44AE00E3798F4008FCC51 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = gtest;
+				TARGET_NAME = gtest;
+			};
+			name = Release;
+		};
+		40C848FB101A209D0083642A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
+			buildSettings = {
+				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;
+				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				PRODUCT_NAME = gtest;
+			};
+			name = Debug;
+		};
+		40C848FC101A209D0083642A /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
+			buildSettings = {
+				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;
+				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				PRODUCT_NAME = gtest;
+			};
+			name = Release;
+		};
+		40C8490E101A217F0083642A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
+			buildSettings = {
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				PRODUCT_NAME = gtest_main;
+			};
+			name = Debug;
+		};
+		40C8490F101A217F0083642A /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
+			buildSettings = {
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				PRODUCT_NAME = gtest_main;
+			};
+			name = Release;
+		};
+		40C84985101A36850083642A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				HEADER_SEARCH_PATHS = ../;
+				PRODUCT_NAME = gtest_unittest;
+			};
+			name = Debug;
+		};
+		40C84986101A36850083642A /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				HEADER_SEARCH_PATHS = ../;
+				PRODUCT_NAME = gtest_unittest;
+			};
+			name = Release;
+		};
+		40C84995101A36A60083642A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = "sample1_unittest-static";
+			};
+			name = Debug;
+		};
+		40C84996101A36A60083642A /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = "sample1_unittest-static";
+			};
+			name = Release;
+		};
+		4FADC24308B4156D00ABE55E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				INFOPLIST_FILE = Resources/Info.plist;
+				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";
+				INFOPLIST_PREPROCESS = YES;
+				PRODUCT_NAME = gtest;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Debug;
+		};
+		4FADC24408B4156D00ABE55E /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				INFOPLIST_FILE = Resources/Info.plist;
+				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";
+				INFOPLIST_PREPROCESS = YES;
+				PRODUCT_NAME = gtest;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Release;
+		};
+		4FADC24708B4156D00ABE55E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40D4CDF10E30E07400294801 /* DebugProject.xcconfig */;
+			buildSettings = {
+			};
+			name = Debug;
+		};
+		4FADC24808B4156D00ABE55E /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */;
+			buildSettings = {
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				3B238F600E828B5400846E11 /* Debug */,
+				3B238F610E828B5400846E11 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40899F450FFA7185000B29AE /* Debug */,
+				40899F460FFA7185000B29AE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4089A0150FFACEFD000B29AE /* Debug */,
+				4089A0160FFACEFD000B29AE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C44ADF0E3798F4008FCC51 /* Debug */,
+				40C44AE00E3798F4008FCC51 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C848FB101A209D0083642A /* Debug */,
+				40C848FC101A209D0083642A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C8490E101A217F0083642A /* Debug */,
+				40C8490F101A217F0083642A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C84985101A36850083642A /* Debug */,
+				40C84986101A36850083642A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C84995101A36A60083642A /* Debug */,
+				40C84996101A36A60083642A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FADC24308B4156D00ABE55E /* Debug */,
+				4FADC24408B4156D00ABE55E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FADC24708B4156D00ABE55E /* Debug */,
+				4FADC24808B4156D00ABE55E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
+}
diff --git a/scripts/travis.sh b/scripts/travis.sh
index 98d14a7..b6b7975 100755
--- a/scripts/travis.sh
+++ b/scripts/travis.sh
@@ -1,15 +1,15 @@
-#!/bin/bash -e

-

-CMAKE_ARGS="-DCMAKE_BUILD_TYPE=Debug -DENTITYX_BUILD_TESTING=1"

-

-if [ "$USE_STD_SHARED_PTR" = "1" ]; then

-  CMAKE_ARGS="${CMAKE_ARGS}"

-  # This fails on OSX

-  if [ "$CXX" = "clang++" ]; then

-    CMAKE_ARGS="${CMAKE_ARGS} -DENTITYX_USE_CPP11_STDLIB=1"

-  fi

-fi

-

-cmake ${CMAKE_ARGS}

-make VERBOSE=1

-make test || cat Testing/Temporary/LastTest.log

+#!/bin/bash -e
+
+CMAKE_ARGS="-DCMAKE_BUILD_TYPE=Debug -DENTITYX_BUILD_TESTING=1"
+
+if [ "$USE_STD_SHARED_PTR" = "1" ]; then
+  CMAKE_ARGS="${CMAKE_ARGS}"
+  # This fails on OSX
+  if [ "$CXX" = "clang++" ]; then
+    CMAKE_ARGS="${CMAKE_ARGS} -DENTITYX_USE_CPP11_STDLIB=1"
+  fi
+fi
+
+cmake ${CMAKE_ARGS}
+make VERBOSE=1
+make test || cat Testing/Temporary/LastTest.log