[Mesa-dev] gtest: Update to 1.7.0.

Submitted by Vinson Lee on April 1, 2014, 4:33 p.m.

Details

Message ID 1396369983-16713-1-git-send-email-vlee@freedesktop.org
State New
Headers show

Not browsing as part of any series.

Commit Message

Vinson Lee April 1, 2014, 4:33 p.m.
This patch fixes gtest build errors on Mac OS X 10.9.

Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=73106
Signed-off-by: Vinson Lee <vlee@freedesktop.org>
---
 src/gtest/include/gtest/gtest-death-test.h         |   17 +-
 src/gtest/include/gtest/gtest-message.h            |   74 +-
 src/gtest/include/gtest/gtest-param-test.h         |    2 +-
 src/gtest/include/gtest/gtest-param-test.h.pump    |    2 +-
 src/gtest/include/gtest/gtest-printers.h           |   91 +-
 src/gtest/include/gtest/gtest-spi.h                |    2 +-
 src/gtest/include/gtest/gtest-test-part.h          |   17 +-
 src/gtest/include/gtest/gtest.h                    |  304 +++--
 src/gtest/include/gtest/gtest_pred_impl.h          |   12 +-
 .../gtest/internal/gtest-death-test-internal.h     |   21 +-
 src/gtest/include/gtest/internal/gtest-filepath.h  |   14 +-
 src/gtest/include/gtest/internal/gtest-internal.h  |  182 +--
 .../include/gtest/internal/gtest-linked_ptr.h      |    8 +-
 .../gtest/internal/gtest-param-util-generated.h    |  593 +++++++---
 .../internal/gtest-param-util-generated.h.pump     |    2 +-
 .../include/gtest/internal/gtest-param-util.h      |    8 +-
 src/gtest/include/gtest/internal/gtest-port.h      |  274 ++++-
 src/gtest/include/gtest/internal/gtest-string.h    |  217 +---
 src/gtest/include/gtest/internal/gtest-tuple.h     |   92 +-
 .../include/gtest/internal/gtest-tuple.h.pump      |   13 +-
 src/gtest/include/gtest/internal/gtest-type-util.h |   21 +-
 .../include/gtest/internal/gtest-type-util.h.pump  |   21 +-
 src/gtest/src/gtest-death-test.cc                  |  280 +++--
 src/gtest/src/gtest-filepath.cc                    |   30 +-
 src/gtest/src/gtest-internal-inl.h                 |  242 +++-
 src/gtest/src/gtest-port.cc                        |  119 +-
 src/gtest/src/gtest-printers.cc                    |  101 +-
 src/gtest/src/gtest-test-part.cc                   |    6 +-
 src/gtest/src/gtest-typed-test.cc                  |    6 +-
 src/gtest/src/gtest.cc                             | 1241 +++++++++++---------
 src/gtest/src/gtest_main.cc                        |    5 +-
 31 files changed, 2509 insertions(+), 1508 deletions(-)

Patch hide | download patch | download mbox

diff --git a/src/gtest/include/gtest/gtest-death-test.h b/src/gtest/include/gtest/gtest-death-test.h
index a27883f..957a69c 100644
--- a/src/gtest/include/gtest/gtest-death-test.h
+++ b/src/gtest/include/gtest/gtest-death-test.h
@@ -51,6 +51,17 @@  GTEST_DECLARE_string_(death_test_style);
 
 #if GTEST_HAS_DEATH_TEST
 
+namespace internal {
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+GTEST_API_ bool InDeathTestChild();
+
+}  // namespace internal
+
 // The following macros are useful for writing death tests.
 
 // Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
@@ -75,7 +86,7 @@  GTEST_DECLARE_string_(death_test_style);
 //   for (int i = 0; i < 5; i++) {
 //     EXPECT_DEATH(server.ProcessRequest(i),
 //                  "Invalid request .* in ProcessRequest()")
-//         << "Failed to die on request " << i);
+//                  << "Failed to die on request " << i;
 //   }
 //
 //   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
@@ -245,10 +256,10 @@  class GTEST_API_ KilledBySignal {
 # ifdef NDEBUG
 
 #  define EXPECT_DEBUG_DEATH(statement, regex) \
-  do { statement; } while (::testing::internal::AlwaysFalse())
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
 
 #  define ASSERT_DEBUG_DEATH(statement, regex) \
-  do { statement; } while (::testing::internal::AlwaysFalse())
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
 
 # else
 
diff --git a/src/gtest/include/gtest/gtest-message.h b/src/gtest/include/gtest/gtest-message.h
index 9b7142f..fe879bc 100644
--- a/src/gtest/include/gtest/gtest-message.h
+++ b/src/gtest/include/gtest/gtest-message.h
@@ -48,8 +48,11 @@ 
 
 #include <limits>
 
-#include "gtest/internal/gtest-string.h"
-#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+
+// Ensures that there is at least one operator<< in the global namespace.
+// See Message& operator<<(...) below for why.
+void operator<<(const testing::internal::Secret&, int);
 
 namespace testing {
 
@@ -87,15 +90,7 @@  class GTEST_API_ Message {
 
  public:
   // Constructs an empty Message.
-  // We allocate the stringstream separately because otherwise each use of
-  // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
-  // stack frame leading to huge stack frames in some cases; gcc does not reuse
-  // the stack space.
-  Message() : ss_(new ::std::stringstream) {
-    // By default, we want there to be enough precision when printing
-    // a double to a Message.
-    *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
-  }
+  Message();
 
   // Copy constructor.
   Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
@@ -118,7 +113,22 @@  class GTEST_API_ Message {
   // Streams a non-pointer value to this object.
   template <typename T>
   inline Message& operator <<(const T& val) {
-    ::GTestStreamToHelper(ss_.get(), val);
+    // Some libraries overload << for STL containers.  These
+    // overloads are defined in the global namespace instead of ::std.
+    //
+    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
+    // overloads are visible in either the std namespace or the global
+    // namespace, but not other namespaces, including the testing
+    // namespace which Google Test's Message class is in.
+    //
+    // To allow STL containers (and other types that has a << operator
+    // defined in the global namespace) to be used in Google Test
+    // assertions, testing::Message must access the custom << operator
+    // from the global namespace.  With this using declaration,
+    // overloads of << defined in the global namespace and those
+    // visible via Koenig lookup are both exposed in this function.
+    using ::operator <<;
+    *ss_ << val;
     return *this;
   }
 
@@ -140,7 +150,7 @@  class GTEST_API_ Message {
     if (pointer == NULL) {
       *ss_ << "(null)";
     } else {
-      ::GTestStreamToHelper(ss_.get(), pointer);
+      *ss_ << pointer;
     }
     return *this;
   }
@@ -164,12 +174,8 @@  class GTEST_API_ Message {
 
   // These two overloads allow streaming a wide C string to a Message
   // using the UTF-8 encoding.
-  Message& operator <<(const wchar_t* wide_c_str) {
-    return *this << internal::String::ShowWideCString(wide_c_str);
-  }
-  Message& operator <<(wchar_t* wide_c_str) {
-    return *this << internal::String::ShowWideCString(wide_c_str);
-  }
+  Message& operator <<(const wchar_t* wide_c_str);
+  Message& operator <<(wchar_t* wide_c_str);
 
 #if GTEST_HAS_STD_WSTRING
   // Converts the given wide string to a narrow string using the UTF-8
@@ -183,13 +189,11 @@  class GTEST_API_ Message {
   Message& operator <<(const ::wstring& wstr);
 #endif  // GTEST_HAS_GLOBAL_WSTRING
 
-  // Gets the text streamed to this object so far as a String.
+  // Gets the text streamed to this object so far as an std::string.
   // Each '\0' character in the buffer is replaced with "\\0".
   //
   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  internal::String GetString() const {
-    return internal::StringStreamToString(ss_.get());
-  }
+  std::string GetString() const;
 
  private:
 
@@ -199,16 +203,20 @@  class GTEST_API_ Message {
   // decide between class template specializations for T and T*, so a
   // tr1::type_traits-like is_pointer works, and we can overload on that.
   template <typename T>
-  inline void StreamHelper(internal::true_type /*dummy*/, T* pointer) {
+  inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
     if (pointer == NULL) {
       *ss_ << "(null)";
     } else {
-      ::GTestStreamToHelper(ss_.get(), pointer);
+      *ss_ << pointer;
     }
   }
   template <typename T>
-  inline void StreamHelper(internal::false_type /*dummy*/, const T& value) {
-    ::GTestStreamToHelper(ss_.get(), value);
+  inline void StreamHelper(internal::false_type /*is_pointer*/,
+                           const T& value) {
+    // See the comments in Message& operator <<(const T&) above for why
+    // we need this using statement.
+    using ::operator <<;
+    *ss_ << value;
   }
 #endif  // GTEST_OS_SYMBIAN
 
@@ -225,6 +233,18 @@  inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
   return os << sb.GetString();
 }
 
+namespace internal {
+
+// Converts a streamable value to an std::string.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+template <typename T>
+std::string StreamableToString(const T& streamable) {
+  return (Message() << streamable).GetString();
+}
+
+}  // namespace internal
 }  // namespace testing
 
 #endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
diff --git a/src/gtest/include/gtest/gtest-param-test.h b/src/gtest/include/gtest/gtest-param-test.h
index 6407cfd..d6702c8 100644
--- a/src/gtest/include/gtest/gtest-param-test.h
+++ b/src/gtest/include/gtest/gtest-param-test.h
@@ -1257,7 +1257,7 @@  inline internal::ParamGenerator<bool> Bool() {
 // Boolean flags:
 //
 // class FlagDependentTest
-//     : public testing::TestWithParam<tuple(bool, bool)> > {
+//     : public testing::TestWithParam<tuple<bool, bool> > {
 //   virtual void SetUp() {
 //     // Assigns external_flag_1 and external_flag_2 values from the tuple.
 //     tie(external_flag_1, external_flag_2) = GetParam();
diff --git a/src/gtest/include/gtest/gtest-param-test.h.pump b/src/gtest/include/gtest/gtest-param-test.h.pump
index 401cb51..2dc9303 100644
--- a/src/gtest/include/gtest/gtest-param-test.h.pump
+++ b/src/gtest/include/gtest/gtest-param-test.h.pump
@@ -414,7 +414,7 @@  inline internal::ParamGenerator<bool> Bool() {
 // Boolean flags:
 //
 // class FlagDependentTest
-//     : public testing::TestWithParam<tuple(bool, bool)> > {
+//     : public testing::TestWithParam<tuple<bool, bool> > {
 //   virtual void SetUp() {
 //     // Assigns external_flag_1 and external_flag_2 values from the tuple.
 //     tie(external_flag_1, external_flag_2) = GetParam();
diff --git a/src/gtest/include/gtest/gtest-printers.h b/src/gtest/include/gtest/gtest-printers.h
index 9cbab3f..0639d9f 100644
--- a/src/gtest/include/gtest/gtest-printers.h
+++ b/src/gtest/include/gtest/gtest-printers.h
@@ -630,9 +630,12 @@  void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
   }
 }
 // This overload prints a (const) char array compactly.
-GTEST_API_ void UniversalPrintArray(const char* begin,
-                                    size_t len,
-                                    ::std::ostream* os);
+GTEST_API_ void UniversalPrintArray(
+    const char* begin, size_t len, ::std::ostream* os);
+
+// This overload prints a (const) wchar_t array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const wchar_t* begin, size_t len, ::std::ostream* os);
 
 // Implements printing an array type T[N].
 template <typename T, size_t N>
@@ -673,19 +676,72 @@  class UniversalPrinter<T&> {
 // Prints a value tersely: for a reference type, the referenced value
 // (but not the address) is printed; for a (const) char pointer, the
 // NUL-terminated string (but not the pointer) is printed.
+
 template <typename T>
-void UniversalTersePrint(const T& value, ::std::ostream* os) {
-  UniversalPrint(value, os);
-}
-inline void UniversalTersePrint(const char* str, ::std::ostream* os) {
-  if (str == NULL) {
-    *os << "NULL";
-  } else {
-    UniversalPrint(string(str), os);
+class UniversalTersePrinter {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
   }
-}
-inline void UniversalTersePrint(char* str, ::std::ostream* os) {
-  UniversalTersePrint(static_cast<const char*>(str), os);
+};
+template <typename T>
+class UniversalTersePrinter<T&> {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T, size_t N>
+class UniversalTersePrinter<T[N]> {
+ public:
+  static void Print(const T (&value)[N], ::std::ostream* os) {
+    UniversalPrinter<T[N]>::Print(value, os);
+  }
+};
+template <>
+class UniversalTersePrinter<const char*> {
+ public:
+  static void Print(const char* str, ::std::ostream* os) {
+    if (str == NULL) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char*> {
+ public:
+  static void Print(char* str, ::std::ostream* os) {
+    UniversalTersePrinter<const char*>::Print(str, os);
+  }
+};
+
+#if GTEST_HAS_STD_WSTRING
+template <>
+class UniversalTersePrinter<const wchar_t*> {
+ public:
+  static void Print(const wchar_t* str, ::std::ostream* os) {
+    if (str == NULL) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::wstring(str), os);
+    }
+  }
+};
+#endif
+
+template <>
+class UniversalTersePrinter<wchar_t*> {
+ public:
+  static void Print(wchar_t* str, ::std::ostream* os) {
+    UniversalTersePrinter<const wchar_t*>::Print(str, os);
+  }
+};
+
+template <typename T>
+void UniversalTersePrint(const T& value, ::std::ostream* os) {
+  UniversalTersePrinter<T>::Print(value, os);
 }
 
 // Prints a value using the type inferred by the compiler.  The
@@ -694,7 +750,10 @@  inline void UniversalTersePrint(char* str, ::std::ostream* os) {
 // NUL-terminated string.
 template <typename T>
 void UniversalPrint(const T& value, ::std::ostream* os) {
-  UniversalPrinter<T>::Print(value, os);
+  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
+  // UniversalPrinter with T directly.
+  typedef T T1;
+  UniversalPrinter<T1>::Print(value, os);
 }
 
 #if GTEST_HAS_TR1_TUPLE
@@ -787,7 +846,7 @@  Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
 template <typename T>
 ::std::string PrintToString(const T& value) {
   ::std::stringstream ss;
-  internal::UniversalTersePrint(value, &ss);
+  internal::UniversalTersePrinter<T>::Print(value, &ss);
   return ss.str();
 }
 
diff --git a/src/gtest/include/gtest/gtest-spi.h b/src/gtest/include/gtest/gtest-spi.h
index b226e55..f63fa9a 100644
--- a/src/gtest/include/gtest/gtest-spi.h
+++ b/src/gtest/include/gtest/gtest-spi.h
@@ -223,7 +223,7 @@  class GTEST_API_ SingleFailureChecker {
         (substr));\
     {\
       ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS,\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
           &gtest_failures);\
       if (::testing::internal::AlwaysTrue()) { statement; }\
     }\
diff --git a/src/gtest/include/gtest/gtest-test-part.h b/src/gtest/include/gtest/gtest-test-part.h
index 8aeea14..77eb844 100644
--- a/src/gtest/include/gtest/gtest-test-part.h
+++ b/src/gtest/include/gtest/gtest-test-part.h
@@ -62,7 +62,7 @@  class GTEST_API_ TestPartResult {
                  int a_line_number,
                  const char* a_message)
       : type_(a_type),
-        file_name_(a_file_name),
+        file_name_(a_file_name == NULL ? "" : a_file_name),
         line_number_(a_line_number),
         summary_(ExtractSummary(a_message)),
         message_(a_message) {
@@ -73,7 +73,9 @@  class GTEST_API_ TestPartResult {
 
   // Gets the name of the source file where the test part took place, or
   // NULL if it's unknown.
-  const char* file_name() const { return file_name_.c_str(); }
+  const char* file_name() const {
+    return file_name_.empty() ? NULL : file_name_.c_str();
+  }
 
   // Gets the line in the source file where the test part took place,
   // or -1 if it's unknown.
@@ -96,21 +98,22 @@  class GTEST_API_ TestPartResult {
 
   // Returns true iff the test part fatally failed.
   bool fatally_failed() const { return type_ == kFatalFailure; }
+
  private:
   Type type_;
 
   // Gets the summary of the failure message by omitting the stack
   // trace in it.
-  static internal::String ExtractSummary(const char* message);
+  static std::string ExtractSummary(const char* message);
 
   // The name of the source file where the test part took place, or
-  // NULL if the source file is unknown.
-  internal::String file_name_;
+  // "" if the source file is unknown.
+  std::string file_name_;
   // The line in the source file where the test part took place, or -1
   // if the line number is unknown.
   int line_number_;
-  internal::String summary_;  // The test failure summary.
-  internal::String message_;  // The test failure message.
+  std::string summary_;  // The test failure summary.
+  std::string message_;  // The test failure message.
 };
 
 // Prints a TestPartResult object.
diff --git a/src/gtest/include/gtest/gtest.h b/src/gtest/include/gtest/gtest.h
index cd01c7b..6fa0a39 100644
--- a/src/gtest/include/gtest/gtest.h
+++ b/src/gtest/include/gtest/gtest.h
@@ -52,6 +52,7 @@ 
 #define GTEST_INCLUDE_GTEST_GTEST_H_
 
 #include <limits>
+#include <ostream>
 #include <vector>
 
 #include "gtest/internal/gtest-internal.h"
@@ -153,25 +154,15 @@  class ExecDeathTest;
 class NoExecDeathTest;
 class FinalSuccessChecker;
 class GTestFlagSaver;
+class StreamingListenerTest;
 class TestResultAccessor;
 class TestEventListenersAccessor;
 class TestEventRepeater;
+class UnitTestRecordPropertyTestHelper;
 class WindowsDeathTest;
 class UnitTestImpl* GetUnitTestImpl();
 void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
-                                    const String& message);
-
-// Converts a streamable value to a String.  A NULL pointer is
-// converted to "(null)".  When the input value is a ::string,
-// ::std::string, ::wstring, or ::std::wstring object, each NUL
-// character in it is replaced with "\\0".
-// Declared in gtest-internal.h but defined here, so that it has access
-// to the definition of the Message class, required by the ARM
-// compiler.
-template <typename T>
-String StreamableToString(const T& streamable) {
-  return (Message() << streamable).GetString();
-}
+                                    const std::string& message);
 
 }  // namespace internal
 
@@ -391,20 +382,21 @@  class GTEST_API_ Test {
   // non-fatal) failure.
   static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
 
-  // Logs a property for the current test.  Only the last value for a given
-  // key is remembered.
-  // These are public static so they can be called from utility functions
-  // that are not members of the test fixture.
-  // The arguments are const char* instead strings, as Google Test is used
-  // on platforms where string doesn't compile.
-  //
-  // Note that a driving consideration for these RecordProperty methods
-  // was to produce xml output suited to the Greenspan charting utility,
-  // which at present will only chart values that fit in a 32-bit int. It
-  // is the user's responsibility to restrict their values to 32-bit ints
-  // if they intend them to be used with Greenspan.
-  static void RecordProperty(const char* key, const char* value);
-  static void RecordProperty(const char* key, int value);
+  // Logs a property for the current test, test case, or for the entire
+  // invocation of the test program when used outside of the context of a
+  // test case.  Only the last value for a given key is remembered.  These
+  // are public static so they can be called from utility functions that are
+  // not members of the test fixture.  Calls to RecordProperty made during
+  // lifespan of the test (from the moment its constructor starts to the
+  // moment its destructor finishes) will be output in XML as attributes of
+  // the <testcase> element.  Properties recorded from fixture's
+  // SetUpTestCase or TearDownTestCase are logged as attributes of the
+  // corresponding <testsuite> element.  Calls to RecordProperty made in the
+  // global context (before or after invocation of RUN_ALL_TESTS and from
+  // SetUp/TearDown method of Environment objects registered with Google
+  // Test) will be output as attributes of the <testsuites> element.
+  static void RecordProperty(const std::string& key, const std::string& value);
+  static void RecordProperty(const std::string& key, int value);
 
  protected:
   // Creates a Test object.
@@ -473,7 +465,7 @@  class TestProperty {
   // C'tor.  TestProperty does NOT have a default constructor.
   // Always use this constructor (with parameters) to create a
   // TestProperty object.
-  TestProperty(const char* a_key, const char* a_value) :
+  TestProperty(const std::string& a_key, const std::string& a_value) :
     key_(a_key), value_(a_value) {
   }
 
@@ -488,15 +480,15 @@  class TestProperty {
   }
 
   // Sets a new value, overriding the one supplied in the constructor.
-  void SetValue(const char* new_value) {
+  void SetValue(const std::string& new_value) {
     value_ = new_value;
   }
 
  private:
   // The key supplied by the user.
-  internal::String key_;
+  std::string key_;
   // The value supplied by the user.
-  internal::String value_;
+  std::string value_;
 };
 
 // The result of a single Test.  This includes a list of
@@ -547,6 +539,7 @@  class GTEST_API_ TestResult {
 
  private:
   friend class TestInfo;
+  friend class TestCase;
   friend class UnitTest;
   friend class internal::DefaultGlobalTestPartResultReporter;
   friend class internal::ExecDeathTest;
@@ -571,13 +564,16 @@  class GTEST_API_ TestResult {
   // a non-fatal failure if invalid (e.g., if it conflicts with reserved
   // key names). If a property is already recorded for the same key, the
   // value will be updated, rather than storing multiple values for the same
-  // key.
-  void RecordProperty(const TestProperty& test_property);
+  // key.  xml_element specifies the element for which the property is being
+  // recorded and is used for validation.
+  void RecordProperty(const std::string& xml_element,
+                      const TestProperty& test_property);
 
   // Adds a failure if the key is a reserved attribute of Google Test
   // testcase tags.  Returns true if the property is valid.
   // TODO(russr): Validate attribute names are legal and human readable.
-  static bool ValidateTestProperty(const TestProperty& test_property);
+  static bool ValidateTestProperty(const std::string& xml_element,
+                                   const TestProperty& test_property);
 
   // Adds a test part result to the list.
   void AddTestPartResult(const TestPartResult& test_part_result);
@@ -650,9 +646,9 @@  class GTEST_API_ TestInfo {
     return NULL;
   }
 
-  // Returns true if this test should run, that is if the test is not disabled
-  // (or it is disabled but the also_run_disabled_tests flag has been specified)
-  // and its full name matches the user-specified filter.
+  // Returns true if this test should run, that is if the test is not
+  // disabled (or it is disabled but the also_run_disabled_tests flag has
+  // been specified) and its full name matches the user-specified filter.
   //
   // Google Test allows the user to filter the tests by their full names.
   // The full name of a test Bar in test case Foo is defined as
@@ -668,19 +664,28 @@  class GTEST_API_ TestInfo {
   // contains the character 'A' or starts with "Foo.".
   bool should_run() const { return should_run_; }
 
+  // Returns true iff this test will appear in the XML report.
+  bool is_reportable() const {
+    // For now, the XML report includes all tests matching the filter.
+    // In the future, we may trim tests that are excluded because of
+    // sharding.
+    return matches_filter_;
+  }
+
   // Returns the result of the test.
   const TestResult* result() const { return &result_; }
 
  private:
-
 #if GTEST_HAS_DEATH_TEST
   friend class internal::DefaultDeathTestFactory;
 #endif  // GTEST_HAS_DEATH_TEST
   friend class Test;
   friend class TestCase;
   friend class internal::UnitTestImpl;
+  friend class internal::StreamingListenerTest;
   friend TestInfo* internal::MakeAndRegisterTestInfo(
-      const char* test_case_name, const char* name,
+      const char* test_case_name,
+      const char* name,
       const char* type_param,
       const char* value_param,
       internal::TypeId fixture_class_id,
@@ -690,9 +695,10 @@  class GTEST_API_ TestInfo {
 
   // Constructs a TestInfo object. The newly constructed instance assumes
   // ownership of the factory object.
-  TestInfo(const char* test_case_name, const char* name,
-           const char* a_type_param,
-           const char* a_value_param,
+  TestInfo(const std::string& test_case_name,
+           const std::string& name,
+           const char* a_type_param,   // NULL if not a type-parameterized test
+           const char* a_value_param,  // NULL if not a value-parameterized test
            internal::TypeId fixture_class_id,
            internal::TestFactoryBase* factory);
 
@@ -778,9 +784,15 @@  class GTEST_API_ TestCase {
   // Gets the number of failed tests in this test case.
   int failed_test_count() const;
 
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
   // Gets the number of disabled tests in this test case.
   int disabled_test_count() const;
 
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
   // Get the number of tests in this test case that should run.
   int test_to_run_count() const;
 
@@ -800,6 +812,10 @@  class GTEST_API_ TestCase {
   // total_test_count() - 1. If i is not in that range, returns NULL.
   const TestInfo* GetTestInfo(int i) const;
 
+  // Returns the TestResult that holds test properties recorded during
+  // execution of SetUpTestCase and TearDownTestCase.
+  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
+
  private:
   friend class Test;
   friend class internal::UnitTestImpl;
@@ -852,11 +868,22 @@  class GTEST_API_ TestCase {
     return test_info->should_run() && test_info->result()->Failed();
   }
 
+  // Returns true iff the test is disabled and will be reported in the XML
+  // report.
+  static bool TestReportableDisabled(const TestInfo* test_info) {
+    return test_info->is_reportable() && test_info->is_disabled_;
+  }
+
   // Returns true iff test is disabled.
   static bool TestDisabled(const TestInfo* test_info) {
     return test_info->is_disabled_;
   }
 
+  // Returns true iff this test will appear in the XML report.
+  static bool TestReportable(const TestInfo* test_info) {
+    return test_info->is_reportable();
+  }
+
   // Returns true if the given test should run.
   static bool ShouldRunTest(const TestInfo* test_info) {
     return test_info->should_run();
@@ -869,7 +896,7 @@  class GTEST_API_ TestCase {
   void UnshuffleTests();
 
   // Name of the test case.
-  internal::String name_;
+  std::string name_;
   // Name of the parameter type, or NULL if this is not a typed or a
   // type-parameterized test.
   const internal::scoped_ptr<const ::std::string> type_param_;
@@ -888,6 +915,9 @@  class GTEST_API_ TestCase {
   bool should_run_;
   // Elapsed time, in milliseconds.
   TimeInMillis elapsed_time_;
+  // Holds test properties recorded during execution of SetUpTestCase and
+  // TearDownTestCase.
+  TestResult ad_hoc_test_result_;
 
   // We disallow copying TestCases.
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
@@ -1107,11 +1137,13 @@  class GTEST_API_ UnitTest {
 
   // Returns the TestCase object for the test that's currently running,
   // or NULL if no test is running.
-  const TestCase* current_test_case() const;
+  const TestCase* current_test_case() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Returns the TestInfo object for the test that's currently running,
   // or NULL if no test is running.
-  const TestInfo* current_test_info() const;
+  const TestInfo* current_test_info() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Returns the random seed used at the start of the current test run.
   int random_seed() const;
@@ -1121,7 +1153,8 @@  class GTEST_API_ UnitTest {
   // value-parameterized tests and instantiate and register them.
   //
   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  internal::ParameterizedTestCaseRegistry& parameterized_test_registry();
+  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
+      GTEST_LOCK_EXCLUDED_(mutex_);
 #endif  // GTEST_HAS_PARAM_TEST
 
   // Gets the number of successful test cases.
@@ -1143,15 +1176,25 @@  class GTEST_API_ UnitTest {
   // Gets the number of failed tests.
   int failed_test_count() const;
 
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
   // Gets the number of disabled tests.
   int disabled_test_count() const;
 
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
   // Gets the number of all tests.
   int total_test_count() const;
 
   // Gets the number of tests that should run.
   int test_to_run_count() const;
 
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const;
+
   // Gets the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const;
 
@@ -1166,6 +1209,10 @@  class GTEST_API_ UnitTest {
   // total_test_case_count() - 1. If i is not in that range, returns NULL.
   const TestCase* GetTestCase(int i) const;
 
+  // Returns the TestResult containing information on test failures and
+  // properties logged outside of individual test cases.
+  const TestResult& ad_hoc_test_result() const;
+
   // Returns the list of event listeners that can be used to track events
   // inside Google Test.
   TestEventListeners& listeners();
@@ -1189,12 +1236,16 @@  class GTEST_API_ UnitTest {
   void AddTestPartResult(TestPartResult::Type result_type,
                          const char* file_name,
                          int line_number,
-                         const internal::String& message,
-                         const internal::String& os_stack_trace);
+                         const std::string& message,
+                         const std::string& os_stack_trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
 
-  // Adds a TestProperty to the current TestResult object. If the result already
-  // contains a property with the same key, the value will be updated.
-  void RecordPropertyForCurrentTest(const char* key, const char* value);
+  // Adds a TestProperty to the current TestResult object when invoked from
+  // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
+  // from SetUpTestCase or TearDownTestCase, or to the global property set
+  // when invoked elsewhere.  If the result already contains a property with
+  // the same key, the value will be updated.
+  void RecordProperty(const std::string& key, const std::string& value);
 
   // Gets the i-th test case among all the test cases. i can range from 0 to
   // total_test_case_count() - 1. If i is not in that range, returns NULL.
@@ -1209,11 +1260,13 @@  class GTEST_API_ UnitTest {
   friend class Test;
   friend class internal::AssertHelper;
   friend class internal::ScopedTrace;
+  friend class internal::StreamingListenerTest;
+  friend class internal::UnitTestRecordPropertyTestHelper;
   friend Environment* AddGlobalTestEnvironment(Environment* env);
   friend internal::UnitTestImpl* internal::GetUnitTestImpl();
   friend void internal::ReportFailureInUnknownLocation(
       TestPartResult::Type result_type,
-      const internal::String& message);
+      const std::string& message);
 
   // Creates an empty UnitTest.
   UnitTest();
@@ -1223,10 +1276,12 @@  class GTEST_API_ UnitTest {
 
   // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
   // Google Test trace stack.
-  void PushGTestTrace(const internal::TraceInfo& trace);
+  void PushGTestTrace(const internal::TraceInfo& trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Pops a trace from the per-thread Google Test trace stack.
-  void PopGTestTrace();
+  void PopGTestTrace()
+      GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Protects mutable state in *impl_.  This is mutable as some const
   // methods need to lock it too.
@@ -1281,24 +1336,101 @@  GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
 
 namespace internal {
 
+// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
+// value of type ToPrint that is an operand of a comparison assertion
+// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
+// the comparison, and is used to help determine the best way to
+// format the value.  In particular, when the value is a C string
+// (char pointer) and the other operand is an STL string object, we
+// want to format the C string as a string, since we know it is
+// compared by value with the string object.  If the value is a char
+// pointer but the other operand is not an STL string object, we don't
+// know whether the pointer is supposed to point to a NUL-terminated
+// string, and thus want to print it as a pointer to be safe.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// The default case.
+template <typename ToPrint, typename OtherOperand>
+class FormatForComparison {
+ public:
+  static ::std::string Format(const ToPrint& value) {
+    return ::testing::PrintToString(value);
+  }
+};
+
+// Array.
+template <typename ToPrint, size_t N, typename OtherOperand>
+class FormatForComparison<ToPrint[N], OtherOperand> {
+ public:
+  static ::std::string Format(const ToPrint* value) {
+    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
+  }
+};
+
+// By default, print C string as pointers to be safe, as we don't know
+// whether they actually point to a NUL-terminated string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
+  template <typename OtherOperand>                                      \
+  class FormatForComparison<CharType*, OtherOperand> {                  \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(static_cast<const void*>(value)); \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
+
+// If a C string is compared with an STL string object, we know it's meant
+// to point to a NUL-terminated string, and thus can print it as a string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
+  template <>                                                           \
+  class FormatForComparison<CharType*, OtherStringType> {               \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(value);                           \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
+
+#if GTEST_HAS_GLOBAL_STRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
+#endif
+
+#if GTEST_HAS_GLOBAL_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
+#endif
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
+#endif
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
+
 // Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
 // operand to be used in a failure message.  The type (but not value)
 // of the other operand may affect the format.  This allows us to
 // print a char* as a raw pointer when it is compared against another
-// char*, and print it as a C string when it is compared against an
-// std::string object, for example.
-//
-// The default implementation ignores the type of the other operand.
-// Some specialized versions are used to handle formatting wide or
-// narrow C strings.
+// char* or void*, and print it as a C string when it is compared
+// against an std::string object, for example.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 template <typename T1, typename T2>
-String FormatForComparisonFailureMessage(const T1& value,
-                                         const T2& /* other_operand */) {
-  // C++Builder compiles this incorrectly if the namespace isn't explicitly
-  // given.
-  return ::testing::PrintToString(value);
+std::string FormatForComparisonFailureMessage(
+    const T1& value, const T2& /* other_operand */) {
+  return FormatForComparison<T1, T2>::Format(value);
 }
 
 // The helper function for {ASSERT|EXPECT}_EQ.
@@ -1310,7 +1442,7 @@  AssertionResult CmpHelperEQ(const char* expected_expression,
 #ifdef _MSC_VER
 # pragma warning(push)          // Saves the current warning state.
 # pragma warning(disable:4389)  // Temporarily disables warning on
-                               // signed/unsigned mismatch.
+                                // signed/unsigned mismatch.
 #endif
 
   if (expected == actual) {
@@ -1446,11 +1578,11 @@  GTEST_IMPL_CMP_HELPER_(NE, !=);
 // Implements the helper function for {ASSERT|EXPECT}_LE
 GTEST_IMPL_CMP_HELPER_(LE, <=);
 // Implements the helper function for {ASSERT|EXPECT}_LT
-GTEST_IMPL_CMP_HELPER_(LT, < );
+GTEST_IMPL_CMP_HELPER_(LT, <);
 // Implements the helper function for {ASSERT|EXPECT}_GE
 GTEST_IMPL_CMP_HELPER_(GE, >=);
 // Implements the helper function for {ASSERT|EXPECT}_GT
-GTEST_IMPL_CMP_HELPER_(GT, > );
+GTEST_IMPL_CMP_HELPER_(GT, >);
 
 #undef GTEST_IMPL_CMP_HELPER_
 
@@ -1614,9 +1746,9 @@  class GTEST_API_ AssertHelper {
         : type(t), file(srcfile), line(line_num), message(msg) { }
 
     TestPartResult::Type const type;
-    const char*        const file;
-    int                const line;
-    String             const message;
+    const char* const file;
+    int const line;
+    std::string const message;
 
    private:
     GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
@@ -1675,7 +1807,12 @@  class WithParamInterface {
   // references static data, to reduce the opportunity for incorrect uses
   // like writing 'WithParamInterface<bool>::GetParam()' for a test that
   // uses a fixture whose parameter type is int.
-  const ParamType& GetParam() const { return *parameter_; }
+  const ParamType& GetParam() const {
+    GTEST_CHECK_(parameter_ != NULL)
+        << "GetParam() can only be called inside a value-parameterized test "
+        << "-- did you intend to write TEST_P instead of TEST_F?";
+    return *parameter_;
+  }
 
  private:
   // Sets parameter value. The caller is responsible for making sure the value
@@ -1721,12 +1858,6 @@  class TestWithParam : public Test, public WithParamInterface<T> {
 // usually want the fail-fast behavior of FAIL and ASSERT_*, but those
 // writing data-driven tests often find themselves using ADD_FAILURE
 // and EXPECT_* more.
-//
-// Examples:
-//
-//   EXPECT_TRUE(server.StatusIsOK());
-//   ASSERT_FALSE(server.HasPendingRequest(port))
-//       << "There are still pending requests " << "on port " << port;
 
 // Generates a nonfatal failure with a generic message.
 #define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
@@ -1900,7 +2031,7 @@  class TestWithParam : public Test, public WithParamInterface<T> {
 # define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
 #endif
 
-// C String Comparisons.  All tests treat NULL and any non-NULL string
+// C-string Comparisons.  All tests treat NULL and any non-NULL string
 // as different.  Two NULLs are equal.
 //
 //    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
@@ -2141,15 +2272,20 @@  bool StaticAssertTypeEq() {
   GTEST_TEST_(test_fixture, test_name, test_fixture, \
               ::testing::internal::GetTypeId<test_fixture>())
 
-// Use this macro in main() to run all tests.  It returns 0 if all
+}  // namespace testing
+
+// Use this function in main() to run all tests.  It returns 0 if all
 // tests are successful, or 1 otherwise.
 //
 // RUN_ALL_TESTS() should be invoked after the command line has been
 // parsed by InitGoogleTest().
+//
+// This function was formerly a macro; thus, it is in the global
+// namespace and has an all-caps name.
+int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
 
-#define RUN_ALL_TESTS()\
-  (::testing::UnitTest::GetInstance()->Run())
-
-}  // namespace testing
+inline int RUN_ALL_TESTS() {
+  return ::testing::UnitTest::GetInstance()->Run();
+}
 
 #endif  // GTEST_INCLUDE_GTEST_GTEST_H_
diff --git a/src/gtest/include/gtest/gtest_pred_impl.h b/src/gtest/include/gtest/gtest_pred_impl.h
index 3805f85..30ae712 100644
--- a/src/gtest/include/gtest/gtest_pred_impl.h
+++ b/src/gtest/include/gtest/gtest_pred_impl.h
@@ -27,7 +27,7 @@ 
 // (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
+// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
 // 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
 //
 // Implements a family of generic predicate assertion macros.
@@ -98,7 +98,7 @@  AssertionResult AssertPred1Helper(const char* pred_text,
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
 // Don't use this in your code.
 #define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, v1),\
+  GTEST_ASSERT_(pred_format(#v1, v1), \
                 on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
@@ -144,7 +144,7 @@  AssertionResult AssertPred2Helper(const char* pred_text,
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
 // Don't use this in your code.
 #define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2),\
+  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
                 on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
@@ -197,7 +197,7 @@  AssertionResult AssertPred3Helper(const char* pred_text,
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
 // Don't use this in your code.
 #define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3),\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
                 on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
@@ -257,7 +257,7 @@  AssertionResult AssertPred4Helper(const char* pred_text,
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
 // Don't use this in your code.
 #define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4),\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
                 on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
@@ -324,7 +324,7 @@  AssertionResult AssertPred5Helper(const char* pred_text,
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
 // Don't use this in your code.
 #define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5),\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
                 on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
diff --git a/src/gtest/include/gtest/internal/gtest-death-test-internal.h b/src/gtest/include/gtest/internal/gtest-death-test-internal.h
index 1d9f83b..2b3a78f 100644
--- a/src/gtest/include/gtest/internal/gtest-death-test-internal.h
+++ b/src/gtest/include/gtest/internal/gtest-death-test-internal.h
@@ -127,11 +127,11 @@  class GTEST_API_ DeathTest {
   // the last death test.
   static const char* LastMessage();
 
-  static void set_last_death_test_message(const String& message);
+  static void set_last_death_test_message(const std::string& message);
 
  private:
   // A string containing a description of the outcome of the last death test.
-  static String last_death_test_message_;
+  static std::string last_death_test_message_;
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
 };
@@ -217,12 +217,23 @@  GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
 // The symbol "fail" here expands to something into which a message
 // can be streamed.
 
+// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
+// NDEBUG mode. In this case we need the statements to be executed, the regex is
+// ignored, and the macro must accept a streamed message even though the message
+// is never printed.
+# define GTEST_EXECUTE_STATEMENT_(statement, regex) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+  } else \
+    ::testing::Message()
+
 // A class representing the parsed contents of the
 // --gtest_internal_run_death_test flag, as it existed when
 // RUN_ALL_TESTS was called.
 class InternalRunDeathTestFlag {
  public:
-  InternalRunDeathTestFlag(const String& a_file,
+  InternalRunDeathTestFlag(const std::string& a_file,
                            int a_line,
                            int an_index,
                            int a_write_fd)
@@ -234,13 +245,13 @@  class InternalRunDeathTestFlag {
       posix::Close(write_fd_);
   }
 
-  String file() const { return file_; }
+  const std::string& file() const { return file_; }
   int line() const { return line_; }
   int index() const { return index_; }
   int write_fd() const { return write_fd_; }
 
  private:
-  String file_;
+  std::string file_;
   int line_;
   int index_;
   int write_fd_;
diff --git a/src/gtest/include/gtest/internal/gtest-filepath.h b/src/gtest/include/gtest/internal/gtest-filepath.h
index b36b3cf..7a13b4b 100644
--- a/src/gtest/include/gtest/internal/gtest-filepath.h
+++ b/src/gtest/include/gtest/internal/gtest-filepath.h
@@ -61,11 +61,7 @@  class GTEST_API_ FilePath {
   FilePath() : pathname_("") { }
   FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
 
-  explicit FilePath(const char* pathname) : pathname_(pathname) {
-    Normalize();
-  }
-
-  explicit FilePath(const String& pathname) : pathname_(pathname) {
+  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
     Normalize();
   }
 
@@ -78,7 +74,7 @@  class GTEST_API_ FilePath {
     pathname_ = rhs.pathname_;
   }
 
-  String ToString() const { return pathname_; }
+  const std::string& string() const { return pathname_; }
   const char* c_str() const { return pathname_.c_str(); }
 
   // Returns the current working directory, or "" if unsuccessful.
@@ -111,8 +107,8 @@  class GTEST_API_ FilePath {
                                          const FilePath& base_name,
                                          const char* extension);
 
-  // Returns true iff the path is NULL or "".
-  bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; }
+  // Returns true iff the path is "".
+  bool IsEmpty() const { return pathname_.empty(); }
 
   // If input name has a trailing separator character, removes it and returns
   // the name, otherwise return the name string unmodified.
@@ -201,7 +197,7 @@  class GTEST_API_ FilePath {
   // separators. Returns NULL if no path separator was found.
   const char* FindLastPathSeparator() const;
 
-  String pathname_;
+  std::string pathname_;
 };  // class FilePath
 
 }  // namespace internal
diff --git a/src/gtest/include/gtest/internal/gtest-internal.h b/src/gtest/include/gtest/internal/gtest-internal.h
index 7aa1197..0dcc3a3 100644
--- a/src/gtest/include/gtest/internal/gtest-internal.h
+++ b/src/gtest/include/gtest/internal/gtest-internal.h
@@ -46,12 +46,18 @@ 
 # include <unistd.h>
 #endif  // GTEST_OS_LINUX
 
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
 #include <ctype.h>
+#include <float.h>
 #include <string.h>
 #include <iomanip>
 #include <limits>
 #include <set>
 
+#include "gtest/gtest-message.h"
 #include "gtest/internal/gtest-string.h"
 #include "gtest/internal/gtest-filepath.h"
 #include "gtest/internal/gtest-type-util.h"
@@ -67,36 +73,6 @@ 
 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
 #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
 
-// Google Test defines the testing::Message class to allow construction of
-// test messages via the << operator.  The idea is that anything
-// streamable to std::ostream can be streamed to a testing::Message.
-// This allows a user to use his own types in Google Test assertions by
-// overloading the << operator.
-//
-// util/gtl/stl_logging-inl.h overloads << for STL containers.  These
-// overloads cannot be defined in the std namespace, as that will be
-// undefined behavior.  Therefore, they are defined in the global
-// namespace instead.
-//
-// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
-// overloads are visible in either the std namespace or the global
-// namespace, but not other namespaces, including the testing
-// namespace which Google Test's Message class is in.
-//
-// To allow STL containers (and other types that has a << operator
-// defined in the global namespace) to be used in Google Test assertions,
-// testing::Message must access the custom << operator from the global
-// namespace.  Hence this helper function.
-//
-// Note: Jeffrey Yasskin suggested an alternative fix by "using
-// ::operator<<;" in the definition of Message's operator<<.  That fix
-// doesn't require a helper function, but unfortunately doesn't
-// compile with MSVC.
-template <typename T>
-inline void GTestStreamToHelper(std::ostream* os, const T& val) {
-  *os << val;
-}
-
 class ProtocolMessage;
 namespace proto2 { class Message; }
 
@@ -122,17 +98,12 @@  class TestInfoImpl;                    // Opaque implementation of TestInfo
 class UnitTestImpl;                    // Opaque implementation of UnitTest
 
 // How many times InitGoogleTest() has been called.
-extern int g_init_gtest_count;
+GTEST_API_ extern int g_init_gtest_count;
 
 // The text used in failure messages to indicate the start of the
 // stack trace.
 GTEST_API_ extern const char kStackTraceMarker[];
 
-// A secret type that Google Test users don't know about.  It has no
-// definition on purpose.  Therefore it's impossible to create a
-// Secret object, which is what we want.
-class Secret;
-
 // Two overloaded helpers for checking at compile time whether an
 // expression is a null pointer literal (i.e. NULL or any 0-valued
 // compile-time integral constant).  Their return values have
@@ -163,8 +134,23 @@  char (&IsNullLiteralHelper(...))[2];  // NOLINT
 #endif  // GTEST_ELLIPSIS_NEEDS_POD_
 
 // Appends the user-supplied message to the Google-Test-generated message.
-GTEST_API_ String AppendUserMessage(const String& gtest_msg,
-                                    const Message& user_msg);
+GTEST_API_ std::string AppendUserMessage(
+    const std::string& gtest_msg, const Message& user_msg);
+
+#if GTEST_HAS_EXCEPTIONS
+
+// This exception is thrown by (and only by) a failed Google Test
+// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
+// are enabled).  We derive it from std::runtime_error, which is for
+// errors presumably detectable only at run time.  Since
+// std::runtime_error inherits from std::exception, many testing
+// frameworks know how to extract and print the message inside it.
+class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
+ public:
+  explicit GoogleTestFailureException(const TestPartResult& failure);
+};
+
+#endif  // GTEST_HAS_EXCEPTIONS
 
 // A helper class for creating scoped traces in user programs.
 class GTEST_API_ ScopedTrace {
@@ -185,77 +171,6 @@  class GTEST_API_ ScopedTrace {
                             // c'tor and d'tor.  Therefore it doesn't
                             // need to be used otherwise.
 
-// Converts a streamable value to a String.  A NULL pointer is
-// converted to "(null)".  When the input value is a ::string,
-// ::std::string, ::wstring, or ::std::wstring object, each NUL
-// character in it is replaced with "\\0".
-// Declared here but defined in gtest.h, so that it has access
-// to the definition of the Message class, required by the ARM
-// compiler.
-template <typename T>
-String StreamableToString(const T& streamable);
-
-// The Symbian compiler has a bug that prevents it from selecting the
-// correct overload of FormatForComparisonFailureMessage (see below)
-// unless we pass the first argument by reference.  If we do that,
-// however, Visual Age C++ 10.1 generates a compiler error.  Therefore
-// we only apply the work-around for Symbian.
-#if defined(__SYMBIAN32__)
-# define GTEST_CREF_WORKAROUND_ const&
-#else
-# define GTEST_CREF_WORKAROUND_
-#endif
-
-// When this operand is a const char* or char*, if the other operand
-// is a ::std::string or ::string, we print this operand as a C string
-// rather than a pointer (we do the same for wide strings); otherwise
-// we print it as a pointer to be safe.
-
-// This internal macro is used to avoid duplicated code.
-#define GTEST_FORMAT_IMPL_(operand2_type, operand1_printer)\
-inline String FormatForComparisonFailureMessage(\
-    operand2_type::value_type* GTEST_CREF_WORKAROUND_ str, \
-    const operand2_type& /*operand2*/) {\
-  return operand1_printer(str);\
-}\
-inline String FormatForComparisonFailureMessage(\
-    const operand2_type::value_type* GTEST_CREF_WORKAROUND_ str, \
-    const operand2_type& /*operand2*/) {\
-  return operand1_printer(str);\
-}
-
-GTEST_FORMAT_IMPL_(::std::string, String::ShowCStringQuoted)
-#if GTEST_HAS_STD_WSTRING
-GTEST_FORMAT_IMPL_(::std::wstring, String::ShowWideCStringQuoted)
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_GLOBAL_STRING
-GTEST_FORMAT_IMPL_(::string, String::ShowCStringQuoted)
-#endif  // GTEST_HAS_GLOBAL_STRING
-#if GTEST_HAS_GLOBAL_WSTRING
-GTEST_FORMAT_IMPL_(::wstring, String::ShowWideCStringQuoted)
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-#undef GTEST_FORMAT_IMPL_
-
-// The next four overloads handle the case where the operand being
-// printed is a char/wchar_t pointer and the other operand is not a
-// string/wstring object.  In such cases, we just print the operand as
-// a pointer to be safe.
-#define GTEST_FORMAT_CHAR_PTR_IMPL_(CharType)                       \
-  template <typename T>                                             \
-  String FormatForComparisonFailureMessage(CharType* GTEST_CREF_WORKAROUND_ p, \
-                                           const T&) { \
-    return PrintToString(static_cast<const void*>(p));              \
-  }
-
-GTEST_FORMAT_CHAR_PTR_IMPL_(char)
-GTEST_FORMAT_CHAR_PTR_IMPL_(const char)
-GTEST_FORMAT_CHAR_PTR_IMPL_(wchar_t)
-GTEST_FORMAT_CHAR_PTR_IMPL_(const wchar_t)
-
-#undef GTEST_FORMAT_CHAR_PTR_IMPL_
-
 // Constructs and returns the message for an equality assertion
 // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
 //
@@ -273,12 +188,12 @@  GTEST_FORMAT_CHAR_PTR_IMPL_(const wchar_t)
 // be inserted into the message.
 GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
                                      const char* actual_expression,
-                                     const String& expected_value,
-                                     const String& actual_value,
+                                     const std::string& expected_value,
+                                     const std::string& actual_value,
                                      bool ignoring_case);
 
 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
-GTEST_API_ String GetBoolAssertionFailureMessage(
+GTEST_API_ std::string GetBoolAssertionFailureMessage(
     const AssertionResult& assertion_result,
     const char* expression_text,
     const char* actual_predicate_value,
@@ -353,7 +268,7 @@  class FloatingPoint {
   // bits.  Therefore, 4 should be enough for ordinary use.
   //
   // See the following article for more details on ULP:
-  // http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm.
+  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
   static const size_t kMaxUlps = 4;
 
   // Constructs a FloatingPoint from a raw floating-point number.
@@ -380,6 +295,9 @@  class FloatingPoint {
     return ReinterpretBits(kExponentBitMask);
   }
 
+  // Returns the maximum representable finite floating-point number.
+  static RawType Max();
+
   // Non-static methods
 
   // Returns the bits that represents this number.
@@ -460,6 +378,13 @@  class FloatingPoint {
   FloatingPointUnion u_;
 };
 
+// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
+// macro defined by <windows.h>.
+template <>
+inline float FloatingPoint<float>::Max() { return FLT_MAX; }
+template <>
+inline double FloatingPoint<double>::Max() { return DBL_MAX; }
+
 // Typedefs the instances of the FloatingPoint template class that we
 // care to use.
 typedef FloatingPoint<float> Float;
@@ -554,7 +479,7 @@  typedef void (*TearDownTestCaseFunc)();
 //   test_case_name:   name of the test case
 //   name:             name of the test
 //   type_param        the name of the test's type parameter, or NULL if
-//                     this is not  a typed or a type-parameterized test.
+//                     this is not a typed or a type-parameterized test.
 //   value_param       text representation of the test's value parameter,
 //                     or NULL if this is not a type-parameterized test.
 //   fixture_class_id: ID of the test fixture class
@@ -564,7 +489,8 @@  typedef void (*TearDownTestCaseFunc)();
 //                     The newly created TestInfo instance will assume
 //                     ownership of the factory object.
 GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
-    const char* test_case_name, const char* name,
+    const char* test_case_name,
+    const char* name,
     const char* type_param,
     const char* value_param,
     TypeId fixture_class_id,
@@ -624,9 +550,9 @@  inline const char* SkipComma(const char* str) {
 
 // Returns the prefix of 'str' before the first comma in it; returns
 // the entire string if it contains no comma.
-inline String GetPrefixUntilComma(const char* str) {
+inline std::string GetPrefixUntilComma(const char* str) {
   const char* comma = strchr(str, ',');
-  return comma == NULL ? String(str) : String(str, comma - str);
+  return comma == NULL ? str : std::string(str, comma);
 }
 
 // TypeParameterizedTest<Fixture, TestSel, Types>::Register()
@@ -652,8 +578,8 @@  class TypeParameterizedTest {
     // First, registers the first type-parameterized test in the type
     // list.
     MakeAndRegisterTestInfo(
-        String::Format("%s%s%s/%d", prefix, prefix[0] == '\0' ? "" : "/",
-                       case_name, index).c_str(),
+        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
+         + StreamableToString(index)).c_str(),
         GetPrefixUntilComma(test_names).c_str(),
         GetTypeName<Type>().c_str(),
         NULL,  // No value parameter.
@@ -711,7 +637,7 @@  class TypeParameterizedTestCase<Fixture, Templates0, Types> {
 
 #endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
 
-// Returns the current OS stack trace as a String.
+// Returns the current OS stack trace as an std::string.
 //
 // The maximum number of stack frames to be included is specified by
 // the gtest_stack_trace_depth flag.  The skip_count parameter
@@ -721,8 +647,8 @@  class TypeParameterizedTestCase<Fixture, Templates0, Types> {
 // For example, if Foo() calls Bar(), which in turn calls
 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-GTEST_API_ String GetCurrentOsStackTraceExceptTop(UnitTest* unit_test,
-                                                  int skip_count);
+GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
+    UnitTest* unit_test, int skip_count);
 
 // Helpers for suppressing warnings on unreachable code or constant
 // condition.
@@ -797,13 +723,19 @@  struct RemoveConst<const T> { typedef T type; };  // NOLINT
 // MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
 // definition to fail to remove the const in 'const int[3]' and 'const
 // char[3][4]'.  The following specialization works around the bug.
-// However, it causes trouble with GCC and thus needs to be
-// conditionally compiled.
-#if defined(_MSC_VER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
 template <typename T, size_t N>
 struct RemoveConst<const T[N]> {
   typedef typename RemoveConst<T>::type type[N];
 };
+
+#if defined(_MSC_VER) && _MSC_VER < 1400
+// This is the only specialization that allows VC++ 7.1 to remove const in
+// 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
+// and thus needs to be conditionally compiled.
+template <typename T, size_t N>
+struct RemoveConst<T[N]> {
+  typedef typename RemoveConst<T>::type type[N];
+};
 #endif
 
 // A handy wrapper around RemoveConst that works when the argument
diff --git a/src/gtest/include/gtest/internal/gtest-linked_ptr.h b/src/gtest/include/gtest/internal/gtest-linked_ptr.h
index 57147b4..b1362cd 100644
--- a/src/gtest/include/gtest/internal/gtest-linked_ptr.h
+++ b/src/gtest/include/gtest/internal/gtest-linked_ptr.h
@@ -105,8 +105,8 @@  class linked_ptr_internal {
   // framework.
 
   // Join an existing circle.
-  // L < g_linked_ptr_mutex
-  void join(linked_ptr_internal const* ptr) {
+  void join(linked_ptr_internal const* ptr)
+      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
     MutexLock lock(&g_linked_ptr_mutex);
 
     linked_ptr_internal const* p = ptr;
@@ -117,8 +117,8 @@  class linked_ptr_internal {
 
   // Leave whatever circle we're part of.  Returns true if we were the
   // last member of the circle.  Once this is done, you can join() another.
-  // L < g_linked_ptr_mutex
-  bool depart() {
+  bool depart()
+      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
     MutexLock lock(&g_linked_ptr_mutex);
 
     if (next_ == this) return true;
diff --git a/src/gtest/include/gtest/internal/gtest-param-util-generated.h b/src/gtest/include/gtest/internal/gtest-param-util-generated.h
index 2582675..e805485 100644
--- a/src/gtest/include/gtest/internal/gtest-param-util-generated.h
+++ b/src/gtest/include/gtest/internal/gtest-param-util-generated.h
@@ -95,7 +95,7 @@  class ValueArray2 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
     return ValuesIn(array);
   }
 
@@ -114,7 +114,8 @@  class ValueArray3 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_)};
     return ValuesIn(array);
   }
 
@@ -135,7 +136,8 @@  class ValueArray4 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_)};
     return ValuesIn(array);
   }
 
@@ -157,7 +159,8 @@  class ValueArray5 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
     return ValuesIn(array);
   }
 
@@ -181,7 +184,9 @@  class ValueArray6 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_)};
     return ValuesIn(array);
   }
 
@@ -206,7 +211,9 @@  class ValueArray7 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_)};
     return ValuesIn(array);
   }
 
@@ -233,7 +240,9 @@  class ValueArray8 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
     return ValuesIn(array);
   }
 
@@ -261,7 +270,10 @@  class ValueArray9 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_)};
     return ValuesIn(array);
   }
 
@@ -290,7 +302,10 @@  class ValueArray10 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_)};
     return ValuesIn(array);
   }
 
@@ -321,7 +336,10 @@  class ValueArray11 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
     return ValuesIn(array);
   }
 
@@ -353,8 +371,11 @@  class ValueArray12 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_)};
     return ValuesIn(array);
   }
 
@@ -388,8 +409,11 @@  class ValueArray13 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_)};
     return ValuesIn(array);
   }
 
@@ -424,8 +448,11 @@  class ValueArray14 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
     return ValuesIn(array);
   }
 
@@ -461,8 +488,12 @@  class ValueArray15 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_)};
     return ValuesIn(array);
   }
 
@@ -501,8 +532,12 @@  class ValueArray16 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_)};
     return ValuesIn(array);
   }
 
@@ -542,8 +577,12 @@  class ValueArray17 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
     return ValuesIn(array);
   }
 
@@ -584,8 +623,13 @@  class ValueArray18 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_)};
     return ValuesIn(array);
   }
 
@@ -627,8 +671,13 @@  class ValueArray19 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_)};
     return ValuesIn(array);
   }
 
@@ -672,8 +721,13 @@  class ValueArray20 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
     return ValuesIn(array);
   }
 
@@ -719,8 +773,14 @@  class ValueArray21 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_)};
     return ValuesIn(array);
   }
 
@@ -767,8 +827,14 @@  class ValueArray22 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_)};
     return ValuesIn(array);
   }
 
@@ -817,9 +883,14 @@  class ValueArray23 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_,
-        v23_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
     return ValuesIn(array);
   }
 
@@ -869,9 +940,15 @@  class ValueArray24 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_)};
     return ValuesIn(array);
   }
 
@@ -922,9 +999,15 @@  class ValueArray25 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_)};
     return ValuesIn(array);
   }
 
@@ -977,9 +1060,15 @@  class ValueArray26 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
     return ValuesIn(array);
   }
 
@@ -1034,9 +1123,16 @@  class ValueArray27 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_)};
     return ValuesIn(array);
   }
 
@@ -1092,9 +1188,16 @@  class ValueArray28 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_)};
     return ValuesIn(array);
   }
 
@@ -1151,9 +1254,16 @@  class ValueArray29 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
     return ValuesIn(array);
   }
 
@@ -1212,9 +1322,17 @@  class ValueArray30 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_)};
     return ValuesIn(array);
   }
 
@@ -1275,9 +1393,17 @@  class ValueArray31 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_)};
     return ValuesIn(array);
   }
 
@@ -1339,9 +1465,17 @@  class ValueArray32 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
     return ValuesIn(array);
   }
 
@@ -1405,9 +1539,18 @@  class ValueArray33 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_)};
     return ValuesIn(array);
   }
 
@@ -1472,9 +1615,18 @@  class ValueArray34 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_)};
     return ValuesIn(array);
   }
 
@@ -1540,10 +1692,18 @@  class ValueArray35 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_,
-        v35_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
     return ValuesIn(array);
   }
 
@@ -1611,10 +1771,19 @@  class ValueArray36 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_)};
     return ValuesIn(array);
   }
 
@@ -1684,10 +1853,19 @@  class ValueArray37 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_)};
     return ValuesIn(array);
   }
 
@@ -1758,10 +1936,19 @@  class ValueArray38 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
     return ValuesIn(array);
   }
 
@@ -1833,10 +2020,20 @@  class ValueArray39 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_)};
     return ValuesIn(array);
   }
 
@@ -1910,10 +2107,20 @@  class ValueArray40 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_)};
     return ValuesIn(array);
   }
 
@@ -1989,10 +2196,20 @@  class ValueArray41 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
     return ValuesIn(array);
   }
 
@@ -2069,10 +2286,21 @@  class ValueArray42 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_)};
     return ValuesIn(array);
   }
 
@@ -2150,10 +2378,21 @@  class ValueArray43 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_)};
     return ValuesIn(array);
   }
 
@@ -2233,10 +2472,21 @@  class ValueArray44 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
     return ValuesIn(array);
   }
 
@@ -2317,10 +2567,22 @@  class ValueArray45 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_)};
     return ValuesIn(array);
   }
 
@@ -2403,10 +2665,22 @@  class ValueArray46 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_)};
     return ValuesIn(array);
   }
 
@@ -2491,11 +2765,22 @@  class ValueArray47 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_,
-        v47_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
     return ValuesIn(array);
   }
 
@@ -2581,11 +2866,23 @@  class ValueArray48 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_,
-        v48_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_)};
     return ValuesIn(array);
   }
 
@@ -2672,11 +2969,23 @@  class ValueArray49 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_,
-        v48_, v49_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_), static_cast<T>(v49_)};
     return ValuesIn(array);
   }
 
@@ -2764,11 +3073,23 @@  class ValueArray50 {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
-        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
-        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
-        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_,
-        v48_, v49_, v50_};
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
     return ValuesIn(array);
   }
 
diff --git a/src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump b/src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump
index dbe9386..009206f 100644
--- a/src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump
+++ b/src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump
@@ -98,7 +98,7 @@  class ValueArray$i {
 
   template <typename T>
   operator ParamGenerator<T>() const {
-    const T array[] = {$for j, [[v$(j)_]]};
+    const T array[] = {$for j, [[static_cast<T>(v$(j)_)]]};
     return ValuesIn(array);
   }
 
diff --git a/src/gtest/include/gtest/internal/gtest-param-util.h b/src/gtest/include/gtest/internal/gtest-param-util.h
index 0ef9718..d5e1028 100644
--- a/src/gtest/include/gtest/internal/gtest-param-util.h
+++ b/src/gtest/include/gtest/internal/gtest-param-util.h
@@ -494,10 +494,10 @@  class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
         const string& instantiation_name = gen_it->first;
         ParamGenerator<ParamType> generator((*gen_it->second)());
 
-        Message test_case_name_stream;
+        string test_case_name;
         if ( !instantiation_name.empty() )
-          test_case_name_stream << instantiation_name << "/";
-        test_case_name_stream << test_info->test_case_base_name;
+          test_case_name = instantiation_name + "/";
+        test_case_name += test_info->test_case_base_name;
 
         int i = 0;
         for (typename ParamGenerator<ParamType>::iterator param_it =
@@ -506,7 +506,7 @@  class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
           Message test_name_stream;
           test_name_stream << test_info->test_base_name << "/" << i;
           MakeAndRegisterTestInfo(
-              test_case_name_stream.GetString().c_str(),
+              test_case_name.c_str(),
               test_name_stream.GetString().c_str(),
               NULL,  // No type parameter.
               PrintToString(*param_it).c_str(),
diff --git a/src/gtest/include/gtest/internal/gtest-port.h b/src/gtest/include/gtest/internal/gtest-port.h
index 157b47f..dc4fe0c 100644
--- a/src/gtest/include/gtest/internal/gtest-port.h
+++ b/src/gtest/include/gtest/internal/gtest-port.h
@@ -32,6 +32,10 @@ 
 // Low-level types and utilities for porting Google Test to various
 // platforms.  They are subject to change without notice.  DO NOT USE
 // THEM IN USER CODE.
+//
+// This file is fundamental to Google Test.  All other Google Test source
+// files are expected to #include this.  Therefore, it cannot #include
+// any other Google Test header.
 
 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
@@ -72,6 +76,8 @@ 
 //                              Test's own tr1 tuple implementation should be
 //                              used.  Unused when the user sets
 //                              GTEST_HAS_TR1_TUPLE to 0.
+//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
+//                              is building in C++11/C++98 mode.
 //   GTEST_LINKED_AS_SHARED_LIBRARY
 //                            - Define to 1 when compiling tests that use
 //                              Google Test as a shared library (known as
@@ -90,7 +96,11 @@ 
 //   GTEST_OS_LINUX    - Linux
 //     GTEST_OS_LINUX_ANDROID - Google Android
 //   GTEST_OS_MAC      - Mac OS X
+//     GTEST_OS_IOS    - iOS
+//       GTEST_OS_IOS_SIMULATOR - iOS simulator
 //   GTEST_OS_NACL     - Google Native Client (NaCl)
+//   GTEST_OS_OPENBSD  - OpenBSD
+//   GTEST_OS_QNX      - QNX
 //   GTEST_OS_SOLARIS  - Sun Solaris
 //   GTEST_OS_SYMBIAN  - Symbian
 //   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
@@ -175,7 +185,7 @@ 
 //   GTEST_FLAG()       - references a flag.
 //   GTEST_DECLARE_*()  - declares a flag.
 //   GTEST_DEFINE_*()   - defines a flag.
-//   GetArgvs()         - returns the command line as a vector of strings.
+//   GetInjectableArgvs() - returns the command line as a vector of strings.
 //
 // Environment variable utilities:
 //   GetEnv()             - gets the value of an environment variable.
@@ -193,6 +203,11 @@ 
 # include <sys/stat.h>
 #endif  // !_WIN32_WCE
 
+#if defined __APPLE__
+# include <AvailabilityMacros.h>
+# include <TargetConditionals.h>
+#endif
+
 #include <iostream>  // NOLINT
 #include <sstream>  // NOLINT
 #include <string>  // NOLINT
@@ -227,11 +242,17 @@ 
 # endif  // _WIN32_WCE
 #elif defined __APPLE__
 # define GTEST_OS_MAC 1
+# if TARGET_OS_IPHONE
+#  define GTEST_OS_IOS 1
+#  if TARGET_IPHONE_SIMULATOR
+#   define GTEST_OS_IOS_SIMULATOR 1
+#  endif
+# endif
 #elif defined __linux__
 # define GTEST_OS_LINUX 1
-# ifdef ANDROID
+# if defined __ANDROID__
 #  define GTEST_OS_LINUX_ANDROID 1
-# endif  // ANDROID
+# endif
 #elif defined __MVS__
 # define GTEST_OS_ZOS 1
 #elif defined(__sun) && defined(__SVR4)
@@ -242,8 +263,25 @@ 
 # define GTEST_OS_HPUX 1
 #elif defined __native_client__
 # define GTEST_OS_NACL 1
+#elif defined __OpenBSD__
+# define GTEST_OS_OPENBSD 1
+#elif defined __QNX__
+# define GTEST_OS_QNX 1
 #endif  // __CYGWIN__
 
+#ifndef GTEST_LANG_CXX11
+// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
+// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
+// value for __cplusplus, and recent versions of clang, gcc, and
+// probably other compilers set that too in C++11 mode.
+# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
+// Compiling in at least C++11 mode.
+#  define GTEST_LANG_CXX11 1
+# else
+#  define GTEST_LANG_CXX11 0
+# endif
+#endif
+
 // Brings in definitions for functions used in the testing::internal::posix
 // namespace (read, write, close, chdir, isatty, stat). We do not currently
 // use them on Windows Mobile.
@@ -252,20 +290,25 @@ 
 // is not the case, we need to include headers that provide the functions
 // mentioned above.
 # include <unistd.h>
-# if !GTEST_OS_NACL
-// TODO(vladl@google.com): Remove this condition when Native Client SDK adds
-// strings.h (tracked in
-// http://code.google.com/p/nativeclient/issues/detail?id=1175).
-#  include <strings.h>  // Native Client doesn't provide strings.h.
-# endif
+# include <strings.h>
 #elif !GTEST_OS_WINDOWS_MOBILE
 # include <direct.h>
 # include <io.h>
 #endif
 
+#if GTEST_OS_LINUX_ANDROID
+// Used to define __ANDROID_API__ matching the target NDK API level.
+#  include <android/api-level.h>  // NOLINT
+#endif
+
 // Defines this to true iff Google Test can use POSIX regular expressions.
 #ifndef GTEST_HAS_POSIX_RE
-# define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
+# if GTEST_OS_LINUX_ANDROID
+// On Android, <regex.h> is only available starting with Gingerbread.
+#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
+# else
+#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
+# endif
 #endif
 
 #if GTEST_HAS_POSIX_RE
@@ -380,11 +423,27 @@ 
 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
 
 #  ifdef __GXX_RTTI
-#   define GTEST_HAS_RTTI 1
+// When building against STLport with the Android NDK and with
+// -frtti -fno-exceptions, the build fails at link time with undefined
+// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
+// so disable RTTI when detected.
+#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
+       !defined(__EXCEPTIONS)
+#    define GTEST_HAS_RTTI 0
+#   else
+#    define GTEST_HAS_RTTI 1
+#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
 #  else
 #   define GTEST_HAS_RTTI 0
 #  endif  // __GXX_RTTI
 
+// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
+// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
+// first version with C++ support.
+# elif defined(__clang__)
+
+#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
+
 // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
 // both the typeid and dynamic_cast features are present.
 # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
@@ -417,7 +476,8 @@ 
 //
 // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
 // to your compiler flags.
-# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX)
+# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
+    || GTEST_OS_QNX)
 #endif  // GTEST_HAS_PTHREAD
 
 #if GTEST_HAS_PTHREAD
@@ -433,8 +493,13 @@ 
 // this macro to 0 to prevent Google Test from using tuple (any
 // feature depending on tuple with be disabled in this mode).
 #ifndef GTEST_HAS_TR1_TUPLE
+# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
+// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
+#  define GTEST_HAS_TR1_TUPLE 0
+# else
 // The user didn't tell us not to do it, so we assume it's OK.
-# define GTEST_HAS_TR1_TUPLE 1
+#  define GTEST_HAS_TR1_TUPLE 1
+# endif
 #endif  // GTEST_HAS_TR1_TUPLE
 
 // Determines whether Google Test's own tr1 tuple implementation
@@ -443,14 +508,28 @@ 
 // The user didn't tell us, so we need to figure it out.
 
 // We use our own TR1 tuple if we aren't sure the user has an
-// implementation of it already.  At this time, GCC 4.0.0+ and MSVC
-// 2010 are the only mainstream compilers that come with a TR1 tuple
-// implementation.  NVIDIA's CUDA NVCC compiler pretends to be GCC by
-// defining __GNUC__ and friends, but cannot compile GCC's tuple
-// implementation.  MSVC 2008 (9.0) provides TR1 tuple in a 323 MB
-// Feature Pack download, which we cannot assume the user has.
-# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \
-    || _MSC_VER >= 1600
+// implementation of it already.  At this time, libstdc++ 4.0.0+ and
+// MSVC 2010 are the only mainstream standard libraries that come
+// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
+// pretends to be GCC by defining __GNUC__ and friends, but cannot
+// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
+// tuple in a 323 MB Feature Pack download, which we cannot assume the
+// user has.  QNX's QCC compiler is a modified GCC but it doesn't
+// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
+// and it can be used with some compilers that define __GNUC__.
+# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
+      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
+#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
+# endif
+
+// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
+// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
+// can build with clang but need to use gcc4.2's libstdc++).
+# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
+#  define GTEST_ENV_HAS_STD_TUPLE_ 1
+# endif
+
+# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
 #  define GTEST_USE_OWN_TR1_TUPLE 0
 # else
 #  define GTEST_USE_OWN_TR1_TUPLE 1
@@ -465,6 +544,22 @@ 
 
 # if GTEST_USE_OWN_TR1_TUPLE
 #  include "gtest/internal/gtest-tuple.h"
+# elif GTEST_ENV_HAS_STD_TUPLE_
+#  include <tuple>
+// C++11 puts its tuple into the ::std namespace rather than
+// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
+// This causes undefined behavior, but supported compilers react in
+// the way we intend.
+namespace std {
+namespace tr1 {
+using ::std::get;
+using ::std::make_tuple;
+using ::std::tuple;
+using ::std::tuple_element;
+using ::std::tuple_size;
+}
+}
+
 # elif GTEST_OS_SYMBIAN
 
 // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
@@ -515,7 +610,16 @@ 
 // The user didn't tell us, so we need to figure it out.
 
 # if GTEST_OS_LINUX && !defined(__ia64__)
-#  define GTEST_HAS_CLONE 1
+#  if GTEST_OS_LINUX_ANDROID
+// On Android, clone() is only available on ARM starting with Gingerbread.
+#    if defined(__arm__) && __ANDROID_API__ >= 9
+#     define GTEST_HAS_CLONE 1
+#    else
+#     define GTEST_HAS_CLONE 0
+#    endif
+#  else
+#   define GTEST_HAS_CLONE 1
+#  endif
 # else
 #  define GTEST_HAS_CLONE 0
 # endif  // GTEST_OS_LINUX && !defined(__ia64__)
@@ -538,9 +642,11 @@ 
 // Google Test does not support death tests for VC 7.1 and earlier as
 // abort() in a VC 7.1 application compiled as GUI in debug config
 // pops up a dialog window that cannot be suppressed programmatically.
-#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
+#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
+     (GTEST_OS_MAC && !GTEST_OS_IOS) || GTEST_OS_IOS_SIMULATOR || \
      (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
-     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX)
+     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
+     GTEST_OS_OPENBSD || GTEST_OS_QNX)
 # define GTEST_HAS_DEATH_TEST 1
 # include <vector>  // NOLINT
 #endif
@@ -669,13 +775,23 @@ 
 # define GTEST_NO_INLINE_
 #endif
 
+// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
+#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
+# define GTEST_HAS_CXXABI_H_ 1
+#else
+# define GTEST_HAS_CXXABI_H_ 0
+#endif
+
 namespace testing {
 
 class Message;
 
 namespace internal {
 
-class String;
+// A secret type that Google Test users don't know about.  It has no
+// definition on purpose.  Therefore it's impossible to create a
+// Secret object, which is what we want.
+class Secret;
 
 // The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
 // expression is true. For example, you could use it to verify the
@@ -697,8 +813,8 @@  struct CompileAssert {
 };
 
 #define GTEST_COMPILE_ASSERT_(expr, msg) \
-  typedef ::testing::internal::CompileAssert<(bool(expr))> \
-      msg[bool(expr) ? 1 : -1]
+  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
+      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
 
 // Implementation details of GTEST_COMPILE_ASSERT_:
 //
@@ -796,6 +912,7 @@  class scoped_ptr {
       ptr_ = p;
     }
   }
+
  private:
   T* ptr_;
 
@@ -858,10 +975,9 @@  class GTEST_API_ RE {
  private:
   void Init(const char* regex);
 
-  // We use a const char* instead of a string, as Google Test may be used
-  // where string is not available.  We also do not use Google Test's own
-  // String type here, in order to simplify dependencies between the
-  // files.
+  // We use a const char* instead of an std::string, as Google Test used to be
+  // used where std::string is not available.  TODO(wan@google.com): change to
+  // std::string.
   const char* pattern_;
   bool is_valid_;
 
@@ -1044,20 +1160,21 @@  Derived* CheckedDowncastToActualType(Base* base) {
 //   GetCapturedStderr - stops capturing stderr and returns the captured string.
 //
 GTEST_API_ void CaptureStdout();
-GTEST_API_ String GetCapturedStdout();
+GTEST_API_ std::string GetCapturedStdout();
 GTEST_API_ void CaptureStderr();
-GTEST_API_ String GetCapturedStderr();
+GTEST_API_ std::string GetCapturedStderr();
 
 #endif  // GTEST_HAS_STREAM_REDIRECTION
 
 
 #if GTEST_HAS_DEATH_TEST
 
-// A copy of all command line arguments.  Set by InitGoogleTest().
-extern ::std::vector<String> g_argvs;
+const ::std::vector<testing::internal::string>& GetInjectableArgvs();
+void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
+                             new_argvs);
 
-// GTEST_HAS_DEATH_TEST implies we have ::std::string.
-const ::std::vector<String>& GetArgvs();
+// A copy of all command line arguments.  Set by InitGoogleTest().
+extern ::std::vector<testing::internal::string> g_argvs;
 
 #endif  // GTEST_HAS_DEATH_TEST
 
@@ -1084,22 +1201,37 @@  inline void SleepMilliseconds(int n) {
 // use it in user tests, either directly or indirectly.
 class Notification {
  public:
-  Notification() : notified_(false) {}
+  Notification() : notified_(false) {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
+  }
+  ~Notification() {
+    pthread_mutex_destroy(&mutex_);
+  }
 
   // Notifies all threads created with this notification to start. Must
   // be called from the controller thread.
-  void Notify() { notified_ = true; }
+  void Notify() {
+    pthread_mutex_lock(&mutex_);
+    notified_ = true;
+    pthread_mutex_unlock(&mutex_);
+  }
 
   // Blocks until the controller thread notifies. Must be called from a test
   // thread.
   void WaitForNotification() {
-    while(!notified_) {
+    for (;;) {
+      pthread_mutex_lock(&mutex_);
+      const bool notified = notified_;
+      pthread_mutex_unlock(&mutex_);
+      if (notified)
+        break;
       SleepMilliseconds(10);
     }
   }
 
  private:
-  volatile bool notified_;
+  pthread_mutex_t mutex_;
+  bool notified_;
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
 };
@@ -1207,21 +1339,23 @@  class MutexBase {
   void Lock() {
     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
     owner_ = pthread_self();
+    has_owner_ = true;
   }
 
   // Releases this mutex.
   void Unlock() {
-    // We don't protect writing to owner_ here, as it's the caller's
-    // responsibility to ensure that the current thread holds the
+    // Since the lock is being released the owner_ field should no longer be
+    // considered valid. We don't protect writing to has_owner_ here, as it's
+    // the caller's responsibility to ensure that the current thread holds the
     // mutex when this is called.
-    owner_ = 0;
+    has_owner_ = false;
     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
   }
 
   // Does nothing if the current thread holds the mutex. Otherwise, crashes
   // with high probability.
   void AssertHeld() const {
-    GTEST_CHECK_(owner_ == pthread_self())
+    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
         << "The current thread is not holding the mutex @" << this;
   }
 
@@ -1232,7 +1366,14 @@  class MutexBase {
   // have to be public.
  public:
   pthread_mutex_t mutex_;  // The underlying pthread mutex.
-  pthread_t owner_;  // The thread holding the mutex; 0 means no one holds it.
+  // has_owner_ indicates whether the owner_ field below contains a valid thread
+  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
+  // accesses to the owner_ field should be protected by a check of this field.
+  // An alternative might be to memset() owner_ to all zeros, but there's no
+  // guarantee that a zero'd pthread_t is necessarily invalid or even different
+  // from pthread_self().
+  bool has_owner_;
+  pthread_t owner_;  // The thread holding the mutex.
 };
 
 // Forward-declares a static mutex.
@@ -1240,8 +1381,13 @@  class MutexBase {
     extern ::testing::internal::MutexBase mutex
 
 // Defines and statically (i.e. at link time) initializes a static mutex.
+// The initialization list here does not explicitly initialize each field,
+// instead relying on default initialization for the unspecified fields. In
+// particular, the owner_ field (a pthread_t) is not explicitly initialized.
+// This allows initialization to work whether pthread_t is a scalar or struct.
+// The flag -Wmissing-field-initializers must not be specified for this to work.
 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-    ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 }
+    ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false }
 
 // The Mutex class can only be used for mutexes created at runtime. It
 // shares its API with MutexBase otherwise.
@@ -1249,7 +1395,7 @@  class Mutex : public MutexBase {
  public:
   Mutex() {
     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
-    owner_ = 0;
+    has_owner_ = false;
   }
   ~Mutex() {
     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
@@ -1399,6 +1545,8 @@  class ThreadLocal {
 class Mutex {
  public:
   Mutex() {}
+  void Lock() {}
+  void Unlock() {}
   void AssertHeld() const {}
 };
 
@@ -1529,6 +1677,10 @@  inline bool IsUpper(char ch) {
 inline bool IsXDigit(char ch) {
   return isxdigit(static_cast<unsigned char>(ch)) != 0;
 }
+inline bool IsXDigit(wchar_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
 
 inline char ToLower(char ch) {
   return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
@@ -1666,6 +1818,23 @@  inline void Abort() { abort(); }
 
 }  // namespace posix
 
+// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
+// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
+// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
+// function in order to achieve that.  We use macro definition here because
+// snprintf is a variadic function.
+#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
+// MSVC 2005 and above support variadic macros.
+# define GTEST_SNPRINTF_(buffer, size, format, ...) \
+     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
+#elif defined(_MSC_VER)
+// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
+// complain about _snprintf.
+# define GTEST_SNPRINTF_ _snprintf
+#else
+# define GTEST_SNPRINTF_ snprintf
+#endif
+
 // The maximum number a BiggestInt can represent.  This definition
 // works no matter BiggestInt is represented in one's complement or
 // two's complement.
@@ -1718,7 +1887,6 @@  class TypeWithSize<4> {
 template <>
 class TypeWithSize<8> {
  public:
-
 #if GTEST_OS_WINDOWS
   typedef __int64 Int;
   typedef unsigned __int64 UInt;
@@ -1745,7 +1913,7 @@  typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
 #define GTEST_DECLARE_int32_(name) \
     GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
 #define GTEST_DECLARE_string_(name) \
-    GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name)
+    GTEST_API_ extern ::std::string GTEST_FLAG(name)
 
 // Macros for defining flags.
 #define GTEST_DEFINE_bool_(name, default_val, doc) \
@@ -1753,7 +1921,11 @@  typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
 #define GTEST_DEFINE_int32_(name, default_val, doc) \
     GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
 #define GTEST_DEFINE_string_(name, default_val, doc) \
-    GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val)
+    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
+
+// Thread annotations
+#define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+#define GTEST_LOCK_EXCLUDED_(locks)
 
 // Parses 'str' for a 32-bit signed integer.  If successful, writes the result
 // to *value and returns true; otherwise leaves *value unchanged and returns
diff --git a/src/gtest/include/gtest/internal/gtest-string.h b/src/gtest/include/gtest/internal/gtest-string.h
index dc3a07b..97f1a7f 100644
--- a/src/gtest/include/gtest/internal/gtest-string.h
+++ b/src/gtest/include/gtest/internal/gtest-string.h
@@ -47,50 +47,18 @@ 
 #endif
 
 #include <string.h>
-#include "gtest/internal/gtest-port.h"
-
 #include <string>
 
+#include "gtest/internal/gtest-port.h"
+
 namespace testing {
 namespace internal {
 
-// String - a UTF-8 string class.
-//
-// For historic reasons, we don't use std::string.
-//
-// TODO(wan@google.com): replace this class with std::string or
-// implement it in terms of the latter.
-//
-// Note that String can represent both NULL and the empty string,
-// while std::string cannot represent NULL.
-//
-// NULL and the empty string are considered different.  NULL is less
-// than anything (including the empty string) except itself.
-//
-// This class only provides minimum functionality necessary for
-// implementing Google Test.  We do not intend to implement a full-fledged
-// string class here.
-//
-// Since the purpose of this class is to provide a substitute for
-// std::string on platforms where it cannot be used, we define a copy
-// constructor and assignment operators such that we don't need
-// conditional compilation in a lot of places.
-//
-// In order to make the representation efficient, the d'tor of String
-// is not virtual.  Therefore DO NOT INHERIT FROM String.
+// String - an abstract class holding static string utilities.
 class GTEST_API_ String {
  public:
   // Static utility methods
 
-  // Returns the input enclosed in double quotes if it's not NULL;
-  // otherwise returns "(null)".  For example, "\"Hello\"" is returned
-  // for input "Hello".
-  //
-  // This is useful for printing a C string in the syntax of a literal.
-  //
-  // Known issue: escape sequences are not handled yet.
-  static String ShowCStringQuoted(const char* c_str);
-
   // Clones a 0-terminated C string, allocating memory using new.  The
   // caller is responsible for deleting the return value using
   // delete[].  Returns the cloned string, or NULL if the input is
@@ -137,11 +105,7 @@  class GTEST_API_ String {
   // NULL will be converted to "(null)".  If an error occurred during
   // the conversion, "(failed to convert from wide string)" is
   // returned.
-  static String ShowWideCString(const wchar_t* wide_c_str);
-
-  // Similar to ShowWideCString(), except that this function encloses
-  // the converted string in double quotes.
-  static String ShowWideCStringQuoted(const wchar_t* wide_c_str);
+  static std::string ShowWideCString(const wchar_t* wide_c_str);
 
   // Compares two wide C strings.  Returns true iff they have the same
   // content.
@@ -175,174 +139,27 @@  class GTEST_API_ String {
   static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
                                                const wchar_t* rhs);
 
-  // Formats a list of arguments to a String, using the same format
-  // spec string as for printf.
-  //
-  // We do not use the StringPrintf class as it is not universally
-  // available.
-  //
-  // The result is limited to 4096 characters (including the tailing
-  // 0).  If 4096 characters are not enough to format the input,
-  // "<buffer exceeded>" is returned.
-  static String Format(const char* format, ...);
-
-  // C'tors
-
-  // The default c'tor constructs a NULL string.
-  String() : c_str_(NULL), length_(0) {}
-
-  // Constructs a String by cloning a 0-terminated C string.
-  String(const char* a_c_str) {  // NOLINT
-    if (a_c_str == NULL) {
-      c_str_ = NULL;
-      length_ = 0;
-    } else {
-      ConstructNonNull(a_c_str, strlen(a_c_str));
-    }
-  }
+  // Returns true iff the given string ends with the given suffix, ignoring
+  // case. Any string is considered to end with an empty suffix.
+  static bool EndsWithCaseInsensitive(
+      const std::string& str, const std::string& suffix);
 
-  // Constructs a String by copying a given number of chars from a
-  // buffer.  E.g. String("hello", 3) creates the string "hel",
-  // String("a\0bcd", 4) creates "a\0bc", String(NULL, 0) creates "",
-  // and String(NULL, 1) results in access violation.
-  String(const char* buffer, size_t a_length) {
-    ConstructNonNull(buffer, a_length);
-  }
+  // Formats an int value as "%02d".
+  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
 
-  // The copy c'tor creates a new copy of the string.  The two
-  // String objects do not share content.
-  String(const String& str) : c_str_(NULL), length_(0) { *this = str; }
+  // Formats an int value as "%X".
+  static std::string FormatHexInt(int value);
 
-  // D'tor.  String is intended to be a final class, so the d'tor
-  // doesn't need to be virtual.
-  ~String() { delete[] c_str_; }
-
-  // Allows a String to be implicitly converted to an ::std::string or
-  // ::string, and vice versa.  Converting a String containing a NULL
-  // pointer to ::std::string or ::string is undefined behavior.
-  // Converting a ::std::string or ::string containing an embedded NUL
-  // character to a String will result in the prefix up to the first
-  // NUL character.
-  String(const ::std::string& str) {
-    ConstructNonNull(str.c_str(), str.length());
-  }
-
-  operator ::std::string() const { return ::std::string(c_str(), length()); }
-
-#if GTEST_HAS_GLOBAL_STRING
-  String(const ::string& str) {
-    ConstructNonNull(str.c_str(), str.length());
-  }
-
-  operator ::string() const { return ::string(c_str(), length()); }
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-  // Returns true iff this is an empty string (i.e. "").
-  bool empty() const { return (c_str() != NULL) && (length() == 0); }
-
-  // Compares this with another String.
-  // Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
-  // if this is greater than rhs.
-  int Compare(const String& rhs) const;
-
-  // Returns true iff this String equals the given C string.  A NULL
-  // string and a non-NULL string are considered not equal.
-  bool operator==(const char* a_c_str) const { return Compare(a_c_str) == 0; }
-
-  // Returns true iff this String is less than the given String.  A
-  // NULL string is considered less than "".
-  bool operator<(const String& rhs) const { return Compare(rhs) < 0; }
-
-  // Returns true iff this String doesn't equal the given C string.  A NULL
-  // string and a non-NULL string are considered not equal.
-  bool operator!=(const char* a_c_str) const { return !(*this == a_c_str); }
-
-  // Returns true iff this String ends with the given suffix.  *Any*
-  // String is considered to end with a NULL or empty suffix.
-  bool EndsWith(const char* suffix) const;
-
-  // Returns true iff this String ends with the given suffix, not considering
-  // case. Any String is considered to end with a NULL or empty suffix.
-  bool EndsWithCaseInsensitive(const char* suffix) const;
-
-  // Returns the length of the encapsulated string, or 0 if the
-  // string is NULL.
-  size_t length() const { return length_; }
-
-  // Gets the 0-terminated C string this String object represents.
-  // The String object still owns the string.  Therefore the caller
-  // should NOT delete the return value.
-  const char* c_str() const { return c_str_; }
-
-  // Assigns a C string to this object.  Self-assignment works.
-  const String& operator=(const char* a_c_str) {
-    return *this = String(a_c_str);
-  }
-
-  // Assigns a String object to this object.  Self-assignment works.
-  const String& operator=(const String& rhs) {
-    if (this != &rhs) {
-      delete[] c_str_;
-      if (rhs.c_str() == NULL) {
-        c_str_ = NULL;
-        length_ = 0;
-      } else {
-        ConstructNonNull(rhs.c_str(), rhs.length());
-      }
-    }
-
-    return *this;
-  }
+  // Formats a byte as "%02X".
+  static std::string FormatByte(unsigned char value);
 
  private:
-  // Constructs a non-NULL String from the given content.  This
-  // function can only be called when c_str_ has not been allocated.
-  // ConstructNonNull(NULL, 0) results in an empty string ("").
-  // ConstructNonNull(NULL, non_zero) is undefined behavior.
-  void ConstructNonNull(const char* buffer, size_t a_length) {
-    char* const str = new char[a_length + 1];
-    memcpy(str, buffer, a_length);
-    str[a_length] = '\0';
-    c_str_ = str;
-    length_ = a_length;
-  }
-
-  const char* c_str_;
-  size_t length_;
+  String();  // Not meant to be instantiated.
 };  // class String
 
-// Streams a String to an ostream.  Each '\0' character in the String
-// is replaced with "\\0".
-inline ::std::ostream& operator<<(::std::ostream& os, const String& str) {
-  if (str.c_str() == NULL) {
-    os << "(null)";
-  } else {
-    const char* const c_str = str.c_str();
-    for (size_t i = 0; i != str.length(); i++) {
-      if (c_str[i] == '\0') {
-        os << "\\0";
-      } else {
-        os << c_str[i];
-      }
-    }
-  }
-  return os;
-}
-
-// Gets the content of the stringstream's buffer as a String.  Each '\0'
+// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
 // character in the buffer is replaced with "\\0".
-GTEST_API_ String StringStreamToString(::std::stringstream* stream);
-
-// Converts a streamable value to a String.  A NULL pointer is
-// converted to "(null)".  When the input value is a ::string,
-// ::std::string, ::wstring, or ::std::wstring object, each NUL
-// character in it is replaced with "\\0".
-
-// Declared here but defined in gtest.h, so that it has access
-// to the definition of the Message class, required by the ARM
-// compiler.
-template <typename T>
-String StreamableToString(const T& streamable);
+GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
 
 }  // namespace internal
 }  // namespace testing
diff --git a/src/gtest/include/gtest/internal/gtest-tuple.h b/src/gtest/include/gtest/internal/gtest-tuple.h
index d1af50e..7b3dfc3 100644
--- a/src/gtest/include/gtest/internal/gtest-tuple.h
+++ b/src/gtest/include/gtest/internal/gtest-tuple.h
@@ -1,4 +1,6 @@ 
-// This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
+// This file was GENERATED by command:
+//     pump.py gtest-tuple.h.pump
+// DO NOT EDIT BY HAND!!!
 
 // Copyright 2009 Google Inc.
 // All Rights Reserved.
@@ -140,34 +142,54 @@  template <bool kIndexValid, int kIndex, class Tuple>
 struct TupleElement;
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 0, GTEST_10_TUPLE_(T)> { typedef T0 type; };
+struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
+  typedef T0 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 1, GTEST_10_TUPLE_(T)> { typedef T1 type; };
+struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
+  typedef T1 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 2, GTEST_10_TUPLE_(T)> { typedef T2 type; };
+struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
+  typedef T2 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 3, GTEST_10_TUPLE_(T)> { typedef T3 type; };
+struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
+  typedef T3 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 4, GTEST_10_TUPLE_(T)> { typedef T4 type; };
+struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
+  typedef T4 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 5, GTEST_10_TUPLE_(T)> { typedef T5 type; };
+struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
+  typedef T5 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 6, GTEST_10_TUPLE_(T)> { typedef T6 type; };
+struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
+  typedef T6 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 7, GTEST_10_TUPLE_(T)> { typedef T7 type; };
+struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
+  typedef T7 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 8, GTEST_10_TUPLE_(T)> { typedef T8 type; };
+struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
+  typedef T8 type;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> { typedef T9 type; };
+struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
+  typedef T9 type;
+};
 
 }  // namespace gtest_internal
 
@@ -708,37 +730,59 @@  inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
 template <typename Tuple> struct tuple_size;
 
 template <GTEST_0_TYPENAMES_(T)>
-struct tuple_size<GTEST_0_TUPLE_(T)> { static const int value = 0; };
+struct tuple_size<GTEST_0_TUPLE_(T) > {
+  static const int value = 0;
+};
 
 template <GTEST_1_TYPENAMES_(T)>
-struct tuple_size<GTEST_1_TUPLE_(T)> { static const int value = 1; };
+struct tuple_size<GTEST_1_TUPLE_(T) > {
+  static const int value = 1;
+};
 
 template <GTEST_2_TYPENAMES_(T)>
-struct tuple_size<GTEST_2_TUPLE_(T)> { static const int value = 2; };
+struct tuple_size<GTEST_2_TUPLE_(T) > {
+  static const int value = 2;
+};
 
 template <GTEST_3_TYPENAMES_(T)>
-struct tuple_size<GTEST_3_TUPLE_(T)> { static const int value = 3; };
+struct tuple_size<GTEST_3_TUPLE_(T) > {
+  static const int value = 3;
+};
 
 template <GTEST_4_TYPENAMES_(T)>
-struct tuple_size<GTEST_4_TUPLE_(T)> { static const int value = 4; };
+struct tuple_size<GTEST_4_TUPLE_(T) > {
+  static const int value = 4;
+};
 
 template <GTEST_5_TYPENAMES_(T)>
-struct tuple_size<GTEST_5_TUPLE_(T)> { static const int value = 5; };
+struct tuple_size<GTEST_5_TUPLE_(T) > {
+  static const int value = 5;
+};
 
 template <GTEST_6_TYPENAMES_(T)>
-struct tuple_size<GTEST_6_TUPLE_(T)> { static const int value = 6; };
+struct tuple_size<GTEST_6_TUPLE_(T) > {
+  static const int value = 6;
+};
 
 template <GTEST_7_TYPENAMES_(T)>
-struct tuple_size<GTEST_7_TUPLE_(T)> { static const int value = 7; };
+struct tuple_size<GTEST_7_TUPLE_(T) > {
+  static const int value = 7;
+};
 
 template <GTEST_8_TYPENAMES_(T)>
-struct tuple_size<GTEST_8_TUPLE_(T)> { static const int value = 8; };
+struct tuple_size<GTEST_8_TUPLE_(T) > {
+  static const int value = 8;
+};
 
 template <GTEST_9_TYPENAMES_(T)>
-struct tuple_size<GTEST_9_TUPLE_(T)> { static const int value = 9; };
+struct tuple_size<GTEST_9_TUPLE_(T) > {
+  static const int value = 9;
+};
 
 template <GTEST_10_TYPENAMES_(T)>
-struct tuple_size<GTEST_10_TUPLE_(T)> { static const int value = 10; };
+struct tuple_size<GTEST_10_TUPLE_(T) > {
+  static const int value = 10;
+};
 
 template <int k, class Tuple>
 struct tuple_element {
@@ -922,8 +966,8 @@  template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
 inline bool operator==(const GTEST_10_TUPLE_(T)& t,
                        const GTEST_10_TUPLE_(U)& u) {
   return gtest_internal::SameSizeTuplePrefixComparator<
-      tuple_size<GTEST_10_TUPLE_(T)>::value,
-      tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u);
+      tuple_size<GTEST_10_TUPLE_(T) >::value,
+      tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
 }
 
 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
diff --git a/src/gtest/include/gtest/internal/gtest-tuple.h.pump b/src/gtest/include/gtest/internal/gtest-tuple.h.pump
index ef51909..c7d9e03 100644
--- a/src/gtest/include/gtest/internal/gtest-tuple.h.pump
+++ b/src/gtest/include/gtest/internal/gtest-tuple.h.pump
@@ -118,8 +118,9 @@  struct TupleElement;
 
 $for i [[
 template <GTEST_$(n)_TYPENAMES_(T)>
-struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T)> [[]]
-{ typedef T$i type; };
+struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T) > {
+  typedef T$i type;
+};
 
 
 ]]
@@ -220,7 +221,9 @@  template <typename Tuple> struct tuple_size;
 
 $for j [[
 template <GTEST_$(j)_TYPENAMES_(T)>
-struct tuple_size<GTEST_$(j)_TUPLE_(T)> { static const int value = $j; };
+struct tuple_size<GTEST_$(j)_TUPLE_(T) > {
+  static const int value = $j;
+};
 
 
 ]]
@@ -302,8 +305,8 @@  template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
 inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t,
                        const GTEST_$(n)_TUPLE_(U)& u) {
   return gtest_internal::SameSizeTuplePrefixComparator<
-      tuple_size<GTEST_$(n)_TUPLE_(T)>::value,
-      tuple_size<GTEST_$(n)_TUPLE_(U)>::value>::Eq(t, u);
+      tuple_size<GTEST_$(n)_TUPLE_(T) >::value,
+      tuple_size<GTEST_$(n)_TUPLE_(U) >::value>::Eq(t, u);
 }
 
 template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
diff --git a/src/gtest/include/gtest/internal/gtest-type-util.h b/src/gtest/include/gtest/internal/gtest-type-util.h
index b7b01b0..e46f7cf 100644
--- a/src/gtest/include/gtest/internal/gtest-type-util.h
+++ b/src/gtest/include/gtest/internal/gtest-type-util.h
@@ -45,15 +45,14 @@ 
 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
 
 #include "gtest/internal/gtest-port.h"
-#include "gtest/internal/gtest-string.h"
 
 // #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
 // libstdc++ (which is where cxxabi.h comes from).
-# ifdef __GLIBCXX__
+# if GTEST_HAS_CXXABI_H_
 #  include <cxxabi.h>
 # elif defined(__HP_aCC)
 #  include <acxx_demangle.h>
-# endif  // __GLIBCXX__
+# endif  // GTEST_HASH_CXXABI_H_
 
 namespace testing {
 namespace internal {
@@ -62,24 +61,24 @@  namespace internal {
 // NB: This function is also used in Google Mock, so don't move it inside of
 // the typed-test-only section below.
 template <typename T>
-String GetTypeName() {
+std::string GetTypeName() {
 # if GTEST_HAS_RTTI
 
   const char* const name = typeid(T).name();
-#  if defined(__GLIBCXX__) || defined(__HP_aCC)
+#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
   int status = 0;
   // gcc's implementation of typeid(T).name() mangles the type name,
   // so we have to demangle it.
-#   ifdef __GLIBCXX__
+#   if GTEST_HAS_CXXABI_H_
   using abi::__cxa_demangle;
-#   endif // __GLIBCXX__
+#   endif  // GTEST_HAS_CXXABI_H_
   char* const readable_name = __cxa_demangle(name, 0, 0, &status);
-  const String name_str(status == 0 ? readable_name : name);
+  const std::string name_str(status == 0 ? readable_name : name);
   free(readable_name);
   return name_str;
 #  else
   return name;
-#  endif  // __GLIBCXX__ || __HP_aCC
+#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
 
 # else
 
@@ -3300,7 +3299,9 @@  struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
 // INSTANTIATE_TYPED_TEST_CASE_P().
 
 template <typename T>
-struct TypeList { typedef Types1<T> type; };
+struct TypeList {
+  typedef Types1<T> type;
+};
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5,
     typename T6, typename T7, typename T8, typename T9, typename T10,
diff --git a/src/gtest/include/gtest/internal/gtest-type-util.h.pump b/src/gtest/include/gtest/internal/gtest-type-util.h.pump
index 27f331d..251fdf0 100644
--- a/src/gtest/include/gtest/internal/gtest-type-util.h.pump
+++ b/src/gtest/include/gtest/internal/gtest-type-util.h.pump
@@ -43,15 +43,14 @@  $var n = 50  $$ Maximum length of type lists we want to support.
 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
 
 #include "gtest/internal/gtest-port.h"
-#include "gtest/internal/gtest-string.h"
 
 // #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
 // libstdc++ (which is where cxxabi.h comes from).
-# ifdef __GLIBCXX__
+# if GTEST_HAS_CXXABI_H_
 #  include <cxxabi.h>
 # elif defined(__HP_aCC)
 #  include <acxx_demangle.h>
-# endif  // __GLIBCXX__
+# endif  // GTEST_HASH_CXXABI_H_
 
 namespace testing {
 namespace internal {
@@ -60,24 +59,24 @@  namespace internal {
 // NB: This function is also used in Google Mock, so don't move it inside of
 // the typed-test-only section below.
 template <typename T>
-String GetTypeName() {
+std::string GetTypeName() {
 # if GTEST_HAS_RTTI
 
   const char* const name = typeid(T).name();
-#  if defined(__GLIBCXX__) || defined(__HP_aCC)
+#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
   int status = 0;
   // gcc's implementation of typeid(T).name() mangles the type name,
   // so we have to demangle it.
-#   ifdef __GLIBCXX__
+#   if GTEST_HAS_CXXABI_H_
   using abi::__cxa_demangle;
-#   endif // __GLIBCXX__
+#   endif  // GTEST_HAS_CXXABI_H_
   char* const readable_name = __cxa_demangle(name, 0, 0, &status);
-  const String name_str(status == 0 ? readable_name : name);
+  const std::string name_str(status == 0 ? readable_name : name);
   free(readable_name);
   return name_str;
 #  else
   return name;
-#  endif  // __GLIBCXX__ || __HP_aCC
+#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
 
 # else
 
@@ -279,7 +278,9 @@  struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> {
 // INSTANTIATE_TYPED_TEST_CASE_P().
 
 template <typename T>
-struct TypeList { typedef Types1<T> type; };
+struct TypeList {
+  typedef Types1<T> type;
+};
 
 
 $range i 1..n
diff --git a/src/gtest/src/gtest-death-test.cc b/src/gtest/src/gtest-death-test.cc
index 8b2e413..a6023fc 100644
--- a/src/gtest/src/gtest-death-test.cc
+++ b/src/gtest/src/gtest-death-test.cc
@@ -43,6 +43,11 @@ 
 # include <errno.h>
 # include <fcntl.h>
 # include <limits.h>
+
+# if GTEST_OS_LINUX
+#  include <signal.h>
+# endif  // GTEST_OS_LINUX
+
 # include <stdarg.h>
 
 # if GTEST_OS_WINDOWS
@@ -52,6 +57,10 @@ 
 #  include <sys/wait.h>
 # endif  // GTEST_OS_WINDOWS
 
+# if GTEST_OS_QNX
+#  include <spawn.h>
+# endif  // GTEST_OS_QNX
+
 #endif  // GTEST_HAS_DEATH_TEST
 
 #include "gtest/gtest-message.h"
@@ -100,13 +109,42 @@  GTEST_DEFINE_string_(
     "Indicates the file, line number, temporal index of "
     "the single death test to run, and a file descriptor to "
     "which a success code may be sent, all separated by "
-    "colons.  This flag is specified if and only if the current "
+    "the '|' characters.  This flag is specified if and only if the current "
     "process is a sub-process launched for running a thread-safe "
     "death test.  FOR INTERNAL USE ONLY.");
 }  // namespace internal
 
 #if GTEST_HAS_DEATH_TEST
 
+namespace internal {
+
+// Valid only for fast death tests. Indicates the code is running in the
+// child process of a fast style death test.
+static bool g_in_fast_death_test_child = false;
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+bool InDeathTestChild() {
+# if GTEST_OS_WINDOWS
+
+  // On Windows, death tests are thread-safe regardless of the value of the
+  // death_test_style flag.
+  return !GTEST_FLAG(internal_run_death_test).empty();
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe")
+    return !GTEST_FLAG(internal_run_death_test).empty();
+  else
+    return g_in_fast_death_test_child;
+#endif
+}
+
+}  // namespace internal
+
 // ExitedWithCode constructor.
 ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
 }
@@ -141,7 +179,7 @@  namespace internal {
 
 // Generates a textual description of a given exit code, in the format
 // specified by wait(2).
-static String ExitSummary(int exit_code) {
+static std::string ExitSummary(int exit_code) {
   Message m;
 
 # if GTEST_OS_WINDOWS
@@ -176,7 +214,7 @@  bool ExitedUnsuccessfully(int exit_status) {
 // one thread running, or cannot determine the number of threads, prior
 // to executing the given statement.  It is the responsibility of the
 // caller not to pass a thread_count of 1.
-static String DeathTestThreadWarning(size_t thread_count) {
+static std::string DeathTestThreadWarning(size_t thread_count) {
   Message msg;
   msg << "Death tests use fork(), which is unsafe particularly"
       << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
@@ -210,7 +248,7 @@  enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
 // message is propagated back to the parent process.  Otherwise, the
 // message is simply printed to stderr.  In either case, the program
 // then exits with status 1.
-void DeathTestAbort(const String& message) {
+void DeathTestAbort(const std::string& message) {
   // On a POSIX system, this function may be called from a threadsafe-style
   // death test child process, which operates on a very small stack.  Use
   // the heap for any additional non-minuscule memory requirements.
@@ -234,9 +272,10 @@  void DeathTestAbort(const String& message) {
 # define GTEST_DEATH_TEST_CHECK_(expression) \
   do { \
     if (!::testing::internal::IsTrue(expression)) { \
-      DeathTestAbort(::testing::internal::String::Format( \
-          "CHECK failed: File %s, line %d: %s", \
-          __FILE__, __LINE__, #expression)); \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression); \
     } \
   } while (::testing::internal::AlwaysFalse())
 
@@ -254,15 +293,16 @@  void DeathTestAbort(const String& message) {
       gtest_retval = (expression); \
     } while (gtest_retval == -1 && errno == EINTR); \
     if (gtest_retval == -1) { \
-      DeathTestAbort(::testing::internal::String::Format( \
-          "CHECK failed: File %s, line %d: %s != -1", \
-          __FILE__, __LINE__, #expression)); \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression + " != -1"); \
     } \
   } while (::testing::internal::AlwaysFalse())
 
 // Returns the message describing the last system error in errno.
-String GetLastErrnoDescription() {
-    return String(errno == 0 ? "" : posix::StrError(errno));
+std::string GetLastErrnoDescription() {
+    return errno == 0 ? "" : posix::StrError(errno);
 }
 
 // This is called from a death test parent process to read a failure
@@ -312,11 +352,11 @@  const char* DeathTest::LastMessage() {
   return last_death_test_message_.c_str();
 }
 
-void DeathTest::set_last_death_test_message(const String& message) {
+void DeathTest::set_last_death_test_message(const std::string& message) {
   last_death_test_message_ = message;
 }
 
-String DeathTest::last_death_test_message_;
+std::string DeathTest::last_death_test_message_;
 
 // Provides cross platform implementation for some death functionality.
 class DeathTestImpl : public DeathTest {
@@ -491,7 +531,7 @@  bool DeathTestImpl::Passed(bool status_ok) {
   if (!spawned())
     return false;
 
-  const String error_message = GetCapturedStderr();
+  const std::string error_message = GetCapturedStderr();
 
   bool success = false;
   Message buffer;
@@ -673,22 +713,19 @@  DeathTest::TestRole WindowsDeathTest::AssumeRole() {
       FALSE,   // The initial state is non-signalled.
       NULL));  // The even is unnamed.
   GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
-  const String filter_flag = String::Format("--%s%s=%s.%s",
-                                            GTEST_FLAG_PREFIX_, kFilterFlag,
-                                            info->test_case_name(),
-                                            info->name());
-  const String internal_flag = String::Format(
-    "--%s%s=%s|%d|%d|%u|%Iu|%Iu",
-      GTEST_FLAG_PREFIX_,
-      kInternalRunDeathTestFlag,
-      file_, line_,
-      death_test_index,
-      static_cast<unsigned int>(::GetCurrentProcessId()),
-      // size_t has the same with as pointers on both 32-bit and 64-bit
+  const std::string filter_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" +
+      info->test_case_name() + "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
+      "=" + file_ + "|" + StreamableToString(line_) + "|" +
+      StreamableToString(death_test_index) + "|" +
+      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
+      // size_t has the same width as pointers on both 32-bit and 64-bit
       // Windows platforms.
       // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
-      reinterpret_cast<size_t>(write_handle),
-      reinterpret_cast<size_t>(event_handle_.Get()));
+      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
+      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
 
   char executable_path[_MAX_PATH + 1];  // NOLINT
   GTEST_DEATH_TEST_CHECK_(
@@ -696,10 +733,9 @@  DeathTest::TestRole WindowsDeathTest::AssumeRole() {
                                             executable_path,
                                             _MAX_PATH));
 
-  String command_line = String::Format("%s %s \"%s\"",
-                                       ::GetCommandLineA(),
-                                       filter_flag.c_str(),
-                                       internal_flag.c_str());
+  std::string command_line =
+      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
+      internal_flag + "\"";
 
   DeathTest::set_last_death_test_message("");
 
@@ -816,6 +852,7 @@  DeathTest::TestRole NoExecDeathTest::AssumeRole() {
     // Event forwarding to the listeners of event listener API mush be shut
     // down in death test subprocesses.
     GetUnitTestImpl()->listeners()->SuppressEventForwarding();
+    g_in_fast_death_test_child = true;
     return EXECUTE_TEST;
   } else {
     GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
@@ -835,6 +872,11 @@  class ExecDeathTest : public ForkingDeathTest {
       ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
   virtual TestRole AssumeRole();
  private:
+  static ::std::vector<testing::internal::string>
+  GetArgvsForDeathTestChildProcess() {
+    ::std::vector<testing::internal::string> args = GetInjectableArgvs();
+    return args;
+  }
   // The name of the file in which the death test is located.
   const char* const file_;
   // The line number on which the death test is located.
@@ -869,6 +911,7 @@  class Arguments {
   char* const* Argv() {
     return &args_[0];
   }
+
  private:
   std::vector<char*> args_;
 };
@@ -894,6 +937,7 @@  extern "C" char** environ;
 inline char** GetEnviron() { return environ; }
 #  endif  // GTEST_OS_MAC
 
+#  if !GTEST_OS_QNX
 // The main function for a threadsafe-style death test child process.
 // This function is called in a clone()-ed process and thus must avoid
 // any potentially unsafe operations like malloc or libc functions.
@@ -908,9 +952,8 @@  static int ExecDeathTestChildMain(void* child_arg) {
       UnitTest::GetInstance()->original_working_dir();
   // We can safely call chdir() as it's a direct system call.
   if (chdir(original_dir) != 0) {
-    DeathTestAbort(String::Format("chdir(\"%s\") failed: %s",
-                                  original_dir,
-                                  GetLastErrnoDescription().c_str()));
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
     return EXIT_FAILURE;
   }
 
@@ -920,12 +963,12 @@  static int ExecDeathTestChildMain(void* child_arg) {
   // invoke the test program via a valid path that contains at least
   // one path separator.
   execve(args->argv[0], args->argv, GetEnviron());
-  DeathTestAbort(String::Format("execve(%s, ...) in %s failed: %s",
-                                args->argv[0],
-                                original_dir,
-                                GetLastErrnoDescription().c_str()));
+  DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
+                 original_dir + " failed: " +
+                 GetLastErrnoDescription());
   return EXIT_FAILURE;
 }
+#  endif  // !GTEST_OS_QNX
 
 // Two utility routines that together determine the direction the stack
 // grows.
@@ -936,25 +979,75 @@  static int ExecDeathTestChildMain(void* child_arg) {
 // GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
 // StackLowerThanAddress into StackGrowsDown, which then doesn't give
 // correct answer.
-bool StackLowerThanAddress(const void* ptr) GTEST_NO_INLINE_;
-bool StackLowerThanAddress(const void* ptr) {
+void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_;
+void StackLowerThanAddress(const void* ptr, bool* result) {
   int dummy;
-  return &dummy < ptr;
+  *result = (&dummy < ptr);
 }
 
 bool StackGrowsDown() {
   int dummy;
-  return StackLowerThanAddress(&dummy);
+  bool result;
+  StackLowerThanAddress(&dummy, &result);
+  return result;
 }
 
-// A threadsafe implementation of fork(2) for threadsafe-style death tests
-// that uses clone(2).  It dies with an error message if anything goes
-// wrong.
-static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
+// Spawns a child process with the same executable as the current process in
+// a thread-safe manner and instructs it to run the death test.  The
+// implementation uses fork(2) + exec.  On systems where clone(2) is
+// available, it is used instead, being slightly more thread-safe.  On QNX,
+// fork supports only single-threaded environments, so this function uses
+// spawn(2) there instead.  The function dies with an error message if
+// anything goes wrong.
+static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
   ExecDeathTestArgs args = { argv, close_fd };
   pid_t child_pid = -1;
 
-#  if GTEST_HAS_CLONE
+#  if GTEST_OS_QNX
+  // Obtains the current directory and sets it to be closed in the child
+  // process.
+  const int cwd_fd = open(".", O_RDONLY);
+  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  int fd_flags;
+  // Set close_fd to be closed after spawn.
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
+                                        fd_flags | FD_CLOEXEC));
+  struct inheritance inherit = {0};
+  // spawn is a system call.
+  child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron());
+  // Restores the current working directory.
+  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
+
+#  else   // GTEST_OS_QNX
+#   if GTEST_OS_LINUX
+  // When a SIGPROF signal is received while fork() or clone() are executing,
+  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
+  // it after the call to fork()/clone() is complete.
+  struct sigaction saved_sigprof_action;
+  struct sigaction ignore_sigprof_action;
+  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
+  sigemptyset(&ignore_sigprof_action.sa_mask);
+  ignore_sigprof_action.sa_handler = SIG_IGN;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
+      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
+#   endif  // GTEST_OS_LINUX
+
+#   if GTEST_HAS_CLONE
   const bool use_fork = GTEST_FLAG(death_test_use_fork);
 
   if (!use_fork) {
@@ -964,21 +1057,37 @@  static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
     void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
                              MAP_ANON | MAP_PRIVATE, -1, 0);
     GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
+
+    // Maximum stack alignment in bytes:  For a downward-growing stack, this
+    // amount is subtracted from size of the stack space to get an address
+    // that is within the stack space and is aligned on all systems we care
+    // about.  As far as I know there is no ABI with stack alignment greater
+    // than 64.  We assume stack and stack_size already have alignment of
+    // kMaxStackAlignment.
+    const size_t kMaxStackAlignment = 64;
     void* const stack_top =
-        static_cast<char*>(stack) + (stack_grows_down ? stack_size : 0);
+        static_cast<char*>(stack) +
+            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
+    GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
+        reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0);
 
     child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
 
     GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
   }
-#  else
+#   else
   const bool use_fork = true;
-#  endif  // GTEST_HAS_CLONE
+#   endif  // GTEST_HAS_CLONE
 
   if (use_fork && (child_pid = fork()) == 0) {
       ExecDeathTestChildMain(&args);
       _exit(0);
   }
+#  endif  // GTEST_OS_QNX
+#  if GTEST_OS_LINUX
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(
+      sigaction(SIGPROF, &saved_sigprof_action, NULL));
+#  endif  // GTEST_OS_LINUX
 
   GTEST_DEATH_TEST_CHECK_(child_pid != -1);
   return child_pid;
@@ -1006,16 +1115,16 @@  DeathTest::TestRole ExecDeathTest::AssumeRole() {
   // it be closed when the child process does an exec:
   GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
 
-  const String filter_flag =
-      String::Format("--%s%s=%s.%s",
-                     GTEST_FLAG_PREFIX_, kFilterFlag,
-                     info->test_case_name(), info->name());
-  const String internal_flag =
-      String::Format("--%s%s=%s|%d|%d|%d",
-                     GTEST_FLAG_PREFIX_, kInternalRunDeathTestFlag,
-                     file_, line_, death_test_index, pipe_fd[1]);
+  const std::string filter_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
+      + info->test_case_name() + "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
+      + file_ + "|" + StreamableToString(line_) + "|"
+      + StreamableToString(death_test_index) + "|"
+      + StreamableToString(pipe_fd[1]);
   Arguments args;
-  args.AddArguments(GetArgvs());
+  args.AddArguments(GetArgvsForDeathTestChildProcess());
   args.AddArgument(filter_flag.c_str());
   args.AddArgument(internal_flag.c_str());
 
@@ -1026,7 +1135,7 @@  DeathTest::TestRole ExecDeathTest::AssumeRole() {
   // is necessary.
   FlushInfoLog();
 
-  const pid_t child_pid = ExecDeathTestFork(args.Argv(), pipe_fd[0]);
+  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
   GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
   set_child_pid(child_pid);
   set_read_fd(pipe_fd[0]);
@@ -1052,9 +1161,10 @@  bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
 
   if (flag != NULL) {
     if (death_test_index > flag->index()) {
-      DeathTest::set_last_death_test_message(String::Format(
-          "Death test count (%d) somehow exceeded expected maximum (%d)",
-          death_test_index, flag->index()));
+      DeathTest::set_last_death_test_message(
+          "Death test count (" + StreamableToString(death_test_index)
+          + ") somehow exceeded expected maximum ("
+          + StreamableToString(flag->index()) + ")");
       return false;
     }
 
@@ -1083,9 +1193,9 @@  bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
 # endif  // GTEST_OS_WINDOWS
 
   else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
-    DeathTest::set_last_death_test_message(String::Format(
-        "Unknown death test style \"%s\" encountered",
-        GTEST_FLAG(death_test_style).c_str()));
+    DeathTest::set_last_death_test_message(
+        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
+        + "\" encountered");
     return false;
   }
 
@@ -1123,8 +1233,8 @@  int GetStatusFileDescriptor(unsigned int parent_process_id,
                                                    FALSE,  // Non-inheritable.
                                                    parent_process_id));
   if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
-    DeathTestAbort(String::Format("Unable to open parent process %u",
-                                  parent_process_id));
+    DeathTestAbort("Unable to open parent process " +
+                   StreamableToString(parent_process_id));
   }
 
   // TODO(vladl@google.com): Replace the following check with a
@@ -1144,9 +1254,10 @@  int GetStatusFileDescriptor(unsigned int parent_process_id,
                                  // DUPLICATE_SAME_ACCESS is used.
                          FALSE,  // Request non-inheritable handler.
                          DUPLICATE_SAME_ACCESS)) {
-    DeathTestAbort(String::Format(
-        "Unable to duplicate the pipe handle %Iu from the parent process %u",
-        write_handle_as_size_t, parent_process_id));
+    DeathTestAbort("Unable to duplicate the pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
   }
 
   const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
@@ -1157,17 +1268,18 @@  int GetStatusFileDescriptor(unsigned int parent_process_id,
                          0x0,
                          FALSE,
                          DUPLICATE_SAME_ACCESS)) {
-    DeathTestAbort(String::Format(
-        "Unable to duplicate the event handle %Iu from the parent process %u",
-        event_handle_as_size_t, parent_process_id));
+    DeathTestAbort("Unable to duplicate the event handle " +
+                   StreamableToString(event_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
   }
 
   const int write_fd =
       ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
   if (write_fd == -1) {
-    DeathTestAbort(String::Format(
-        "Unable to convert pipe handle %Iu to a file descriptor",
-        write_handle_as_size_t));
+    DeathTestAbort("Unable to convert pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " to a file descriptor");
   }
 
   // Signals the parent that the write end of the pipe has been acquired
@@ -1204,9 +1316,8 @@  InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
       || !ParseNaturalNumber(fields[3], &parent_process_id)
       || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
       || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
-    DeathTestAbort(String::Format(
-        "Bad --gtest_internal_run_death_test flag: %s",
-        GTEST_FLAG(internal_run_death_test).c_str()));
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
+                   GTEST_FLAG(internal_run_death_test));
   }
   write_fd = GetStatusFileDescriptor(parent_process_id,
                                      write_handle_as_size_t,
@@ -1217,9 +1328,8 @@  InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
       || !ParseNaturalNumber(fields[1], &line)
       || !ParseNaturalNumber(fields[2], &index)
       || !ParseNaturalNumber(fields[3], &write_fd)) {
-    DeathTestAbort(String::Format(
-        "Bad --gtest_internal_run_death_test flag: %s",
-        GTEST_FLAG(internal_run_death_test).c_str()));
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
+        + GTEST_FLAG(internal_run_death_test));
   }
 
 # endif  // GTEST_OS_WINDOWS
diff --git a/src/gtest/src/gtest-filepath.cc b/src/gtest/src/gtest-filepath.cc
index 91b2571..6be58b6 100644
--- a/src/gtest/src/gtest-filepath.cc
+++ b/src/gtest/src/gtest-filepath.cc
@@ -29,6 +29,7 @@ 
 //
 // Authors: keith.ray@gmail.com (Keith Ray)
 
+#include "gtest/gtest-message.h"
 #include "gtest/internal/gtest-filepath.h"
 #include "gtest/internal/gtest-port.h"
 
@@ -39,8 +40,8 @@ 
 #elif GTEST_OS_WINDOWS
 # include <direct.h>
 # include <io.h>
-#elif GTEST_OS_SYMBIAN || GTEST_OS_NACL
-// Symbian OpenC and NaCl have PATH_MAX in sys/syslimits.h
+#elif GTEST_OS_SYMBIAN
+// Symbian OpenC has PATH_MAX in sys/syslimits.h
 # include <sys/syslimits.h>
 #else
 # include <limits.h>
@@ -116,9 +117,10 @@  FilePath FilePath::GetCurrentDir() {
 // FilePath("dir/file"). If a case-insensitive extension is not
 // found, returns a copy of the original FilePath.
 FilePath FilePath::RemoveExtension(const char* extension) const {
-  String dot_extension(String::Format(".%s", extension));
-  if (pathname_.EndsWithCaseInsensitive(dot_extension.c_str())) {
-    return FilePath(String(pathname_.c_str(), pathname_.length() - 4));
+  const std::string dot_extension = std::string(".") + extension;
+  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
+    return FilePath(pathname_.substr(
+        0, pathname_.length() - dot_extension.length()));
   }
   return *this;
 }
@@ -147,7 +149,7 @@  const char* FilePath::FindLastPathSeparator() const {
 // On Windows platform, '\' is the path separator, otherwise it is '/'.
 FilePath FilePath::RemoveDirectoryName() const {
   const char* const last_sep = FindLastPathSeparator();
-  return last_sep ? FilePath(String(last_sep + 1)) : *this;
+  return last_sep ? FilePath(last_sep + 1) : *this;
 }
 
 // RemoveFileName returns the directory path with the filename removed.
@@ -158,9 +160,9 @@  FilePath FilePath::RemoveDirectoryName() const {
 // On Windows platform, '\' is the path separator, otherwise it is '/'.
 FilePath FilePath::RemoveFileName() const {
   const char* const last_sep = FindLastPathSeparator();
-  String dir;
+  std::string dir;
   if (last_sep) {
-    dir = String(c_str(), last_sep + 1 - c_str());
+    dir = std::string(c_str(), last_sep + 1 - c_str());
   } else {
     dir = kCurrentDirectoryString;
   }
@@ -177,11 +179,12 @@  FilePath FilePath::MakeFileName(const FilePath& directory,
                                 const FilePath& base_name,
                                 int number,
                                 const char* extension) {
-  String file;
+  std::string file;
   if (number == 0) {
-    file = String::Format("%s.%s", base_name.c_str(), extension);
+    file = base_name.string() + "." + extension;
   } else {
-    file = String::Format("%s_%d.%s", base_name.c_str(), number, extension);
+    file = base_name.string() + "_" + StreamableToString(number)
+        + "." + extension;
   }
   return ConcatPaths(directory, FilePath(file));
 }
@@ -193,8 +196,7 @@  FilePath FilePath::ConcatPaths(const FilePath& directory,
   if (directory.IsEmpty())
     return relative_path;
   const FilePath dir(directory.RemoveTrailingPathSeparator());
-  return FilePath(String::Format("%s%c%s", dir.c_str(), kPathSeparator,
-                                 relative_path.c_str()));
+  return FilePath(dir.string() + kPathSeparator + relative_path.string());
 }
 
 // Returns true if pathname describes something findable in the file-system,
@@ -338,7 +340,7 @@  bool FilePath::CreateFolder() const {
 // On Windows platform, uses \ as the separator, other platforms use /.
 FilePath FilePath::RemoveTrailingPathSeparator() const {
   return IsDirectory()
-      ? FilePath(String(pathname_.c_str(), pathname_.length() - 1))
+      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
       : *this;
 }
 
diff --git a/src/gtest/src/gtest-internal-inl.h b/src/gtest/src/gtest-internal-inl.h
index 65a2101..35df303 100644
--- a/src/gtest/src/gtest-internal-inl.h
+++ b/src/gtest/src/gtest-internal-inl.h
@@ -58,6 +58,11 @@ 
 
 #include "gtest/internal/gtest-port.h"
 
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+#endif
+
 #if GTEST_OS_WINDOWS
 # include <windows.h>  // NOLINT
 #endif  // GTEST_OS_WINDOWS
@@ -112,6 +117,12 @@  GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
 // Formats the given time in milliseconds as seconds.
 GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
 
+// Converts the given time in milliseconds to a date string in the ISO 8601
+// format, without the timezone information.  N.B.: due to the use the
+// non-reentrant localtime() function, this function is not thread safe.  Do
+// not use it in any code that can be called from multiple threads.
+GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
+
 // Parses a string for an Int32 flag, in the form of "--flag=value".
 //
 // On success, stores the value of the flag in *value, and returns
@@ -190,37 +201,35 @@  class GTestFlagSaver {
     GTEST_FLAG(stream_result_to) = stream_result_to_;
     GTEST_FLAG(throw_on_failure) = throw_on_failure_;
   }
+
  private:
   // Fields for saving the original values of flags.
   bool also_run_disabled_tests_;
   bool break_on_failure_;
   bool catch_exceptions_;
-  String color_;
-  String death_test_style_;
+  std::string color_;
+  std::string death_test_style_;
   bool death_test_use_fork_;
-  String filter_;
-  String internal_run_death_test_;
+  std::string filter_;
+  std::string internal_run_death_test_;
   bool list_tests_;
-  String output_;
+  std::string output_;
   bool print_time_;
-  bool pretty_;
   internal::Int32 random_seed_;
   internal::Int32 repeat_;
   bool shuffle_;
   internal::Int32 stack_trace_depth_;
-  String stream_result_to_;
+  std::string stream_result_to_;
   bool throw_on_failure_;
 } GTEST_ATTRIBUTE_UNUSED_;
 
 // Converts a Unicode code point to a narrow string in UTF-8 encoding.
 // code_point parameter is of type UInt32 because wchar_t may not be
 // wide enough to contain a code point.
-// The output buffer str must containt at least 32 characters.
-// The function returns the address of the output buffer.
 // If the code_point is not a valid Unicode code point
-// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output
-// as '(Invalid Unicode 0xXXXXXXXX)'.
-GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str);
+// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
+// to "(Invalid Unicode 0xXXXXXXXX)".
+GTEST_API_ std::string CodePointToUtf8(UInt32 code_point);
 
 // Converts a wide string to a narrow string in UTF-8 encoding.
 // The wide string is assumed to have the following encoding:
@@ -235,7 +244,7 @@  GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str);
 // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
 // and contains invalid UTF-16 surrogate pairs, values in those pairs
 // will be encoded as individual Unicode characters from Basic Normal Plane.
-GTEST_API_ String WideStringToUtf8(const wchar_t* str, int num_chars);
+GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
 
 // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
 // if the variable is present. If a file already exists at this location, this
@@ -339,16 +348,15 @@  class TestPropertyKeyIs {
   // Constructor.
   //
   // TestPropertyKeyIs has NO default constructor.
-  explicit TestPropertyKeyIs(const char* key)
-      : key_(key) {}
+  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
 
   // Returns true iff the test name of test property matches on key_.
   bool operator()(const TestProperty& test_property) const {
-    return String(test_property.key()).Compare(key_) == 0;
+    return test_property.key() == key_;
   }
 
  private:
-  String key_;
+  std::string key_;
 };
 
 // Class UnitTestOptions.
@@ -366,12 +374,12 @@  class GTEST_API_ UnitTestOptions {
   // Functions for processing the gtest_output flag.
 
   // Returns the output format, or "" for normal printed output.
-  static String GetOutputFormat();
+  static std::string GetOutputFormat();
 
   // Returns the absolute path of the requested output file, or the
   // default (test_detail.xml in the original working directory) if
   // none was explicitly specified.
-  static String GetAbsolutePathToOutputFile();
+  static std::string GetAbsolutePathToOutputFile();
 
   // Functions for processing the gtest_filter flag.
 
@@ -384,8 +392,8 @@  class GTEST_API_ UnitTestOptions {
 
   // Returns true iff the user-specified filter matches the test case
   // name and the test name.
-  static bool FilterMatchesTest(const String &test_case_name,
-                                const String &test_name);
+  static bool FilterMatchesTest(const std::string &test_case_name,
+                                const std::string &test_name);
 
 #if GTEST_OS_WINDOWS
   // Function for supporting the gtest_catch_exception flag.
@@ -398,7 +406,7 @@  class GTEST_API_ UnitTestOptions {
 
   // Returns true if "name" matches the ':' separated list of glob-style
   // filters in "filter".
-  static bool MatchesFilter(const String& name, const char* filter);
+  static bool MatchesFilter(const std::string& name, const char* filter);
 };
 
 // Returns the current application's name, removing directory path if that
@@ -411,13 +419,13 @@  class OsStackTraceGetterInterface {
   OsStackTraceGetterInterface() {}
   virtual ~OsStackTraceGetterInterface() {}
 
-  // Returns the current OS stack trace as a String.  Parameters:
+  // Returns the current OS stack trace as an std::string.  Parameters:
   //
   //   max_depth  - the maximum number of stack frames to be included
   //                in the trace.
   //   skip_count - the number of top frames to be skipped; doesn't count
   //                against max_depth.
-  virtual String CurrentStackTrace(int max_depth, int skip_count) = 0;
+  virtual string CurrentStackTrace(int max_depth, int skip_count) = 0;
 
   // UponLeavingGTest() should be called immediately before Google Test calls
   // user code. It saves some information about the current stack that
@@ -432,8 +440,11 @@  class OsStackTraceGetterInterface {
 class OsStackTraceGetter : public OsStackTraceGetterInterface {
  public:
   OsStackTraceGetter() : caller_frame_(NULL) {}
-  virtual String CurrentStackTrace(int max_depth, int skip_count);
-  virtual void UponLeavingGTest();
+
+  virtual string CurrentStackTrace(int max_depth, int skip_count)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  virtual void UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_);
 
   // This string is inserted in place of stack frames that are part of
   // Google Test's implementation.
@@ -455,7 +466,7 @@  class OsStackTraceGetter : public OsStackTraceGetterInterface {
 struct TraceInfo {
   const char* file;
   int line;
-  String message;
+  std::string message;
 };
 
 // This is the default global test part result reporter used in UnitTestImpl.
@@ -539,15 +550,25 @@  class GTEST_API_ UnitTestImpl {
   // Gets the number of failed tests.
   int failed_test_count() const;
 
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
   // Gets the number of disabled tests.
   int disabled_test_count() const;
 
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
   // Gets the number of all tests.
   int total_test_count() const;
 
   // Gets the number of tests that should run.
   int test_to_run_count() const;
 
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
   // Gets the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const { return elapsed_time_; }
 
@@ -596,7 +617,7 @@  class GTEST_API_ UnitTestImpl {
   // getter, and returns it.
   OsStackTraceGetterInterface* os_stack_trace_getter();
 
-  // Returns the current OS stack trace as a String.
+  // Returns the current OS stack trace as an std::string.
   //
   // The maximum number of stack frames to be included is specified by
   // the gtest_stack_trace_depth flag.  The skip_count parameter
@@ -606,7 +627,7 @@  class GTEST_API_ UnitTestImpl {
   // For example, if Foo() calls Bar(), which in turn calls
   // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
   // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-  String CurrentOsStackTraceExceptTop(int skip_count);
+  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
 
   // Finds and returns a TestCase with the given name.  If one doesn't
   // exist, creates one and returns it.
@@ -696,6 +717,12 @@  class GTEST_API_ UnitTestImpl {
     ad_hoc_test_result_.Clear();
   }
 
+  // Adds a TestProperty to the current TestResult object when invoked in a
+  // context of a test or a test case, or to the global property set. If the
+  // result already contains a property with the same key, the value will be
+  // updated.
+  void RecordProperty(const TestProperty& test_property);
+
   enum ReactionToSharding {
     HONOR_SHARDING_PROTOCOL,
     IGNORE_SHARDING_PROTOCOL
@@ -880,6 +907,10 @@  class GTEST_API_ UnitTestImpl {
   // Our random number generator.
   internal::Random random_;
 
+  // The time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp_;
+
   // How long the test took to run, in milliseconds.
   TimeInMillis elapsed_time_;
 
@@ -935,7 +966,7 @@  GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
 
 // Returns the message describing the last system error, regardless of the
 // platform.
-GTEST_API_ String GetLastErrnoDescription();
+GTEST_API_ std::string GetLastErrnoDescription();
 
 # if GTEST_OS_WINDOWS
 // Provides leak-safe Windows kernel handle ownership.
@@ -1018,8 +1049,9 @@  bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
 class TestResultAccessor {
  public:
   static void RecordProperty(TestResult* test_result,
+                             const std::string& xml_element,
                              const TestProperty& property) {
-    test_result->RecordProperty(property);
+    test_result->RecordProperty(xml_element, property);
   }
 
   static void ClearTestPartResults(TestResult* test_result) {
@@ -1032,6 +1064,154 @@  class TestResultAccessor {
   }
 };
 
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Streams test results to the given port on the given host machine.
+class StreamingListener : public EmptyTestEventListener {
+ public:
+  // Abstract base class for writing strings to a socket.
+  class AbstractSocketWriter {
+   public:
+    virtual ~AbstractSocketWriter() {}
+
+    // Sends a string to the socket.
+    virtual void Send(const string& message) = 0;
+
+    // Closes the socket.
+    virtual void CloseConnection() {}
+
+    // Sends a string and a newline to the socket.
+    void SendLn(const string& message) {
+      Send(message + "\n");
+    }
+  };
+
+  // Concrete class for actually writing strings to a socket.
+  class SocketWriter : public AbstractSocketWriter {
+   public:
+    SocketWriter(const string& host, const string& port)
+        : sockfd_(-1), host_name_(host), port_num_(port) {
+      MakeConnection();
+    }
+
+    virtual ~SocketWriter() {
+      if (sockfd_ != -1)
+        CloseConnection();
+    }
+
+    // Sends a string to the socket.
+    virtual void Send(const string& message) {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "Send() can be called only when there is a connection.";
+
+      const int len = static_cast<int>(message.length());
+      if (write(sockfd_, message.c_str(), len) != len) {
+        GTEST_LOG_(WARNING)
+            << "stream_result_to: failed to stream to "
+            << host_name_ << ":" << port_num_;
+      }
+    }
+
+   private:
+    // Creates a client socket and connects to the server.
+    void MakeConnection();
+
+    // Closes the socket.
+    void CloseConnection() {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "CloseConnection() can be called only when there is a connection.";
+
+      close(sockfd_);
+      sockfd_ = -1;
+    }
+
+    int sockfd_;  // socket file descriptor
+    const string host_name_;
+    const string port_num_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
+  };  // class SocketWriter
+
+  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
+  static string UrlEncode(const char* str);
+
+  StreamingListener(const string& host, const string& port)
+      : socket_writer_(new SocketWriter(host, port)) { Start(); }
+
+  explicit StreamingListener(AbstractSocketWriter* socket_writer)
+      : socket_writer_(socket_writer) { Start(); }
+
+  void OnTestProgramStart(const UnitTest& /* unit_test */) {
+    SendLn("event=TestProgramStart");
+  }
+
+  void OnTestProgramEnd(const UnitTest& unit_test) {
+    // Note that Google Test current only report elapsed time for each
+    // test iteration, not for the entire test program.
+    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
+
+    // Notify the streaming server to stop.
+    socket_writer_->CloseConnection();
+  }
+
+  void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
+    SendLn("event=TestIterationStart&iteration=" +
+           StreamableToString(iteration));
+  }
+
+  void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
+    SendLn("event=TestIterationEnd&passed=" +
+           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
+           StreamableToString(unit_test.elapsed_time()) + "ms");
+  }
+
+  void OnTestCaseStart(const TestCase& test_case) {
+    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
+  }
+
+  void OnTestCaseEnd(const TestCase& test_case) {
+    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
+           + "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
+           + "ms");
+  }
+
+  void OnTestStart(const TestInfo& test_info) {
+    SendLn(std::string("event=TestStart&name=") + test_info.name());
+  }
+
+  void OnTestEnd(const TestInfo& test_info) {
+    SendLn("event=TestEnd&passed=" +
+           FormatBool((test_info.result())->Passed()) +
+           "&elapsed_time=" +
+           StreamableToString((test_info.result())->elapsed_time()) + "ms");
+  }
+
+  void OnTestPartResult(const TestPartResult& test_part_result) {
+    const char* file_name = test_part_result.file_name();
+    if (file_name == NULL)
+      file_name = "";
+    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
+           "&line=" + StreamableToString(test_part_result.line_number()) +
+           "&message=" + UrlEncode(test_part_result.message()));
+  }
+
+ private:
+  // Sends the given message and a newline to the socket.
+  void SendLn(const string& message) { socket_writer_->SendLn(message); }
+
+  // Called at the start of streaming to notify the receiver what
+  // protocol we are using.
+  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
+
+  string FormatBool(bool value) { return value ? "1" : "0"; }
+
+  const scoped_ptr<AbstractSocketWriter> socket_writer_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
+};  // class StreamingListener
+
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
 }  // namespace internal
 }  // namespace testing
 
diff --git a/src/gtest/src/gtest-port.cc b/src/gtest/src/gtest-port.cc
index b860d48..0c4df5f 100644
--- a/src/gtest/src/gtest-port.cc
+++ b/src/gtest/src/gtest-port.cc
@@ -51,6 +51,11 @@ 
 # include <mach/vm_map.h>
 #endif  // GTEST_OS_MAC
 
+#if GTEST_OS_QNX
+# include <devctl.h>
+# include <sys/procfs.h>
+#endif  // GTEST_OS_QNX
+
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest-message.h"
 #include "gtest/internal/gtest-internal.h"
@@ -98,6 +103,26 @@  size_t GetThreadCount() {
   }
 }
 
+#elif GTEST_OS_QNX
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  const int fd = open("/proc/self/as", O_RDONLY);
+  if (fd < 0) {
+    return 0;
+  }
+  procfs_info process_info;
+  const int status =
+      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL);
+  close(fd);
+  if (status == EOK) {
+    return static_cast<size_t>(process_info.num_threads);
+  } else {
+    return 0;
+  }
+}
+
 #else
 
 size_t GetThreadCount() {
@@ -222,7 +247,7 @@  bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
 }
 
 // Helper function used by ValidateRegex() to format error messages.
-String FormatRegexSyntaxError(const char* regex, int index) {
+std::string FormatRegexSyntaxError(const char* regex, int index) {
   return (Message() << "Syntax error at index " << index
           << " in simple regular expression \"" << regex << "\": ").GetString();
 }
@@ -429,15 +454,15 @@  const char kUnknownFile[] = "unknown file";
 // Formats a source file path and a line number as they would appear
 // in an error message from the compiler used to compile this code.
 GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
-  const char* const file_name = file == NULL ? kUnknownFile : file;
+  const std::string file_name(file == NULL ? kUnknownFile : file);
 
   if (line < 0) {
-    return String::Format("%s:", file_name).c_str();
+    return file_name + ":";
   }
 #ifdef _MSC_VER
-  return String::Format("%s(%d):", file_name, line).c_str();
+  return file_name + "(" + StreamableToString(line) + "):";
 #else
-  return String::Format("%s:%d:", file_name, line).c_str();
+  return file_name + ":" + StreamableToString(line) + ":";
 #endif  // _MSC_VER
 }
 
@@ -448,12 +473,12 @@  GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
 // to the file location it produces, unlike FormatFileLocation().
 GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
     const char* file, int line) {
-  const char* const file_name = file == NULL ? kUnknownFile : file;
+  const std::string file_name(file == NULL ? kUnknownFile : file);
 
   if (line < 0)
     return file_name;
   else
-    return String::Format("%s:%d", file_name, line).c_str();
+    return file_name + ":" + StreamableToString(line);
 }
 
 
@@ -488,8 +513,7 @@  GTestLog::~GTestLog() {
 class CapturedStream {
  public:
   // The ctor redirects the stream to a temporary file.
-  CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
-
+  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
 # if GTEST_OS_WINDOWS
     char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
     char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
@@ -506,10 +530,29 @@  class CapturedStream {
                                     << temp_file_path;
     filename_ = temp_file_path;
 # else
-    // There's no guarantee that a test has write access to the
-    // current directory, so we create the temporary file in the /tmp
-    // directory instead.
+    // There's no guarantee that a test has write access to the current
+    // directory, so we create the temporary file in the /tmp directory
+    // instead. We use /tmp on most systems, and /sdcard on Android.
+    // That's because Android doesn't have /tmp.
+#  if GTEST_OS_LINUX_ANDROID
+    // Note: Android applications are expected to call the framework's
+    // Context.getExternalStorageDirectory() method through JNI to get
+    // the location of the world-writable SD Card directory. However,
+    // this requires a Context handle, which cannot be retrieved
+    // globally from native code. Doing so also precludes running the
+    // code as part of a regular standalone executable, which doesn't
+    // run in a Dalvik process (e.g. when running it through 'adb shell').
+    //
+    // The location /sdcard is directly accessible from native code
+    // and is the only location (unofficially) supported by the Android
+    // team. It's generally a symlink to the real SD Card mount point
+    // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
+    // other OEM-customized locations. Never rely on these, and always
+    // use /sdcard.
+    char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
+#  else
     char name_template[] = "/tmp/captured_stream.XXXXXX";
+#  endif  // GTEST_OS_LINUX_ANDROID
     const int captured_fd = mkstemp(name_template);
     filename_ = name_template;
 # endif  // GTEST_OS_WINDOWS
@@ -522,7 +565,7 @@  class CapturedStream {
     remove(filename_.c_str());
   }
 
-  String GetCapturedString() {
+  std::string GetCapturedString() {
     if (uncaptured_fd_ != -1) {
       // Restores the original stream.
       fflush(NULL);
@@ -532,14 +575,14 @@  class CapturedStream {
     }
 
     FILE* const file = posix::FOpen(filename_.c_str(), "r");
-    const String content = ReadEntireFile(file);
+    const std::string content = ReadEntireFile(file);
     posix::FClose(file);
     return content;
   }
 
  private:
-  // Reads the entire content of a file as a String.
-  static String ReadEntireFile(FILE* file);
+  // Reads the entire content of a file as an std::string.
+  static std::string ReadEntireFile(FILE* file);
 
   // Returns the size (in bytes) of a file.
   static size_t GetFileSize(FILE* file);
@@ -559,7 +602,7 @@  size_t CapturedStream::GetFileSize(FILE* file) {
 }
 
 // Reads the entire content of a file as a string.
-String CapturedStream::ReadEntireFile(FILE* file) {
+std::string CapturedStream::ReadEntireFile(FILE* file) {
   const size_t file_size = GetFileSize(file);
   char* const buffer = new char[file_size];
 
@@ -575,7 +618,7 @@  String CapturedStream::ReadEntireFile(FILE* file) {
     bytes_read += bytes_last_read;
   } while (bytes_last_read > 0 && bytes_read < file_size);
 
-  const String content(buffer, bytes_read);
+  const std::string content(buffer, bytes_read);
   delete[] buffer;
 
   return content;
@@ -598,8 +641,8 @@  void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
 }
 
 // Stops capturing the output stream and returns the captured string.
-String GetCapturedStream(CapturedStream** captured_stream) {
-  const String content = (*captured_stream)->GetCapturedString();
+std::string GetCapturedStream(CapturedStream** captured_stream) {
+  const std::string content = (*captured_stream)->GetCapturedString();
 
   delete *captured_stream;
   *captured_stream = NULL;
@@ -618,21 +661,37 @@  void CaptureStderr() {
 }
 
 // Stops capturing stdout and returns the captured string.
-String GetCapturedStdout() { return GetCapturedStream(&g_captured_stdout); }
+std::string GetCapturedStdout() {
+  return GetCapturedStream(&g_captured_stdout);
+}
 
 // Stops capturing stderr and returns the captured string.
-String GetCapturedStderr() { return GetCapturedStream(&g_captured_stderr); }
+std::string GetCapturedStderr() {
+  return GetCapturedStream(&g_captured_stderr);
+}
 
 #endif  // GTEST_HAS_STREAM_REDIRECTION
 
 #if GTEST_HAS_DEATH_TEST
 
 // A copy of all command line arguments.  Set by InitGoogleTest().
-::std::vector<String> g_argvs;
+::std::vector<testing::internal::string> g_argvs;
 
-// Returns the command line as a vector of strings.
-const ::std::vector<String>& GetArgvs() { return g_argvs; }
+static const ::std::vector<testing::internal::string>* g_injected_test_argvs =
+                                        NULL;  // Owned.
 
+void SetInjectableArgvs(const ::std::vector<testing::internal::string>* argvs) {
+  if (g_injected_test_argvs != argvs)
+    delete g_injected_test_argvs;
+  g_injected_test_argvs = argvs;
+}
+
+const ::std::vector<testing::internal::string>& GetInjectableArgvs() {
+  if (g_injected_test_argvs != NULL) {
+    return *g_injected_test_argvs;
+  }
+  return g_argvs;
+}
 #endif  // GTEST_HAS_DEATH_TEST
 
 #if GTEST_OS_WINDOWS_MOBILE
@@ -647,8 +706,8 @@  void Abort() {
 // Returns the name of the environment variable corresponding to the
 // given flag.  For example, FlagToEnvVar("foo") will return
 // "GTEST_FOO" in the open-source version.
-static String FlagToEnvVar(const char* flag) {
-  const String full_flag =
+static std::string FlagToEnvVar(const char* flag) {
+  const std::string full_flag =
       (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
 
   Message env_var;
@@ -705,7 +764,7 @@  bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
 //
 // The value is considered true iff it's not "0".
 bool BoolFromGTestEnv(const char* flag, bool default_value) {
-  const String env_var = FlagToEnvVar(flag);
+  const std::string env_var = FlagToEnvVar(flag);
   const char* const string_value = posix::GetEnv(env_var.c_str());
   return string_value == NULL ?
       default_value : strcmp(string_value, "0") != 0;
@@ -715,7 +774,7 @@  bool BoolFromGTestEnv(const char* flag, bool default_value) {
 // variable corresponding to the given flag; if it isn't set or
 // doesn't represent a valid 32-bit integer, returns default_value.
 Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
-  const String env_var = FlagToEnvVar(flag);
+  const std::string env_var = FlagToEnvVar(flag);
   const char* const string_value = posix::GetEnv(env_var.c_str());
   if (string_value == NULL) {
     // The environment variable is not set.
@@ -737,7 +796,7 @@  Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
 // Reads and returns the string environment variable corresponding to
 // the given flag; if it's not set, returns default_value.
 const char* StringFromGTestEnv(const char* flag, const char* default_value) {
-  const String env_var = FlagToEnvVar(flag);
+  const std::string env_var = FlagToEnvVar(flag);
   const char* const value = posix::GetEnv(env_var.c_str());
   return value == NULL ? default_value : value;
 }
diff --git a/src/gtest/src/gtest-printers.cc b/src/gtest/src/gtest-printers.cc
index ed63c7b..75fa408 100644
--- a/src/gtest/src/gtest-printers.cc
+++ b/src/gtest/src/gtest-printers.cc
@@ -55,14 +55,6 @@  namespace {
 
 using ::std::ostream;
 
-#if GTEST_OS_WINDOWS_MOBILE  // Windows CE does not define _snprintf_s.
-# define snprintf _snprintf
-#elif _MSC_VER >= 1400  // VC 8.0 and later deprecate snprintf and _snprintf.
-# define snprintf _snprintf_s
-#elif _MSC_VER
-# define snprintf _snprintf
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
 // Prints a segment of bytes in the given object.
 void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
                                 size_t count, ostream* os) {
@@ -77,7 +69,7 @@  void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
       else
         *os << '-';
     }
-    snprintf(text, sizeof(text), "%02X", obj_bytes[j]);
+    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
     *os << text;
   }
 }
@@ -184,16 +176,16 @@  static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
         *os << static_cast<char>(c);
         return kAsIs;
       } else {
-        *os << String::Format("\\x%X", static_cast<UnsignedChar>(c));
+        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
         return kHexEscape;
       }
   }
   return kSpecialEscape;
 }
 
-// Prints a char c as if it's part of a string literal, escaping it when
+// Prints a wchar_t c as if it's part of a string literal, escaping it when
 // necessary; returns how c was formatted.
-static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
+static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
   switch (c) {
     case L'\'':
       *os << "'";
@@ -208,8 +200,9 @@  static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
 
 // Prints a char c as if it's part of a string literal, escaping it when
 // necessary; returns how c was formatted.
-static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
-  return PrintAsWideStringLiteralTo(static_cast<unsigned char>(c), os);
+static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
+  return PrintAsStringLiteralTo(
+      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
 }
 
 // Prints a wide or narrow character c and its code.  '\0' is printed
@@ -228,7 +221,7 @@  void PrintCharAndCodeTo(Char c, ostream* os) {
   // obvious).
   if (c == 0)
     return;
-  *os << " (" << String::Format("%d", c).c_str();
+  *os << " (" << static_cast<int>(c);
 
   // For more convenience, we print c's code again in hexidecimal,
   // unless c was already printed in the form '\x##' or the code is in
@@ -236,8 +229,7 @@  void PrintCharAndCodeTo(Char c, ostream* os) {
   if (format == kHexEscape || (1 <= c && c <= 9)) {
     // Do nothing.
   } else {
-    *os << String::Format(", 0x%X",
-                          static_cast<UnsignedChar>(c)).c_str();
+    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
   }
   *os << ")";
 }
@@ -255,48 +247,63 @@  void PrintTo(wchar_t wc, ostream* os) {
   PrintCharAndCodeTo<wchar_t>(wc, os);
 }
 
-// Prints the given array of characters to the ostream.
-// The array starts at *begin, the length is len, it may include '\0' characters
-// and may not be null-terminated.
-static void PrintCharsAsStringTo(const char* begin, size_t len, ostream* os) {
-  *os << "\"";
+// Prints the given array of characters to the ostream.  CharType must be either
+// char or wchar_t.
+// The array starts at begin, the length is len, it may include '\0' characters
+// and may not be NUL-terminated.
+template <typename CharType>
+static void PrintCharsAsStringTo(
+    const CharType* begin, size_t len, ostream* os) {
+  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
+  *os << kQuoteBegin;
   bool is_previous_hex = false;
   for (size_t index = 0; index < len; ++index) {
-    const char cur = begin[index];
+    const CharType cur = begin[index];
     if (is_previous_hex && IsXDigit(cur)) {
       // Previous character is of '\x..' form and this character can be
       // interpreted as another hexadecimal digit in its number. Break string to
       // disambiguate.
-      *os << "\" \"";
+      *os << "\" " << kQuoteBegin;
     }
-    is_previous_hex = PrintAsNarrowStringLiteralTo(cur, os) == kHexEscape;
+    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
   }
   *os << "\"";
 }
 
+// Prints a (const) char/wchar_t array of 'len' elements, starting at address
+// 'begin'.  CharType must be either char or wchar_t.
+template <typename CharType>
+static void UniversalPrintCharArray(
+    const CharType* begin, size_t len, ostream* os) {
+  // The code
+  //   const char kFoo[] = "foo";
+  // generates an array of 4, not 3, elements, with the last one being '\0'.
+  //
+  // Therefore when printing a char array, we don't print the last element if
+  // it's '\0', such that the output matches the string literal as it's
+  // written in the source code.
+  if (len > 0 && begin[len - 1] == '\0') {
+    PrintCharsAsStringTo(begin, len - 1, os);
+    return;
+  }
+
+  // If, however, the last element in the array is not '\0', e.g.
+  //    const char kFoo[] = { 'f', 'o', 'o' };
+  // we must print the entire array.  We also print a message to indicate
+  // that the array is not NUL-terminated.
+  PrintCharsAsStringTo(begin, len, os);
+  *os << " (no terminating NUL)";
+}
+
 // Prints a (const) char array of 'len' elements, starting at address 'begin'.
 void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
-  PrintCharsAsStringTo(begin, len, os);
+  UniversalPrintCharArray(begin, len, os);
 }
 
-// Prints the given array of wide characters to the ostream.
-// The array starts at *begin, the length is len, it may include L'\0'
-// characters and may not be null-terminated.
-static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
-                                     ostream* os) {
-  *os << "L\"";
-  bool is_previous_hex = false;
-  for (size_t index = 0; index < len; ++index) {
-    const wchar_t cur = begin[index];
-    if (is_previous_hex && isascii(cur) && IsXDigit(static_cast<char>(cur))) {
-      // Previous character is of '\x..' form and this character can be
-      // interpreted as another hexadecimal digit in its number. Break string to
-      // disambiguate.
-      *os << "\" L\"";
-    }
-    is_previous_hex = PrintAsWideStringLiteralTo(cur, os) == kHexEscape;
-  }
-  *os << "\"";
+// Prints a (const) wchar_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
 }
 
 // Prints the given C string to the ostream.
@@ -322,7 +329,7 @@  void PrintTo(const wchar_t* s, ostream* os) {
     *os << "NULL";
   } else {
     *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintWideCharsAsStringTo(s, wcslen(s), os);
+    PrintCharsAsStringTo(s, wcslen(s), os);
   }
 }
 #endif  // wchar_t is native
@@ -341,13 +348,13 @@  void PrintStringTo(const ::std::string& s, ostream* os) {
 // Prints a ::wstring object.
 #if GTEST_HAS_GLOBAL_WSTRING
 void PrintWideStringTo(const ::wstring& s, ostream* os) {
-  PrintWideCharsAsStringTo(s.data(), s.size(), os);
+  PrintCharsAsStringTo(s.data(), s.size(), os);
 }
 #endif  // GTEST_HAS_GLOBAL_WSTRING
 
 #if GTEST_HAS_STD_WSTRING
 void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
-  PrintWideCharsAsStringTo(s.data(), s.size(), os);
+  PrintCharsAsStringTo(s.data(), s.size(), os);
 }
 #endif  // GTEST_HAS_STD_WSTRING
 
diff --git a/src/gtest/src/gtest-test-part.cc b/src/gtest/src/gtest-test-part.cc
index 5ddc67c..c60eef3 100644
--- a/src/gtest/src/gtest-test-part.cc
+++ b/src/gtest/src/gtest-test-part.cc
@@ -48,10 +48,10 @@  using internal::GetUnitTestImpl;
 
 // Gets the summary of the failure message by omitting the stack trace
 // in it.
-internal::String TestPartResult::ExtractSummary(const char* message) {
+std::string TestPartResult::ExtractSummary(const char* message) {
   const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
-  return stack_trace == NULL ? internal::String(message) :
-      internal::String(message, stack_trace - message);
+  return stack_trace == NULL ? message :
+      std::string(message, stack_trace);
 }
 
 // Prints a TestPartResult object.
diff --git a/src/gtest/src/gtest-typed-test.cc b/src/gtest/src/gtest-typed-test.cc
index a5cc88f..f0079f4 100644
--- a/src/gtest/src/gtest-typed-test.cc
+++ b/src/gtest/src/gtest-typed-test.cc
@@ -58,10 +58,10 @@  const char* TypedTestCasePState::VerifyRegisteredTestNames(
   registered_tests = SkipSpaces(registered_tests);
 
   Message errors;
-  ::std::set<String> tests;
+  ::std::set<std::string> tests;
   for (const char* names = registered_tests; names != NULL;
        names = SkipComma(names)) {
-    const String name = GetPrefixUntilComma(names);
+    const std::string name = GetPrefixUntilComma(names);
     if (tests.count(name) != 0) {
       errors << "Test " << name << " is listed more than once.\n";
       continue;
@@ -93,7 +93,7 @@  const char* TypedTestCasePState::VerifyRegisteredTestNames(
     }
   }
 
-  const String& errors_str = errors.GetString();
+  const std::string& errors_str = errors.GetString();
   if (errors_str != "") {
     fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
             errors_str.c_str());
diff --git a/src/gtest/src/gtest.cc b/src/gtest/src/gtest.cc
index 904d9d7..6de53dd 100644
--- a/src/gtest/src/gtest.cc
+++ b/src/gtest/src/gtest.cc
@@ -39,10 +39,13 @@ 
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <time.h>
 #include <wchar.h>
 #include <wctype.h>
 
 #include <algorithm>
+#include <iomanip>
+#include <limits>
 #include <ostream>  // NOLINT
 #include <sstream>
 #include <vector>
@@ -179,6 +182,10 @@  bool g_help_flag = false;
 
 }  // namespace internal
 
+static const char* GetDefaultFilter() {
+  return kUniversalFilter;
+}
+
 GTEST_DEFINE_bool_(
     also_run_disabled_tests,
     internal::BoolFromGTestEnv("also_run_disabled_tests", false),
@@ -201,11 +208,11 @@  GTEST_DEFINE_string_(
     "Whether to use colors in the output.  Valid values: yes, no, "
     "and auto.  'auto' means to use colors if the output is "
     "being sent to a terminal and the TERM environment variable "
-    "is set to xterm, xterm-color, xterm-256color, linux or cygwin.");
+    "is set to a terminal type that supports colors.");
 
 GTEST_DEFINE_string_(
     filter,
-    internal::StringFromGTestEnv("filter", kUniversalFilter),
+    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
     "A colon-separated list of glob (not regex) patterns "
     "for filtering the tests to run, optionally followed by a "
     "'-' and a : separated list of negative patterns (tests to "
@@ -305,7 +312,7 @@  UInt32 Random::Generate(UInt32 range) {
 // Test.  g_init_gtest_count is set to the number of times
 // InitGoogleTest() has been called.  We don't protect this variable
 // under a mutex as it is only accessed in the main thread.
-int g_init_gtest_count = 0;
+GTEST_API_ int g_init_gtest_count = 0;
 static bool GTestIsInitialized() { return g_init_gtest_count != 0; }
 
 // Iterates over a vector of TestCases, keeping a running sum of the
@@ -360,10 +367,10 @@  void AssertHelper::operator=(const Message& message) const {
 }
 
 // Mutex for linked pointers.
-GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
+GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
 
 // Application pathname gotten in InitGoogleTest.
-String g_executable_path;
+std::string g_executable_path;
 
 // Returns the current application's name, removing directory path if that
 // is present.
@@ -382,29 +389,29 @@  FilePath GetCurrentExecutableName() {
 // Functions for processing the gtest_output flag.
 
 // Returns the output format, or "" for normal printed output.
-String UnitTestOptions::GetOutputFormat() {
+std::string UnitTestOptions::GetOutputFormat() {
   const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
-  if (gtest_output_flag == NULL) return String("");
+  if (gtest_output_flag == NULL) return std::string("");
 
   const char* const colon = strchr(gtest_output_flag, ':');
   return (colon == NULL) ?
-      String(gtest_output_flag) :
-      String(gtest_output_flag, colon - gtest_output_flag);
+      std::string(gtest_output_flag) :
+      std::string(gtest_output_flag, colon - gtest_output_flag);
 }
 
 // Returns the name of the requested output file, or the default if none
 // was explicitly specified.
-String UnitTestOptions::GetAbsolutePathToOutputFile() {
+std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
   const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
   if (gtest_output_flag == NULL)
-    return String("");
+    return "";
 
   const char* const colon = strchr(gtest_output_flag, ':');
   if (colon == NULL)
-    return String(internal::FilePath::ConcatPaths(
-               internal::FilePath(
-                   UnitTest::GetInstance()->original_working_dir()),
-               internal::FilePath(kDefaultOutputFile)).ToString() );
+    return internal::FilePath::ConcatPaths(
+        internal::FilePath(
+            UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(kDefaultOutputFile)).string();
 
   internal::FilePath output_name(colon + 1);
   if (!output_name.IsAbsolutePath())
@@ -417,12 +424,12 @@  String UnitTestOptions::GetAbsolutePathToOutputFile() {
         internal::FilePath(colon + 1));
 
   if (!output_name.IsDirectory())
-    return output_name.ToString();
+    return output_name.string();
 
   internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
       output_name, internal::GetCurrentExecutableName(),
       GetOutputFormat().c_str()));
-  return result.ToString();
+  return result.string();
 }
 
 // Returns true iff the wildcard pattern matches the string.  The
@@ -447,7 +454,8 @@  bool UnitTestOptions::PatternMatchesString(const char *pattern,
   }
 }
 
-bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) {
+bool UnitTestOptions::MatchesFilter(
+    const std::string& name, const char* filter) {
   const char *cur_pattern = filter;
   for (;;) {
     if (PatternMatchesString(cur_pattern, name.c_str())) {
@@ -467,28 +475,24 @@  bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) {
   }
 }
 
-// TODO(keithray): move String function implementations to gtest-string.cc.
-
 // Returns true iff the user-specified filter matches the test case
 // name and the test name.
-bool UnitTestOptions::FilterMatchesTest(const String &test_case_name,
-                                        const String &test_name) {
-  const String& full_name = String::Format("%s.%s",
-                                           test_case_name.c_str(),
-                                           test_name.c_str());
+bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
+                                        const std::string &test_name) {
+  const std::string& full_name = test_case_name + "." + test_name.c_str();
 
   // Split --gtest_filter at '-', if there is one, to separate into
   // positive filter and negative filter portions
   const char* const p = GTEST_FLAG(filter).c_str();
   const char* const dash = strchr(p, '-');
-  String positive;
-  String negative;
+  std::string positive;
+  std::string negative;
   if (dash == NULL) {
     positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
-    negative = String("");
+    negative = "";
   } else {
-    positive = String(p, dash - p);  // Everything up to the dash
-    negative = String(dash+1);       // Everything after the dash
+    positive = std::string(p, dash);   // Everything up to the dash
+    negative = std::string(dash + 1);  // Everything after the dash
     if (positive.empty()) {
       // Treat '-test1' as the same as '*-test1'
       positive = kUniversalFilter;
@@ -608,7 +612,7 @@  AssertionResult HasOneFailure(const char* /* results_expr */,
                               const TestPartResultArray& results,
                               TestPartResult::Type type,
                               const string& substr) {
-  const String expected(type == TestPartResult::kFatalFailure ?
+  const std::string expected(type == TestPartResult::kFatalFailure ?
                         "1 fatal failure" :
                         "1 non-fatal failure");
   Message msg;
@@ -731,11 +735,22 @@  int UnitTestImpl::failed_test_count() const {
   return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
 }
 
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTestImpl::reportable_disabled_test_count() const {
+  return SumOverTestCaseList(test_cases_,
+                             &TestCase::reportable_disabled_test_count);
+}
+
 // Gets the number of disabled tests.
 int UnitTestImpl::disabled_test_count() const {
   return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
 }
 
+// Gets the number of tests to be printed in the XML report.
+int UnitTestImpl::reportable_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count);
+}
+
 // Gets the number of all tests.
 int UnitTestImpl::total_test_count() const {
   return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
@@ -746,7 +761,7 @@  int UnitTestImpl::test_to_run_count() const {
   return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
 }
 
-// Returns the current OS stack trace as a String.
+// Returns the current OS stack trace as an std::string.
 //
 // The maximum number of stack frames to be included is specified by
 // the gtest_stack_trace_depth flag.  The skip_count parameter
@@ -756,9 +771,9 @@  int UnitTestImpl::test_to_run_count() const {
 // For example, if Foo() calls Bar(), which in turn calls
 // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
 // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
+std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
   (void)skip_count;
-  return String("");
+  return "";
 }
 
 // Returns the current time in milliseconds.
@@ -815,41 +830,7 @@  TimeInMillis GetTimeInMillis() {
 
 // Utilities
 
-// class String
-
-// Returns the input enclosed in double quotes if it's not NULL;
-// otherwise returns "(null)".  For example, "\"Hello\"" is returned
-// for input "Hello".
-//
-// This is useful for printing a C string in the syntax of a literal.
-//
-// Known issue: escape sequences are not handled yet.
-String String::ShowCStringQuoted(const char* c_str) {
-  return c_str ? String::Format("\"%s\"", c_str) : String("(null)");
-}
-
-// Copies at most length characters from str into a newly-allocated
-// piece of memory of size length+1.  The memory is allocated with new[].
-// A terminating null byte is written to the memory, and a pointer to it
-// is returned.  If str is NULL, NULL is returned.
-static char* CloneString(const char* str, size_t length) {
-  if (str == NULL) {
-    return NULL;
-  } else {
-    char* const clone = new char[length + 1];
-    posix::StrNCpy(clone, str, length);
-    clone[length] = '\0';
-    return clone;
-  }
-}
-
-// Clones a 0-terminated C string, allocating memory using new.  The
-// caller is responsible for deleting[] the return value.  Returns the
-// cloned string, or NULL if the input is NULL.
-const char * String::CloneCString(const char* c_str) {
-  return (c_str == NULL) ?
-                    NULL : CloneString(c_str, strlen(c_str));
-}
+// class String.
 
 #if GTEST_OS_WINDOWS_MOBILE
 // Creates a UTF-16 wide string from the given ANSI string, allocating
@@ -906,11 +887,6 @@  bool String::CStringEquals(const char * lhs, const char * rhs) {
 // encoding, and streams the result to the given Message object.
 static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
                                      Message* msg) {
-  // TODO(wan): consider allowing a testing::String object to
-  // contain '\0'.  This will make it behave more like std::string,
-  // and will allow ToUtf8String() to return the correct encoding
-  // for '\0' s.t. we can get rid of the conditional here (and in
-  // several other places).
   for (size_t i = 0; i != length; ) {  // NOLINT
     if (wstr[i] != L'\0') {
       *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
@@ -927,6 +903,26 @@  static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
 
 }  // namespace internal
 
+// Constructs an empty Message.
+// We allocate the stringstream separately because otherwise each use of
+// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
+// stack frame leading to huge stack frames in some cases; gcc does not reuse
+// the stack space.
+Message::Message() : ss_(new ::std::stringstream) {
+  // By default, we want there to be enough precision when printing
+  // a double to a Message.
+  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
+}
+
+// These two overloads allow streaming a wide C string to a Message
+// using the UTF-8 encoding.
+Message& Message::operator <<(const wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+Message& Message::operator <<(wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+
 #if GTEST_HAS_STD_WSTRING
 // Converts the given wide string to a narrow string using the UTF-8
 // encoding, and streams the result to this Message object.
@@ -945,6 +941,12 @@  Message& Message::operator <<(const ::wstring& wstr) {
 }
 #endif  // GTEST_HAS_GLOBAL_WSTRING
 
+// Gets the text streamed to this object so far as an std::string.
+// Each '\0' character in the buffer is replaced with "\\0".
+std::string Message::GetString() const {
+  return internal::StringStreamToString(ss_.get());
+}
+
 // AssertionResult constructors.
 // Used in EXPECT_TRUE/FALSE(assertion_result).
 AssertionResult::AssertionResult(const AssertionResult& other)
@@ -997,8 +999,8 @@  namespace internal {
 // be inserted into the message.
 AssertionResult EqFailure(const char* expected_expression,
                           const char* actual_expression,
-                          const String& expected_value,
-                          const String& actual_value,
+                          const std::string& expected_value,
+                          const std::string& actual_value,
                           bool ignoring_case) {
   Message msg;
   msg << "Value of: " << actual_expression;
@@ -1018,10 +1020,11 @@  AssertionResult EqFailure(const char* expected_expression,
 }
 
 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
-String GetBoolAssertionFailureMessage(const AssertionResult& assertion_result,
-                                      const char* expression_text,
-                                      const char* actual_predicate_value,
-                                      const char* expected_predicate_value) {
+std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value) {
   const char* actual_message = assertion_result.message();
   Message msg;
   msg << "Value of: " << expression_text
@@ -1168,8 +1171,8 @@  AssertionResult CmpHelperSTREQ(const char* expected_expression,
 
   return EqFailure(expected_expression,
                    actual_expression,
-                   String::ShowCStringQuoted(expected),
-                   String::ShowCStringQuoted(actual),
+                   PrintToString(expected),
+                   PrintToString(actual),
                    false);
 }
 
@@ -1184,8 +1187,8 @@  AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
 
   return EqFailure(expected_expression,
                    actual_expression,
-                   String::ShowCStringQuoted(expected),
-                   String::ShowCStringQuoted(actual),
+                   PrintToString(expected),
+                   PrintToString(actual),
                    true);
 }
 
@@ -1349,7 +1352,7 @@  AssertionResult HRESULTFailureHelper(const char* expr,
   // want inserts expanded.
   const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
                        FORMAT_MESSAGE_IGNORE_INSERTS;
-  const DWORD kBufSize = 4096;  // String::Format can't exceed this length.
+  const DWORD kBufSize = 4096;
   // Gets the system's human readable message string for this HRESULT.
   char error_text[kBufSize] = { '\0' };
   DWORD message_length = ::FormatMessageA(kFlags,
@@ -1359,7 +1362,7 @@  AssertionResult HRESULTFailureHelper(const char* expr,
                                           error_text,  // output buffer
                                           kBufSize,  // buf size
                                           NULL);  // no arguments for inserts
-  // Trims tailing white space (FormatMessage leaves a trailing cr-lf)
+  // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
   for (; message_length && IsSpace(error_text[message_length - 1]);
           --message_length) {
     error_text[message_length - 1] = '\0';
@@ -1367,10 +1370,10 @@  AssertionResult HRESULTFailureHelper(const char* expr,
 
 # endif  // GTEST_OS_WINDOWS_MOBILE
 
-  const String error_hex(String::Format("0x%08X ", hr));
+  const std::string error_hex("0x" + String::FormatHexInt(hr));
   return ::testing::AssertionFailure()
       << "Expected: " << expr << " " << expected << ".\n"
-      << "  Actual: " << error_hex << error_text << "\n";
+      << "  Actual: " << error_hex << " " << error_text << "\n";
 }
 
 }  // namespace
@@ -1427,12 +1430,15 @@  inline UInt32 ChopLowBits(UInt32* bits, int n) {
 // Converts a Unicode code point to a narrow string in UTF-8 encoding.
 // code_point parameter is of type UInt32 because wchar_t may not be
 // wide enough to contain a code point.
-// The output buffer str must containt at least 32 characters.
-// The function returns the address of the output buffer.
 // If the code_point is not a valid Unicode code point
-// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output
-// as '(Invalid Unicode 0xXXXXXXXX)'.
-char* CodePointToUtf8(UInt32 code_point, char* str) {
+// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
+// to "(Invalid Unicode 0xXXXXXXXX)".
+std::string CodePointToUtf8(UInt32 code_point) {
+  if (code_point > kMaxCodePoint4) {
+    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
+  }
+
+  char str[5];  // Big enough for the largest valid code point.
   if (code_point <= kMaxCodePoint1) {
     str[1] = '\0';
     str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
@@ -1445,22 +1451,12 @@  char* CodePointToUtf8(UInt32 code_point, char* str) {
     str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
     str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
     str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
-  } else if (code_point <= kMaxCodePoint4) {
+  } else {  // code_point <= kMaxCodePoint4
     str[4] = '\0';
     str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
     str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
     str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
     str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
-  } else {
-    // The longest string String::Format can produce when invoked
-    // with these parameters is 28 character long (not including
-    // the terminating nul character). We are asking for 32 character
-    // buffer just in case. This is also enough for strncpy to
-    // null-terminate the destination string.
-    posix::StrNCpy(
-        str, String::Format("(Invalid Unicode 0x%X)", code_point).c_str(), 32);
-    str[31] = '\0';  // Makes sure no change in the format to strncpy leaves
-                     // the result unterminated.
   }
   return str;
 }
@@ -1501,7 +1497,7 @@  inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
 // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
 // and contains invalid UTF-16 surrogate pairs, values in those pairs
 // will be encoded as individual Unicode characters from Basic Normal Plane.
-String WideStringToUtf8(const wchar_t* str, int num_chars) {
+std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
   if (num_chars == -1)
     num_chars = static_cast<int>(wcslen(str));
 
@@ -1519,27 +1515,17 @@  String WideStringToUtf8(const wchar_t* str, int num_chars) {
       unicode_code_point = static_cast<UInt32>(str[i]);
     }
 
-    char buffer[32];  // CodePointToUtf8 requires a buffer this big.
-    stream << CodePointToUtf8(unicode_code_point, buffer);
+    stream << CodePointToUtf8(unicode_code_point);
   }
   return StringStreamToString(&stream);
 }
 
-// Converts a wide C string to a String using the UTF-8 encoding.
+// Converts a wide C string to an std::string using the UTF-8 encoding.
 // NULL will be converted to "(null)".
-String String::ShowWideCString(const wchar_t * wide_c_str) {
-  if (wide_c_str == NULL) return String("(null)");
-
-  return String(internal::WideStringToUtf8(wide_c_str, -1).c_str());
-}
-
-// Similar to ShowWideCString(), except that this function encloses
-// the converted string in double quotes.
-String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
-  if (wide_c_str == NULL) return String("(null)");
+std::string String::ShowWideCString(const wchar_t * wide_c_str) {
+  if (wide_c_str == NULL)  return "(null)";
 
-  return String::Format("L\"%s\"",
-                        String::ShowWideCString(wide_c_str).c_str());
+  return internal::WideStringToUtf8(wide_c_str, -1);
 }
 
 // Compares two wide C strings.  Returns true iff they have the same
@@ -1567,8 +1553,8 @@  AssertionResult CmpHelperSTREQ(const char* expected_expression,
 
   return EqFailure(expected_expression,
                    actual_expression,
-                   String::ShowWideCStringQuoted(expected),
-                   String::ShowWideCStringQuoted(actual),
+                   PrintToString(expected),
+                   PrintToString(actual),
                    false);
 }
 
@@ -1583,8 +1569,8 @@  AssertionResult CmpHelperSTRNE(const char* s1_expression,
 
   return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                             << s2_expression << "), actual: "
-                            << String::ShowWideCStringQuoted(s1)
-                            << " vs " << String::ShowWideCStringQuoted(s2);
+                            << PrintToString(s1)
+                            << " vs " << PrintToString(s2);
 }
 
 // Compares two C strings, ignoring case.  Returns true iff they have
@@ -1635,135 +1621,69 @@  bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
 #endif  // OS selector
 }
 
-// Compares this with another String.
-// Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
-// if this is greater than rhs.
-int String::Compare(const String & rhs) const {
-  const char* const lhs_c_str = c_str();
-  const char* const rhs_c_str = rhs.c_str();
-
-  if (lhs_c_str == NULL) {
-    return rhs_c_str == NULL ? 0 : -1;  // NULL < anything except NULL
-  } else if (rhs_c_str == NULL) {
-    return 1;
-  }
-
-  const size_t shorter_str_len =
-      length() <= rhs.length() ? length() : rhs.length();
-  for (size_t i = 0; i != shorter_str_len; i++) {
-    if (lhs_c_str[i] < rhs_c_str[i]) {
-      return -1;
-    } else if (lhs_c_str[i] > rhs_c_str[i]) {
-      return 1;
-    }
-  }
-  return (length() < rhs.length()) ? -1 :
-      (length() > rhs.length()) ? 1 : 0;
+// Returns true iff str ends with the given suffix, ignoring case.
+// Any string is considered to end with an empty suffix.
+bool String::EndsWithCaseInsensitive(
+    const std::string& str, const std::string& suffix) {
+  const size_t str_len = str.length();
+  const size_t suffix_len = suffix.length();
+  return (str_len >= suffix_len) &&
+         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
+                                      suffix.c_str());
 }
 
-// Returns true iff this String ends with the given suffix.  *Any*
-// String is considered to end with a NULL or empty suffix.
-bool String::EndsWith(const char* suffix) const {
-  if (suffix == NULL || CStringEquals(suffix, "")) return true;
-
-  if (c_str() == NULL) return false;
-
-  const size_t this_len = strlen(c_str());
-  const size_t suffix_len = strlen(suffix);
-  return (this_len >= suffix_len) &&
-         CStringEquals(c_str() + this_len - suffix_len, suffix);
+// Formats an int value as "%02d".
+std::string String::FormatIntWidth2(int value) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(2) << value;
+  return ss.str();
 }
 
-// Returns true iff this String ends with the given suffix, ignoring case.
-// Any String is considered to end with a NULL or empty suffix.
-bool String::EndsWithCaseInsensitive(const char* suffix) const {
-  if (suffix == NULL || CStringEquals(suffix, "")) return true;
-
-  if (c_str() == NULL) return false;
-
-  const size_t this_len = strlen(c_str());
-  const size_t suffix_len = strlen(suffix);
-  return (this_len >= suffix_len) &&
-         CaseInsensitiveCStringEquals(c_str() + this_len - suffix_len, suffix);
+// Formats an int value as "%X".
+std::string String::FormatHexInt(int value) {
+  std::stringstream ss;
+  ss << std::hex << std::uppercase << value;
+  return ss.str();
 }
 
-// Formats a list of arguments to a String, using the same format
-// spec string as for printf.
-//
-// We do not use the StringPrintf class as it is not universally
-// available.
-//
-// The result is limited to 4096 characters (including the tailing 0).
-// If 4096 characters are not enough to format the input, or if
-// there's an error, "<formatting error or buffer exceeded>" is
-// returned.
-String String::Format(const char * format, ...) {
-  va_list args;
-  va_start(args, format);
-
-  char buffer[4096];
-  const int kBufferSize = sizeof(buffer)/sizeof(buffer[0]);
-
-  // MSVC 8 deprecates vsnprintf(), so we want to suppress warning
-  // 4996 (deprecated function) there.
-#ifdef _MSC_VER  // We are using MSVC.
-# pragma warning(push)          // Saves the current warning state.
-# pragma warning(disable:4996)  // Temporarily disables warning 4996.
-
-  const int size = vsnprintf(buffer, kBufferSize, format, args);
-
-# pragma warning(pop)           // Restores the warning state.
-#else  // We are not using MSVC.
-  const int size = vsnprintf(buffer, kBufferSize, format, args);
-#endif  // _MSC_VER
-  va_end(args);
-
-  // vsnprintf()'s behavior is not portable.  When the buffer is not
-  // big enough, it returns a negative value in MSVC, and returns the
-  // needed buffer size on Linux.  When there is an output error, it
-  // always returns a negative value.  For simplicity, we lump the two
-  // error cases together.
-  if (size < 0 || size >= kBufferSize) {
-    return String("<formatting error or buffer exceeded>");
-  } else {
-    return String(buffer, size);
-  }
+// Formats a byte as "%02X".
+std::string String::FormatByte(unsigned char value) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
+     << static_cast<unsigned int>(value);
+  return ss.str();
 }
 
-// Converts the buffer in a stringstream to a String, converting NUL
+// Converts the buffer in a stringstream to an std::string, converting NUL
 // bytes to "\\0" along the way.
-String StringStreamToString(::std::stringstream* ss) {
+std::string StringStreamToString(::std::stringstream* ss) {
   const ::std::string& str = ss->str();
   const char* const start = str.c_str();
   const char* const end = start + str.length();
 
-  // We need to use a helper stringstream to do this transformation
-  // because String doesn't support push_back().
-  ::std::stringstream helper;
+  std::string result;
+  result.reserve(2 * (end - start));
   for (const char* ch = start; ch != end; ++ch) {
     if (*ch == '\0') {
-      helper << "\\0";  // Replaces NUL with "\\0";
+      result += "\\0";  // Replaces NUL with "\\0";
     } else {
-      helper.put(*ch);
+      result += *ch;
     }
   }
 
-  return String(helper.str().c_str());
+  return result;
 }
 
 // Appends the user-supplied message to the Google-Test-generated message.
-String AppendUserMessage(const String& gtest_msg,
-                         const Message& user_msg) {
+std::string AppendUserMessage(const std::string& gtest_msg,
+                              const Message& user_msg) {
   // Appends the user message if it's non-empty.
-  const String user_msg_string = user_msg.GetString();
+  const std::string user_msg_string = user_msg.GetString();
   if (user_msg_string.empty()) {
     return gtest_msg;
   }
 
-  Message msg;
-  msg << gtest_msg << "\n" << user_msg_string;
-
-  return msg.GetString();
+  return gtest_msg + "\n" + user_msg_string;
 }
 
 }  // namespace internal
@@ -1811,8 +1731,9 @@  void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
 // Adds a test property to the list. If a property with the same key as the
 // supplied property is already represented, the value of this test_property
 // replaces the old value for that key.
-void TestResult::RecordProperty(const TestProperty& test_property) {
-  if (!ValidateTestProperty(test_property)) {
+void TestResult::RecordProperty(const std::string& xml_element,
+                                const TestProperty& test_property) {
+  if (!ValidateTestProperty(xml_element, test_property)) {
     return;
   }
   internal::MutexLock lock(&test_properites_mutex_);
@@ -1826,21 +1747,94 @@  void TestResult::RecordProperty(const TestProperty& test_property) {
   property_with_matching_key->SetValue(test_property.value());
 }
 
-// Adds a failure if the key is a reserved attribute of Google Test
-// testcase tags.  Returns true if the property is valid.
-bool TestResult::ValidateTestProperty(const TestProperty& test_property) {
-  internal::String key(test_property.key());
-  if (key == "name" || key == "status" || key == "time" || key == "classname") {
-    ADD_FAILURE()
-        << "Reserved key used in RecordProperty(): "
-        << key
-        << " ('name', 'status', 'time', and 'classname' are reserved by "
-        << GTEST_NAME_ << ")";
+// The list of reserved attributes used in the <testsuites> element of XML
+// output.
+static const char* const kReservedTestSuitesAttributes[] = {
+  "disabled",
+  "errors",
+  "failures",
+  "name",
+  "random_seed",
+  "tests",
+  "time",
+  "timestamp"
+};
+
+// The list of reserved attributes used in the <testsuite> element of XML
+// output.
+static const char* const kReservedTestSuiteAttributes[] = {
+  "disabled",
+  "errors",
+  "failures",
+  "name",
+  "tests",
+  "time"
+};
+
+// The list of reserved attributes used in the <testcase> element of XML output.
+static const char* const kReservedTestCaseAttributes[] = {
+  "classname",
+  "name",
+  "status",
+  "time",
+  "type_param",
+  "value_param"
+};
+
+template <int kSize>
+std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
+  return std::vector<std::string>(array, array + kSize);
+}
+
+static std::vector<std::string> GetReservedAttributesForElement(
+    const std::string& xml_element) {
+  if (xml_element == "testsuites") {
+    return ArrayAsVector(kReservedTestSuitesAttributes);
+  } else if (xml_element == "testsuite") {
+    return ArrayAsVector(kReservedTestSuiteAttributes);
+  } else if (xml_element == "testcase") {
+    return ArrayAsVector(kReservedTestCaseAttributes);
+  } else {
+    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
+  }
+  // This code is unreachable but some compilers may not realizes that.
+  return std::vector<std::string>();
+}
+
+static std::string FormatWordList(const std::vector<std::string>& words) {
+  Message word_list;
+  for (size_t i = 0; i < words.size(); ++i) {
+    if (i > 0 && words.size() > 2) {
+      word_list << ", ";
+    }
+    if (i == words.size() - 1) {
+      word_list << "and ";
+    }
+    word_list << "'" << words[i] << "'";
+  }
+  return word_list.GetString();
+}
+
+bool ValidateTestPropertyName(const std::string& property_name,
+                              const std::vector<std::string>& reserved_names) {
+  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
+          reserved_names.end()) {
+    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
+                  << " (" << FormatWordList(reserved_names)
+                  << " are reserved by " << GTEST_NAME_ << ")";
     return false;
   }
   return true;
 }
 
+// Adds a failure if the key is a reserved attribute of the element named
+// xml_element.  Returns true if the property is valid.
+bool TestResult::ValidateTestProperty(const std::string& xml_element,
+                                      const TestProperty& test_property) {
+  return ValidateTestPropertyName(test_property.key(),
+                                  GetReservedAttributesForElement(xml_element));
+}
+
 // Clears the object.
 void TestResult::Clear() {
   test_part_results_.clear();
@@ -1916,12 +1910,12 @@  void Test::TearDown() {
 }
 
 // Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const char* key, const char* value) {
-  UnitTest::GetInstance()->RecordPropertyForCurrentTest(key, value);
+void Test::RecordProperty(const std::string& key, const std::string& value) {
+  UnitTest::GetInstance()->RecordProperty(key, value);
 }
 
 // Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const char* key, int value) {
+void Test::RecordProperty(const std::string& key, int value) {
   Message value_message;
   value_message << value;
   RecordProperty(key, value_message.GetString().c_str());
@@ -1930,7 +1924,7 @@  void Test::RecordProperty(const char* key, int value) {
 namespace internal {
 
 void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
-                                    const String& message) {
+                                    const std::string& message) {
   // This function is a friend of UnitTest and as such has access to
   // AddTestPartResult.
   UnitTest::GetInstance()->AddTestPartResult(
@@ -1938,7 +1932,7 @@  void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
       NULL,  // No info about the source file where the exception occurred.
       -1,    // We have no info on which line caused the exception.
       message,
-      String());  // No stack trace, either.
+      "");   // No stack trace, either.
 }
 
 }  // namespace internal
@@ -2015,22 +2009,24 @@  bool Test::HasSameFixtureClass() {
 // function returns its result via an output parameter pointer because VC++
 // prohibits creation of objects with destructors on stack in functions
 // using __try (see error C2712).
-static internal::String* FormatSehExceptionMessage(DWORD exception_code,
-                                                   const char* location) {
+static std::string* FormatSehExceptionMessage(DWORD exception_code,
+                                              const char* location) {
   Message message;
   message << "SEH exception with code 0x" << std::setbase(16) <<
     exception_code << std::setbase(10) << " thrown in " << location << ".";
 
-  return new internal::String(message.GetString());
+  return new std::string(message.GetString());
 }
 
 #endif  // GTEST_HAS_SEH
 
+namespace internal {
+
 #if GTEST_HAS_EXCEPTIONS
 
 // Adds an "exception thrown" fatal failure to the current test.
-static internal::String FormatCxxExceptionMessage(const char* description,
-                                                  const char* location) {
+static std::string FormatCxxExceptionMessage(const char* description,
+                                             const char* location) {
   Message message;
   if (description != NULL) {
     message << "C++ exception with description \"" << description << "\"";
@@ -2042,23 +2038,15 @@  static internal::String FormatCxxExceptionMessage(const char* description,
   return message.GetString();
 }
 
-static internal::String PrintTestPartResultToString(
+static std::string PrintTestPartResultToString(
     const TestPartResult& test_part_result);
 
-// A failed Google Test assertion will throw an exception of this type when
-// GTEST_FLAG(throw_on_failure) is true (if exceptions are enabled).  We
-// derive it from std::runtime_error, which is for errors presumably
-// detectable only at run time.  Since std::runtime_error inherits from
-// std::exception, many testing frameworks know how to extract and print the
-// message inside it.
-class GoogleTestFailureException : public ::std::runtime_error {
- public:
-  explicit GoogleTestFailureException(const TestPartResult& failure)
-      : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
-};
+GoogleTestFailureException::GoogleTestFailureException(
+    const TestPartResult& failure)
+    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
+
 #endif  // GTEST_HAS_EXCEPTIONS
 
-namespace internal {
 // We put these helper functions in the internal namespace as IBM's xlC
 // compiler rejects the code if they were declared static.
 
@@ -2078,7 +2066,7 @@  Result HandleSehExceptionsInMethodIfSupported(
     // We create the exception message on the heap because VC++ prohibits
     // creation of objects with destructors on stack in functions using __try
     // (see error C2712).
-    internal::String* exception_message = FormatSehExceptionMessage(
+    std::string* exception_message = FormatSehExceptionMessage(
         GetExceptionCode(), location);
     internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
                                              *exception_message);
@@ -2124,9 +2112,10 @@  Result HandleExceptionsInMethodIfSupported(
 #if GTEST_HAS_EXCEPTIONS
     try {
       return HandleSehExceptionsInMethodIfSupported(object, method, location);
-    } catch (const GoogleTestFailureException&) {  // NOLINT
-      // This exception doesn't originate in code under test. It makes no
-      // sense to report it as a test failure.
+    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
+      // This exception type can only be thrown by a failed Google
+      // Test assertion with the intention of letting another testing
+      // framework catch it.  Therefore we just re-throw it.
       throw;
     } catch (const std::exception& e) {  // NOLINT
       internal::ReportFailureInUnknownLocation(
@@ -2185,10 +2174,8 @@  bool Test::HasNonfatalFailure() {
 
 // Constructs a TestInfo object. It assumes ownership of the test factory
 // object.
-// TODO(vladl@google.com): Make a_test_case_name and a_name const string&'s
-// to signify they cannot be NULLs.
-TestInfo::TestInfo(const char* a_test_case_name,
-                   const char* a_name,
+TestInfo::TestInfo(const std::string& a_test_case_name,
+                   const std::string& a_name,
                    const char* a_type_param,
                    const char* a_value_param,
                    internal::TypeId fixture_class_id,
@@ -2227,7 +2214,8 @@  namespace internal {
 //                     The newly created TestInfo instance will assume
 //                     ownership of the factory object.
 TestInfo* MakeAndRegisterTestInfo(
-    const char* test_case_name, const char* name,
+    const char* test_case_name,
+    const char* name,
     const char* type_param,
     const char* value_param,
     TypeId fixture_class_id,
@@ -2282,11 +2270,11 @@  class TestNameIs {
 
   // Returns true iff the test name of test_info matches name_.
   bool operator()(const TestInfo * test_info) const {
-    return test_info && internal::String(test_info->name()).Compare(name_) == 0;
+    return test_info && test_info->name() == name_;
   }
 
  private:
-  internal::String name_;
+  std::string name_;
 };
 
 }  // namespace
@@ -2365,10 +2353,21 @@  int TestCase::failed_test_count() const {
   return CountIf(test_info_list_, TestFailed);
 }
 
+// Gets the number of disabled tests that will be reported in the XML report.
+int TestCase::reportable_disabled_test_count() const {
+  return CountIf(test_info_list_, TestReportableDisabled);
+}
+
+// Gets the number of disabled tests in this test case.
 int TestCase::disabled_test_count() const {
   return CountIf(test_info_list_, TestDisabled);
 }
 
+// Gets the number of tests to be printed in the XML report.
+int TestCase::reportable_test_count() const {
+  return CountIf(test_info_list_, TestReportable);
+}
+
 // Get the number of tests in this test case that should run.
 int TestCase::test_to_run_count() const {
   return CountIf(test_info_list_, ShouldRunTest);
@@ -2456,6 +2455,7 @@  void TestCase::Run() {
 
 // Clears the results of all tests in this test case.
 void TestCase::ClearResult() {
+  ad_hoc_test_result_.Clear();
   ForEach(test_info_list_, TestInfo::ClearTestResult);
 }
 
@@ -2476,20 +2476,20 @@  void TestCase::UnshuffleTests() {
 //
 // FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
 // FormatCountableNoun(5, "book", "books") returns "5 books".
-static internal::String FormatCountableNoun(int count,
-                                            const char * singular_form,
-                                            const char * plural_form) {
-  return internal::String::Format("%d %s", count,
-                                  count == 1 ? singular_form : plural_form);
+static std::string FormatCountableNoun(int count,
+                                       const char * singular_form,
+                                       const char * plural_form) {
+  return internal::StreamableToString(count) + " " +
+      (count == 1 ? singular_form : plural_form);
 }
 
 // Formats the count of tests.
-static internal::String FormatTestCount(int test_count) {
+static std::string FormatTestCount(int test_count) {
   return FormatCountableNoun(test_count, "test", "tests");
 }
 
 // Formats the count of test cases.
-static internal::String FormatTestCaseCount(int test_case_count) {
+static std::string FormatTestCaseCount(int test_case_count) {
   return FormatCountableNoun(test_case_count, "test case", "test cases");
 }
 
@@ -2514,8 +2514,10 @@  static const char * TestPartResultTypeToString(TestPartResult::Type type) {
   }
 }
 
-// Prints a TestPartResult to a String.
-static internal::String PrintTestPartResultToString(
+namespace internal {
+
+// Prints a TestPartResult to an std::string.
+static std::string PrintTestPartResultToString(
     const TestPartResult& test_part_result) {
   return (Message()
           << internal::FormatFileLocation(test_part_result.file_name(),
@@ -2526,7 +2528,7 @@  static internal::String PrintTestPartResultToString(
 
 // Prints a TestPartResult.
 static void PrintTestPartResult(const TestPartResult& test_part_result) {
-  const internal::String& result =
+  const std::string& result =
       PrintTestPartResultToString(test_part_result);
   printf("%s\n", result.c_str());
   fflush(stdout);
@@ -2545,8 +2547,6 @@  static void PrintTestPartResult(const TestPartResult& test_part_result) {
 
 // class PrettyUnitTestResultPrinter
 
-namespace internal {
-
 enum GTestColor {
   COLOR_DEFAULT,
   COLOR_RED,
@@ -2598,6 +2598,7 @@  bool ShouldUseColor(bool stdout_is_tty) {
         String::CStringEquals(term, "xterm-color") ||
         String::CStringEquals(term, "xterm-256color") ||
         String::CStringEquals(term, "screen") ||
+        String::CStringEquals(term, "screen-256color") ||
         String::CStringEquals(term, "linux") ||
         String::CStringEquals(term, "cygwin");
     return stdout_is_tty && term_supports_color;
@@ -2621,7 +2622,7 @@  void ColoredPrintf(GTestColor color, const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
 
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || GTEST_OS_IOS
   const bool use_color = false;
 #else
   static const bool in_color_mode =
@@ -2663,6 +2664,11 @@  void ColoredPrintf(GTestColor color, const char* fmt, ...) {
   va_end(args);
 }
 
+// Text printed in Google Test's text output and --gunit_list_tests
+// output to label the type parameter and value parameter for a test.
+static const char kTypeParamLabel[] = "TypeParam";
+static const char kValueParamLabel[] = "GetParam()";
+
 void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
   const char* const type_param = test_info.type_param();
   const char* const value_param = test_info.value_param();
@@ -2670,12 +2676,12 @@  void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
   if (type_param != NULL || value_param != NULL) {
     printf(", where ");
     if (type_param != NULL) {
-      printf("TypeParam = %s", type_param);
+      printf("%s = %s", kTypeParamLabel, type_param);
       if (value_param != NULL)
         printf(" and ");
     }
     if (value_param != NULL) {
-      printf("GetParam() = %s", value_param);
+      printf("%s = %s", kValueParamLabel, value_param);
     }
   }
 }
@@ -2707,8 +2713,6 @@  class PrettyUnitTestResultPrinter : public TestEventListener {
 
  private:
   static void PrintFailedTests(const UnitTest& unit_test);
-
-  internal::String test_case_name_;
 };
 
   // Fired before each iteration of tests starts.
@@ -2721,7 +2725,7 @@  void PrettyUnitTestResultPrinter::OnTestIterationStart(
 
   // Prints the filter if it's not *.  This reminds the user that some
   // tests may be skipped.
-  if (!internal::String::CStringEquals(filter, kUniversalFilter)) {
+  if (!String::CStringEquals(filter, kUniversalFilter)) {
     ColoredPrintf(COLOR_YELLOW,
                   "Note: %s filter = %s\n", GTEST_NAME_, filter);
   }
@@ -2755,22 +2759,21 @@  void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
 }
 
 void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
-  test_case_name_ = test_case.name();
-  const internal::String counts =
+  const std::string counts =
       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
   ColoredPrintf(COLOR_GREEN, "[----------] ");
-  printf("%s from %s", counts.c_str(), test_case_name_.c_str());
+  printf("%s from %s", counts.c_str(), test_case.name());
   if (test_case.type_param() == NULL) {
     printf("\n");
   } else {
-    printf(", where TypeParam = %s\n", test_case.type_param());
+    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
   }
   fflush(stdout);
 }
 
 void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
   ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
-  PrintTestName(test_case_name_.c_str(), test_info.name());
+  PrintTestName(test_info.test_case_name(), test_info.name());
   printf("\n");
   fflush(stdout);
 }
@@ -2793,7 +2796,7 @@  void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
   } else {
     ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
   }
-  PrintTestName(test_case_name_.c_str(), test_info.name());
+  PrintTestName(test_info.test_case_name(), test_info.name());
   if (test_info.result()->Failed())
     PrintFullTestCommentIfPresent(test_info);
 
@@ -2809,12 +2812,11 @@  void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
 void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
   if (!GTEST_FLAG(print_time)) return;
 
-  test_case_name_ = test_case.name();
-  const internal::String counts =
+  const std::string counts =
       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
   ColoredPrintf(COLOR_GREEN, "[----------] ");
   printf("%s from %s (%s ms total)\n\n",
-         counts.c_str(), test_case_name_.c_str(),
+         counts.c_str(), test_case.name(),
          internal::StreamableToString(test_case.elapsed_time()).c_str());
   fflush(stdout);
 }
@@ -2875,7 +2877,7 @@  void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                         num_failures == 1 ? "TEST" : "TESTS");
   }
 
-  int num_disabled = unit_test.disabled_test_count();
+  int num_disabled = unit_test.reportable_disabled_test_count();
   if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
     if (!num_failures) {
       printf("\n");  // Add a spacer if no FAILURE banner is displayed.
@@ -3029,18 +3031,27 @@  class XmlUnitTestResultPrinter : public EmptyTestEventListener {
   // is_attribute is true, the text is meant to appear as an attribute
   // value, and normalizable whitespace is preserved by replacing it
   // with character references.
-  static String EscapeXml(const char* str, bool is_attribute);
+  static std::string EscapeXml(const std::string& str, bool is_attribute);
 
   // Returns the given string with all characters invalid in XML removed.
-  static string RemoveInvalidXmlCharacters(const string& str);
+  static std::string RemoveInvalidXmlCharacters(const std::string& str);
 
   // Convenience wrapper around EscapeXml when str is an attribute value.
-  static String EscapeXmlAttribute(const char* str) {
+  static std::string EscapeXmlAttribute(const std::string& str) {
     return EscapeXml(str, true);
   }
 
   // Convenience wrapper around EscapeXml when str is not an attribute value.
-  static String EscapeXmlText(const char* str) { return EscapeXml(str, false); }
+  static std::string EscapeXmlText(const char* str) {
+    return EscapeXml(str, false);
+  }
+
+  // Verifies that the given attribute belongs to the given element and
+  // streams the attribute as XML.
+  static void OutputXmlAttribute(std::ostream* stream,
+                                 const std::string& element_name,
+                                 const std::string& name,
+                                 const std::string& value);
 
   // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
   static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
@@ -3051,19 +3062,21 @@  class XmlUnitTestResultPrinter : public EmptyTestEventListener {
                                 const TestInfo& test_info);
 
   // Prints an XML representation of a TestCase object
-  static void PrintXmlTestCase(FILE* out, const TestCase& test_case);
+  static void PrintXmlTestCase(::std::ostream* stream,
+                               const TestCase& test_case);
 
   // Prints an XML summary of unit_test to output stream out.
-  static void PrintXmlUnitTest(FILE* out, const UnitTest& unit_test);
+  static void PrintXmlUnitTest(::std::ostream* stream,
+                               const UnitTest& unit_test);
 
   // Produces a string representing the test properties in a result as space
   // delimited XML attributes based on the property key="value" pairs.
-  // When the String is not empty, it includes a space at the beginning,
+  // When the std::string is not empty, it includes a space at the beginning,
   // to delimit this attribute from prior attributes.
-  static String TestPropertiesAsXmlAttributes(const TestResult& result);
+  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
 
   // The output file.
-  const String output_file_;
+  const std::string output_file_;
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
 };
@@ -3105,7 +3118,9 @@  void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
     fflush(stderr);
     exit(EXIT_FAILURE);
   }
-  PrintXmlUnitTest(xmlout, unit_test);
+  std::stringstream stream;
+  PrintXmlUnitTest(&stream, unit_test);
+  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
   fclose(xmlout);
 }
 
@@ -3121,42 +3136,43 @@  void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
 // most invalid characters can be retained using character references.
 // TODO(wan): It might be nice to have a minimally invasive, human-readable
 // escaping scheme for invalid characters, rather than dropping them.
-String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_attribute) {
+std::string XmlUnitTestResultPrinter::EscapeXml(
+    const std::string& str, bool is_attribute) {
   Message m;
 
-  if (str != NULL) {
-    for (const char* src = str; *src; ++src) {
-      switch (*src) {
-        case '<':
-          m << "&lt;";
-          break;
-        case '>':
-          m << "&gt;";
-          break;
-        case '&':
-          m << "&amp;";
-          break;
-        case '\'':
-          if (is_attribute)
-            m << "&apos;";
-          else
-            m << '\'';
-          break;
-        case '"':
-          if (is_attribute)
-            m << "&quot;";
+  for (size_t i = 0; i < str.size(); ++i) {
+    const char ch = str[i];
+    switch (ch) {
+      case '<':
+        m << "&lt;";
+        break;
+      case '>':
+        m << "&gt;";
+        break;
+      case '&':
+        m << "&amp;";
+        break;
+      case '\'':
+        if (is_attribute)
+          m << "&apos;";
+        else
+          m << '\'';
+        break;
+      case '"':
+        if (is_attribute)
+          m << "&quot;";
+        else
+          m << '"';
+        break;
+      default:
+        if (IsValidXmlCharacter(ch)) {
+          if (is_attribute && IsNormalizableWhitespace(ch))
+            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
+              << ";";
           else
-            m << '"';
-          break;
-        default:
-          if (IsValidXmlCharacter(*src)) {
-            if (is_attribute && IsNormalizableWhitespace(*src))
-              m << String::Format("&#x%02X;", unsigned(*src));
-            else
-              m << *src;
-          }
-          break;
-      }
+            m << ch;
+        }
+        break;
     }
   }
 
@@ -3166,10 +3182,11 @@  String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_attribute) {
 // Returns the given string with all characters invalid in XML removed.
 // Currently invalid characters are dropped from the string. An
 // alternative is to replace them with certain characters such as . or ?.
-string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const string& str) {
-  string output;
+std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
+    const std::string& str) {
+  std::string output;
   output.reserve(str.size());
-  for (string::const_iterator it = str.begin(); it != str.end(); ++it)
+  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
     if (IsValidXmlCharacter(*it))
       output.push_back(*it);
 
@@ -3199,6 +3216,32 @@  std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
   return ss.str();
 }
 
+// Converts the given epoch time in milliseconds to a date string in the ISO
+// 8601 format, without the timezone information.
+std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
+  // Using non-reentrant version as localtime_r is not portable.
+  time_t seconds = static_cast<time_t>(ms / 1000);
+#ifdef _MSC_VER
+# pragma warning(push)          // Saves the current warning state.
+# pragma warning(disable:4996)  // Temporarily disables warning 4996
+                                // (function or variable may be unsafe).
+  const struct tm* const time_struct = localtime(&seconds);  // NOLINT
+# pragma warning(pop)           // Restores the warning state again.
+#else
+  const struct tm* const time_struct = localtime(&seconds);  // NOLINT
+#endif
+  if (time_struct == NULL)
+    return "";  // Invalid ms value
+
+  // YYYY-MM-DDThh:mm:ss
+  return StreamableToString(time_struct->tm_year + 1900) + "-" +
+      String::FormatIntWidth2(time_struct->tm_mon + 1) + "-" +
+      String::FormatIntWidth2(time_struct->tm_mday) + "T" +
+      String::FormatIntWidth2(time_struct->tm_hour) + ":" +
+      String::FormatIntWidth2(time_struct->tm_min) + ":" +
+      String::FormatIntWidth2(time_struct->tm_sec);
+}
+
 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
 void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
                                                      const char* data) {
@@ -3219,45 +3262,63 @@  void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
   *stream << "]]>";
 }
 
+void XmlUnitTestResultPrinter::OutputXmlAttribute(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    const std::string& value) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Attribute " << name << " is not allowed for element <" << element_name
+      << ">.";
+
+  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
+}
+
 // Prints an XML representation of a TestInfo object.
 // TODO(wan): There is also value in printing properties with the plain printer.
 void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
                                                  const char* test_case_name,
                                                  const TestInfo& test_info) {
   const TestResult& result = *test_info.result();
-  *stream << "    <testcase name=\""
-          << EscapeXmlAttribute(test_info.name()).c_str() << "\"";
+  const std::string kTestcase = "testcase";
+
+  *stream << "    <testcase";
+  OutputXmlAttribute(stream, kTestcase, "name", test_info.name());
 
   if (test_info.value_param() != NULL) {
-    *stream << " value_param=\"" << EscapeXmlAttribute(test_info.value_param())
-            << "\"";
+    OutputXmlAttribute(stream, kTestcase, "value_param",
+                       test_info.value_param());
   }
   if (test_info.type_param() != NULL) {
-    *stream << " type_param=\"" << EscapeXmlAttribute(test_info.type_param())
-            << "\"";
+    OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param());
   }
 
-  *stream << " status=\""
-          << (test_info.should_run() ? "run" : "notrun")
-          << "\" time=\""
-          << FormatTimeInMillisAsSeconds(result.elapsed_time())
-          << "\" classname=\"" << EscapeXmlAttribute(test_case_name).c_str()
-          << "\"" << TestPropertiesAsXmlAttributes(result).c_str();
+  OutputXmlAttribute(stream, kTestcase, "status",
+                     test_info.should_run() ? "run" : "notrun");
+  OutputXmlAttribute(stream, kTestcase, "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(stream, kTestcase, "classname", test_case_name);
+  *stream << TestPropertiesAsXmlAttributes(result);
 
   int failures = 0;
   for (int i = 0; i < result.total_part_count(); ++i) {
     const TestPartResult& part = result.GetTestPartResult(i);
     if (part.failed()) {
-      if (++failures == 1)
+      if (++failures == 1) {
         *stream << ">\n";
-      *stream << "      <failure message=\""
-              << EscapeXmlAttribute(part.summary()).c_str()
-              << "\" type=\"\">";
+      }
       const string location = internal::FormatCompilerIndependentFileLocation(
           part.file_name(), part.line_number());
-      const string message = location + "\n" + part.message();
-      OutputXmlCDataSection(stream,
-                            RemoveInvalidXmlCharacters(message).c_str());
+      const string summary = location + "\n" + part.summary();
+      *stream << "      <failure message=\""
+              << EscapeXmlAttribute(summary.c_str())
+              << "\" type=\"\">";
+      const string detail = location + "\n" + part.message();
+      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
       *stream << "</failure>\n";
     }
   }
@@ -3269,49 +3330,73 @@  void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
 }
 
 // Prints an XML representation of a TestCase object
-void XmlUnitTestResultPrinter::PrintXmlTestCase(FILE* out,
+void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
                                                 const TestCase& test_case) {
-  fprintf(out,
-          "  <testsuite name=\"%s\" tests=\"%d\" failures=\"%d\" "
-          "disabled=\"%d\" ",
-          EscapeXmlAttribute(test_case.name()).c_str(),
-          test_case.total_test_count(),
-          test_case.failed_test_count(),
-          test_case.disabled_test_count());
-  fprintf(out,
-          "errors=\"0\" time=\"%s\">\n",
-          FormatTimeInMillisAsSeconds(test_case.elapsed_time()).c_str());
+  const std::string kTestsuite = "testsuite";
+  *stream << "  <" << kTestsuite;
+  OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
+  OutputXmlAttribute(stream, kTestsuite, "tests",
+                     StreamableToString(test_case.reportable_test_count()));
+  OutputXmlAttribute(stream, kTestsuite, "failures",
+                     StreamableToString(test_case.failed_test_count()));
+  OutputXmlAttribute(
+      stream, kTestsuite, "disabled",
+      StreamableToString(test_case.reportable_disabled_test_count()));
+  OutputXmlAttribute(stream, kTestsuite, "errors", "0");
+  OutputXmlAttribute(stream, kTestsuite, "time",
+                     FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
+  *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result())
+          << ">\n";
+
   for (int i = 0; i < test_case.total_test_count(); ++i) {
-    ::std::stringstream stream;
-    OutputXmlTestInfo(&stream, test_case.name(), *test_case.GetTestInfo(i));
-    fprintf(out, "%s", StringStreamToString(&stream).c_str());
+    if (test_case.GetTestInfo(i)->is_reportable())
+      OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i));
   }
-  fprintf(out, "  </testsuite>\n");
+  *stream << "  </" << kTestsuite << ">\n";
 }
 
 // Prints an XML summary of unit_test to output stream out.
-void XmlUnitTestResultPrinter::PrintXmlUnitTest(FILE* out,
+void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
                                                 const UnitTest& unit_test) {
-  fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
-  fprintf(out,
-          "<testsuites tests=\"%d\" failures=\"%d\" disabled=\"%d\" "
-          "errors=\"0\" time=\"%s\" ",
-          unit_test.total_test_count(),
-          unit_test.failed_test_count(),
-          unit_test.disabled_test_count(),
-          FormatTimeInMillisAsSeconds(unit_test.elapsed_time()).c_str());
+  const std::string kTestsuites = "testsuites";
+
+  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  *stream << "<" << kTestsuites;
+
+  OutputXmlAttribute(stream, kTestsuites, "tests",
+                     StreamableToString(unit_test.reportable_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "failures",
+                     StreamableToString(unit_test.failed_test_count()));
+  OutputXmlAttribute(
+      stream, kTestsuites, "disabled",
+      StreamableToString(unit_test.reportable_disabled_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
+  OutputXmlAttribute(
+      stream, kTestsuites, "timestamp",
+      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
+  OutputXmlAttribute(stream, kTestsuites, "time",
+                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
+
   if (GTEST_FLAG(shuffle)) {
-    fprintf(out, "random_seed=\"%d\" ", unit_test.random_seed());
+    OutputXmlAttribute(stream, kTestsuites, "random_seed",
+                       StreamableToString(unit_test.random_seed()));
+  }
+
+  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
+
+  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
+  *stream << ">\n";
+
+  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
+    if (unit_test.GetTestCase(i)->reportable_test_count() > 0)
+      PrintXmlTestCase(stream, *unit_test.GetTestCase(i));
   }
-  fprintf(out, "name=\"AllTests\">\n");
-  for (int i = 0; i < unit_test.total_test_case_count(); ++i)
-    PrintXmlTestCase(out, *unit_test.GetTestCase(i));
-  fprintf(out, "</testsuites>\n");
+  *stream << "</" << kTestsuites << ">\n";
 }
 
 // Produces a string representing the test properties in a result as space
 // delimited XML attributes based on the property key="value" pairs.
-String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
+std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
     const TestResult& result) {
   Message attributes;
   for (int i = 0; i < result.test_property_count(); ++i) {
@@ -3326,112 +3411,6 @@  String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
 
 #if GTEST_CAN_STREAM_RESULTS_
 
-// Streams test results to the given port on the given host machine.
-class StreamingListener : public EmptyTestEventListener {
- public:
-  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
-  static string UrlEncode(const char* str);
-
-  StreamingListener(const string& host, const string& port)
-      : sockfd_(-1), host_name_(host), port_num_(port) {
-    MakeConnection();
-    Send("gtest_streaming_protocol_version=1.0\n");
-  }
-
-  virtual ~StreamingListener() {
-    if (sockfd_ != -1)
-      CloseConnection();
-  }
-
-  void OnTestProgramStart(const UnitTest& /* unit_test */) {
-    Send("event=TestProgramStart\n");
-  }
-
-  void OnTestProgramEnd(const UnitTest& unit_test) {
-    // Note that Google Test current only report elapsed time for each
-    // test iteration, not for the entire test program.
-    Send(String::Format("event=TestProgramEnd&passed=%d\n",
-                        unit_test.Passed()));
-
-    // Notify the streaming server to stop.
-    CloseConnection();
-  }
-
-  void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
-    Send(String::Format("event=TestIterationStart&iteration=%d\n",
-                        iteration));
-  }
-
-  void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
-    Send(String::Format("event=TestIterationEnd&passed=%d&elapsed_time=%sms\n",
-                        unit_test.Passed(),
-                        StreamableToString(unit_test.elapsed_time()).c_str()));
-  }
-
-  void OnTestCaseStart(const TestCase& test_case) {
-    Send(String::Format("event=TestCaseStart&name=%s\n", test_case.name()));
-  }
-
-  void OnTestCaseEnd(const TestCase& test_case) {
-    Send(String::Format("event=TestCaseEnd&passed=%d&elapsed_time=%sms\n",
-                        test_case.Passed(),
-                        StreamableToString(test_case.elapsed_time()).c_str()));
-  }
-
-  void OnTestStart(const TestInfo& test_info) {
-    Send(String::Format("event=TestStart&name=%s\n", test_info.name()));
-  }
-
-  void OnTestEnd(const TestInfo& test_info) {
-    Send(String::Format(
-        "event=TestEnd&passed=%d&elapsed_time=%sms\n",
-        (test_info.result())->Passed(),
-        StreamableToString((test_info.result())->elapsed_time()).c_str()));
-  }
-
-  void OnTestPartResult(const TestPartResult& test_part_result) {
-    const char* file_name = test_part_result.file_name();
-    if (file_name == NULL)
-      file_name = "";
-    Send(String::Format("event=TestPartResult&file=%s&line=%d&message=",
-                        UrlEncode(file_name).c_str(),
-                        test_part_result.line_number()));
-    Send(UrlEncode(test_part_result.message()) + "\n");
-  }
-
- private:
-  // Creates a client socket and connects to the server.
-  void MakeConnection();
-
-  // Closes the socket.
-  void CloseConnection() {
-    GTEST_CHECK_(sockfd_ != -1)
-        << "CloseConnection() can be called only when there is a connection.";
-
-    close(sockfd_);
-    sockfd_ = -1;
-  }
-
-  // Sends a string to the socket.
-  void Send(const string& message) {
-    GTEST_CHECK_(sockfd_ != -1)
-        << "Send() can be called only when there is a connection.";
-
-    const int len = static_cast<int>(message.length());
-    if (write(sockfd_, message.c_str(), len) != len) {
-      GTEST_LOG_(WARNING)
-          << "stream_result_to: failed to stream to "
-          << host_name_ << ":" << port_num_;
-    }
-  }
-
-  int sockfd_;   // socket file descriptor
-  const string host_name_;
-  const string port_num_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
-};  // class StreamingListener
-
 // Checks if str contains '=', '&', '%' or '\n' characters. If yes,
 // replaces them by "%xx" where xx is their hexadecimal value. For
 // example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
@@ -3446,7 +3425,7 @@  string StreamingListener::UrlEncode(const char* str) {
       case '=':
       case '&':
       case '\n':
-        result.append(String::Format("%%%02x", static_cast<unsigned char>(ch)));
+        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
         break;
       default:
         result.push_back(ch);
@@ -3456,7 +3435,7 @@  string StreamingListener::UrlEncode(const char* str) {
   return result;
 }
 
-void StreamingListener::MakeConnection() {
+void StreamingListener::SocketWriter::MakeConnection() {
   GTEST_CHECK_(sockfd_ == -1)
       << "MakeConnection() can't be called when there is already a connection.";
 
@@ -3504,8 +3483,8 @@  void StreamingListener::MakeConnection() {
 
 // Pushes the given source file location and message onto a per-thread
 // trace stack maintained by Google Test.
-// L < UnitTest::mutex_
-ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) {
+ScopedTrace::ScopedTrace(const char* file, int line, const Message& message)
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
   TraceInfo trace;
   trace.file = file;
   trace.line = line;
@@ -3515,35 +3494,64 @@  ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) {
 }
 
 // Pops the info pushed by the c'tor.
-// L < UnitTest::mutex_
-ScopedTrace::~ScopedTrace() {
+ScopedTrace::~ScopedTrace()
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
   UnitTest::GetInstance()->PopGTestTrace();
 }
 
 
 // class OsStackTraceGetter
 
-// Returns the current OS stack trace as a String.  Parameters:
+// Returns the current OS stack trace as an std::string.  Parameters:
 //
 //   max_depth  - the maximum number of stack frames to be included
 //                in the trace.
 //   skip_count - the number of top frames to be skipped; doesn't count
 //                against max_depth.
 //
-// L < mutex_
-// We use "L < mutex_" to denote that the function may acquire mutex_.
-String OsStackTraceGetter::CurrentStackTrace(int, int) {
-  return String("");
+string OsStackTraceGetter::CurrentStackTrace(int /* max_depth */,
+                                             int /* skip_count */)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  return "";
 }
 
-// L < mutex_
-void OsStackTraceGetter::UponLeavingGTest() {
+void OsStackTraceGetter::UponLeavingGTest()
+    GTEST_LOCK_EXCLUDED_(mutex_) {
 }
 
 const char* const
 OsStackTraceGetter::kElidedFramesMarker =
     "... " GTEST_NAME_ " internal frames ...";
 
+// A helper class that creates the premature-exit file in its
+// constructor and deletes the file in its destructor.
+class ScopedPrematureExitFile {
+ public:
+  explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
+      : premature_exit_filepath_(premature_exit_filepath) {
+    // If a path to the premature-exit file is specified...
+    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
+      // create the file with a single "0" character in it.  I/O
+      // errors are ignored as there's nothing better we can do and we
+      // don't want to fail the test because of this.
+      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
+      fwrite("0", 1, 1, pfile);
+      fclose(pfile);
+    }
+  }
+
+  ~ScopedPrematureExitFile() {
+    if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') {
+      remove(premature_exit_filepath_);
+    }
+  }
+
+ private:
+  const char* const premature_exit_filepath_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
+};
+
 }  // namespace internal
 
 // class TestEventListeners
@@ -3630,7 +3638,7 @@  void TestEventListeners::SuppressEventForwarding() {
 // We don't protect this under mutex_ as a user is not supposed to
 // call this before main() starts, from which point on the return
 // value will never change.
-UnitTest * UnitTest::GetInstance() {
+UnitTest* UnitTest::GetInstance() {
   // When compiled with MSVC 7.1 in optimized mode, destroying the
   // UnitTest object upon exiting the program messes up the exit code,
   // causing successful tests to appear failed.  We have to use a
@@ -3680,17 +3688,33 @@  int UnitTest::successful_test_count() const {
 // Gets the number of failed tests.
 int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
 
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTest::reportable_disabled_test_count() const {
+  return impl()->reportable_disabled_test_count();
+}
+
 // Gets the number of disabled tests.
 int UnitTest::disabled_test_count() const {
   return impl()->disabled_test_count();
 }
 
+// Gets the number of tests to be printed in the XML report.
+int UnitTest::reportable_test_count() const {
+  return impl()->reportable_test_count();
+}
+
 // Gets the number of all tests.
 int UnitTest::total_test_count() const { return impl()->total_test_count(); }
 
 // Gets the number of tests that should run.
 int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
 
+// Gets the time of the test program start, in ms from the start of the
+// UNIX epoch.
+internal::TimeInMillis UnitTest::start_timestamp() const {
+    return impl()->start_timestamp();
+}
+
 // Gets the elapsed time, in milliseconds.
 internal::TimeInMillis UnitTest::elapsed_time() const {
   return impl()->elapsed_time();
@@ -3709,6 +3733,12 @@  const TestCase* UnitTest::GetTestCase(int i) const {
   return impl()->GetTestCase(i);
 }
 
+// Returns the TestResult containing information on test failures and
+// properties logged outside of individual test cases.
+const TestResult& UnitTest::ad_hoc_test_result() const {
+  return *impl()->ad_hoc_test_result();
+}
+
 // Gets the i-th test case among all the test cases. i can range from 0 to
 // total_test_case_count() - 1. If i is not in that range, returns NULL.
 TestCase* UnitTest::GetMutableTestCase(int i) {
@@ -3744,12 +3774,12 @@  Environment* UnitTest::AddEnvironment(Environment* env) {
 // assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
 // this to report their results.  The user code should use the
 // assertion macros instead of calling this directly.
-// L < mutex_
-void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
-                                 const char* file_name,
-                                 int line_number,
-                                 const internal::String& message,
-                                 const internal::String& os_stack_trace) {
+void UnitTest::AddTestPartResult(
+    TestPartResult::Type result_type,
+    const char* file_name,
+    int line_number,
+    const std::string& message,
+    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
   Message msg;
   msg << message;
 
@@ -3796,7 +3826,7 @@  void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
 #endif  // GTEST_OS_WINDOWS
     } else if (GTEST_FLAG(throw_on_failure)) {
 #if GTEST_HAS_EXCEPTIONS
-      throw GoogleTestFailureException(result);
+      throw internal::GoogleTestFailureException(result);
 #else
       // We cannot call abort() as it generates a pop-up in debug mode
       // that cannot be suppressed in VC 7.1 or below.
@@ -3806,12 +3836,14 @@  void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
   }
 }
 
-// Creates and adds a property to the current TestResult. If a property matching
-// the supplied value already exists, updates its value instead.
-void UnitTest::RecordPropertyForCurrentTest(const char* key,
-                                            const char* value) {
-  const TestProperty test_property(key, value);
-  impl_->current_test_result()->RecordProperty(test_property);
+// Adds a TestProperty to the current TestResult object when invoked from
+// inside a test, to current TestCase's ad_hoc_test_result_ when invoked
+// from SetUpTestCase or TearDownTestCase, or to the global property set
+// when invoked elsewhere.  If the result already contains a property with
+// the same key, the value will be updated.
+void UnitTest::RecordProperty(const std::string& key,
+                              const std::string& value) {
+  impl_->RecordProperty(TestProperty(key, value));
 }
 
 // Runs all tests in this UnitTest object and prints the result.
@@ -3820,20 +3852,44 @@  void UnitTest::RecordPropertyForCurrentTest(const char* key,
 // We don't protect this under mutex_, as we only support calling it
 // from the main thread.
 int UnitTest::Run() {
+  const bool in_death_test_child_process =
+      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
+
+  // Google Test implements this protocol for catching that a test
+  // program exits before returning control to Google Test:
+  //
+  //   1. Upon start, Google Test creates a file whose absolute path
+  //      is specified by the environment variable
+  //      TEST_PREMATURE_EXIT_FILE.
+  //   2. When Google Test has finished its work, it deletes the file.
+  //
+  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
+  // running a Google-Test-based test program and check the existence
+  // of the file at the end of the test execution to see if it has
+  // exited prematurely.
+
+  // If we are in the child process of a death test, don't
+  // create/delete the premature exit file, as doing so is unnecessary
+  // and will confuse the parent process.  Otherwise, create/delete
+  // the file upon entering/leaving this function.  If the program
+  // somehow exits before this function has a chance to return, the
+  // premature-exit file will be left undeleted, causing a test runner
+  // that understands the premature-exit-file protocol to report the
+  // test as having failed.
+  const internal::ScopedPrematureExitFile premature_exit_file(
+      in_death_test_child_process ?
+      NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
+
   // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
   // used for the duration of the program.
   impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
 
 #if GTEST_HAS_SEH
-  const bool in_death_test_child_process =
-      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
-
   // Either the user wants Google Test to catch exceptions thrown by the
   // tests or this is executing in the context of death test child
   // process. In either case the user does not want to see pop-up dialogs
   // about crashes - they are expected.
   if (impl()->catch_exceptions() || in_death_test_child_process) {
-
 # if !GTEST_OS_WINDOWS_MOBILE
     // SetErrorMode doesn't exist on CE.
     SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
@@ -3864,7 +3920,6 @@  int UnitTest::Run() {
           0x0,                                    // Clear the following flags:
           _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
 # endif
-
   }
 #endif  // GTEST_HAS_SEH
 
@@ -3882,16 +3937,16 @@  const char* UnitTest::original_working_dir() const {
 
 // Returns the TestCase object for the test that's currently running,
 // or NULL if no test is running.
-// L < mutex_
-const TestCase* UnitTest::current_test_case() const {
+const TestCase* UnitTest::current_test_case() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
   internal::MutexLock lock(&mutex_);
   return impl_->current_test_case();
 }
 
 // Returns the TestInfo object for the test that's currently running,
 // or NULL if no test is running.
-// L < mutex_
-const TestInfo* UnitTest::current_test_info() const {
+const TestInfo* UnitTest::current_test_info() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
   internal::MutexLock lock(&mutex_);
   return impl_->current_test_info();
 }
@@ -3902,9 +3957,9 @@  int UnitTest::random_seed() const { return impl_->random_seed(); }
 #if GTEST_HAS_PARAM_TEST
 // Returns ParameterizedTestCaseRegistry object used to keep track of
 // value-parameterized tests and instantiate and register them.
-// L < mutex_
 internal::ParameterizedTestCaseRegistry&
-    UnitTest::parameterized_test_registry() {
+    UnitTest::parameterized_test_registry()
+        GTEST_LOCK_EXCLUDED_(mutex_) {
   return impl_->parameterized_test_registry();
 }
 #endif  // GTEST_HAS_PARAM_TEST
@@ -3921,15 +3976,15 @@  UnitTest::~UnitTest() {
 
 // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
 // Google Test trace stack.
-// L < mutex_
-void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) {
+void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
   internal::MutexLock lock(&mutex_);
   impl_->gtest_trace_stack().push_back(trace);
 }
 
 // Pops a trace from the per-thread Google Test trace stack.
-// L < mutex_
-void UnitTest::PopGTestTrace() {
+void UnitTest::PopGTestTrace()
+    GTEST_LOCK_EXCLUDED_(mutex_) {
   internal::MutexLock lock(&mutex_);
   impl_->gtest_trace_stack().pop_back();
 }
@@ -3965,9 +4020,9 @@  UnitTestImpl::UnitTestImpl(UnitTest* parent)
       post_flag_parse_init_performed_(false),
       random_seed_(0),  // Will be overridden by the flag before first use.
       random_(0),  // Will be reseeded before first use.
+      start_timestamp_(0),
       elapsed_time_(0),
 #if GTEST_HAS_DEATH_TEST
-      internal_run_death_test_flag_(NULL),
       death_test_factory_(new DefaultDeathTestFactory),
 #endif
       // Will be overridden by the flag before first use.
@@ -3985,6 +4040,28 @@  UnitTestImpl::~UnitTestImpl() {
   delete os_stack_trace_getter_;
 }
 
+// Adds a TestProperty to the current TestResult object when invoked in a
+// context of a test, to current test case's ad_hoc_test_result when invoke
+// from SetUpTestCase/TearDownTestCase, or to the global property set
+// otherwise.  If the result already contains a property with the same key,
+// the value will be updated.
+void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
+  std::string xml_element;
+  TestResult* test_result;  // TestResult appropriate for property recording.
+
+  if (current_test_info_ != NULL) {
+    xml_element = "testcase";
+    test_result = &(current_test_info_->result_);
+  } else if (current_test_case_ != NULL) {
+    xml_element = "testsuite";
+    test_result = &(current_test_case_->ad_hoc_test_result_);
+  } else {
+    xml_element = "testsuites";
+    test_result = &ad_hoc_test_result_;
+  }
+  test_result->RecordProperty(xml_element, test_property);
+}
+
 #if GTEST_HAS_DEATH_TEST
 // Disables event forwarding if the control is currently in a death test
 // subprocess. Must not be called before InitGoogleTest.
@@ -3997,7 +4074,7 @@  void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
 // Initializes event listeners performing XML output as specified by
 // UnitTestOptions. Must not be called before InitGoogleTest.
 void UnitTestImpl::ConfigureXmlOutput() {
-  const String& output_format = UnitTestOptions::GetOutputFormat();
+  const std::string& output_format = UnitTestOptions::GetOutputFormat();
   if (output_format == "xml") {
     listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
         UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
@@ -4009,13 +4086,13 @@  void UnitTestImpl::ConfigureXmlOutput() {
 }
 
 #if GTEST_CAN_STREAM_RESULTS_
-// Initializes event listeners for streaming test results in String form.
+// Initializes event listeners for streaming test results in string form.
 // Must not be called before InitGoogleTest.
 void UnitTestImpl::ConfigureStreamingOutput() {
-  const string& target = GTEST_FLAG(stream_result_to);
+  const std::string& target = GTEST_FLAG(stream_result_to);
   if (!target.empty()) {
     const size_t pos = target.find(':');
-    if (pos != string::npos) {
+    if (pos != std::string::npos) {
       listeners()->Append(new StreamingListener(target.substr(0, pos),
                                                 target.substr(pos+1)));
     } else {
@@ -4069,7 +4146,7 @@  void UnitTestImpl::PostFlagParsingInit() {
 class TestCaseNameIs {
  public:
   // Constructor.
-  explicit TestCaseNameIs(const String& name)
+  explicit TestCaseNameIs(const std::string& name)
       : name_(name) {}
 
   // Returns true iff the name of test_case matches name_.
@@ -4078,7 +4155,7 @@  class TestCaseNameIs {
   }
 
  private:
-  String name_;
+  std::string name_;
 };
 
 // Finds and returns a TestCase with the given name.  If one doesn't
@@ -4110,7 +4187,7 @@  TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
       new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
 
   // Is this a death test case?
-  if (internal::UnitTestOptions::MatchesFilter(String(test_case_name),
+  if (internal::UnitTestOptions::MatchesFilter(test_case_name,
                                                kDeathTestCaseFilter)) {
     // Yes.  Inserts the test case after the last death test case
     // defined so far.  This only works when the test cases haven't
@@ -4196,6 +4273,7 @@  bool UnitTestImpl::RunAllTests() {
 
   TestEventListener* repeater = listeners()->repeater();
 
+  start_timestamp_ = GetTimeInMillis();
   repeater->OnTestProgramStart(*parent_);
 
   // How many times to repeat the tests?  We don't want to repeat them
@@ -4388,12 +4466,12 @@  int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
   int num_selected_tests = 0;
   for (size_t i = 0; i < test_cases_.size(); i++) {
     TestCase* const test_case = test_cases_[i];
-    const String &test_case_name = test_case->name();
+    const std::string &test_case_name = test_case->name();
     test_case->set_should_run(false);
 
     for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
       TestInfo* const test_info = test_case->test_info_list()[j];
-      const String test_name(test_info->name());
+      const std::string test_name(test_info->name());
       // A test is disabled if test case name or test name matches
       // kDisableTestFilter.
       const bool is_disabled =
@@ -4427,8 +4505,33 @@  int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
   return num_selected_tests;
 }
 
+// Prints the given C-string on a single line by replacing all '\n'
+// characters with string "\\n".  If the output takes more than
+// max_length characters, only prints the first max_length characters
+// and "...".
+static void PrintOnOneLine(const char* str, int max_length) {
+  if (str != NULL) {
+    for (int i = 0; *str != '\0'; ++str) {
+      if (i >= max_length) {
+        printf("...");
+        break;
+      }
+      if (*str == '\n') {
+        printf("\\n");
+        i += 2;
+      } else {
+        printf("%c", *str);
+        ++i;
+      }
+    }
+  }
+}
+
 // Prints the names of the tests matching the user-specified filter flag.
 void UnitTestImpl::ListTestsMatchingFilter() {
+  // Print at most this many characters for each type/value parameter.
+  const int kMaxParamLength = 250;
+
   for (size_t i = 0; i < test_cases_.size(); i++) {
     const TestCase* const test_case = test_cases_[i];
     bool printed_test_case_name = false;
@@ -4439,9 +4542,23 @@  void UnitTestImpl::ListTestsMatchingFilter() {
       if (test_info->matches_filter_) {
         if (!printed_test_case_name) {
           printed_test_case_name = true;
-          printf("%s.\n", test_case->name());
+          printf("%s.", test_case->name());
+          if (test_case->type_param() != NULL) {
+            printf("  # %s = ", kTypeParamLabel);
+            // We print the type parameter on a single line to make
+            // the output easy to parse by a program.
+            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
+          }
+          printf("\n");
+        }
+        printf("  %s", test_info->name());
+        if (test_info->value_param() != NULL) {
+          printf("  # %s = ", kValueParamLabel);
+          // We print the value parameter on a single line to make the
+          // output easy to parse by a program.
+          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
         }
-        printf("  %s\n", test_info->name());
+        printf("\n");
       }
     }
   }
@@ -4505,7 +4622,7 @@  void UnitTestImpl::UnshuffleTests() {
   }
 }
 
-// Returns the current OS stack trace as a String.
+// Returns the current OS stack trace as an std::string.
 //
 // The maximum number of stack frames to be included is specified by
 // the gtest_stack_trace_depth flag.  The skip_count parameter
@@ -4515,8 +4632,8 @@  void UnitTestImpl::UnshuffleTests() {
 // For example, if Foo() calls Bar(), which in turn calls
 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
-                                       int skip_count) {
+std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
+                                            int skip_count) {
   // We pass skip_count + 1 to skip this wrapper function in addition
   // to what the user really wants to skip.
   return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
@@ -4564,7 +4681,7 @@  const char* ParseFlagValue(const char* str,
   if (str == NULL || flag == NULL) return NULL;
 
   // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
-  const String flag_str = String::Format("--%s%s", GTEST_FLAG_PREFIX_, flag);
+  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
   const size_t flag_len = flag_str.length();
   if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
 
@@ -4629,7 +4746,7 @@  bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
 //
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
-bool ParseStringFlag(const char* str, const char* flag, String* value) {
+bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
   // Gets the value of the flag as a string.
   const char* const value_str = ParseFlagValue(str, flag, false);
 
@@ -4681,7 +4798,7 @@  static void PrintColorEncoded(const char* str) {
       return;
     }
 
-    ColoredPrintf(color, "%s", String(str, p - str).c_str());
+    ColoredPrintf(color, "%s", std::string(str, p).c_str());
 
     const char ch = p[1];
     str = p + 2;
@@ -4771,7 +4888,7 @@  static const char kColorEncodedHelpMessage[] =
 template <typename CharType>
 void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
   for (int i = 1; i < *argc; i++) {
-    const String arg_string = StreamableToString(argv[i]);
+    const std::string arg_string = StreamableToString(argv[i]);
     const char* const arg = arg_string.c_str();
 
     using internal::ParseBoolFlag;
diff --git a/src/gtest/src/gtest_main.cc b/src/gtest/src/gtest_main.cc
index a09bbe0..f302822 100644
--- a/src/gtest/src/gtest_main.cc
+++ b/src/gtest/src/gtest_main.cc
@@ -27,13 +27,12 @@ 
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <iostream>
+#include <stdio.h>
 
 #include "gtest/gtest.h"
 
 GTEST_API_ int main(int argc, char **argv) {
-  std::cout << "Running main() from gtest_main.cc\n";
-
+  printf("Running main() from gtest_main.cc\n");
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

Comments

This seems to work fine with my build.

./autogen.sh --prefix=/opt/xorg-master-x86_64
--libdir=/opt/xorg-master-x86_64/lib64 --disable-glw --disable-glut
--disable-glu --disable-xvmc --disable-vdpau --enable-xcb --enable-dri
--enable-glx --enable-egl --with-dri-drivers=i965,swrast --enable-64-bit
--enable-debug --disable-gallium-llvm --disable-gallium-egl
--without-gallium-drivers --disable-gallium-g3dvl --enable-glx-tls
--enable-texture-float --enable-shared-glapi --enable-gles1 --enable-gles2

Tested-by: Ian Romanick <ian.d.romanick@intel.com>
Acked-by: Ian Romanick <ian.d.romanick@intel.com>

On 04/01/2014 09:33 AM, Vinson Lee wrote:
> This patch fixes gtest build errors on Mac OS X 10.9.
> 
> Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=73106
> Signed-off-by: Vinson Lee <vlee@freedesktop.org>
> ---
>  src/gtest/include/gtest/gtest-death-test.h         |   17 +-
>  src/gtest/include/gtest/gtest-message.h            |   74 +-
>  src/gtest/include/gtest/gtest-param-test.h         |    2 +-
>  src/gtest/include/gtest/gtest-param-test.h.pump    |    2 +-
>  src/gtest/include/gtest/gtest-printers.h           |   91 +-
>  src/gtest/include/gtest/gtest-spi.h                |    2 +-
>  src/gtest/include/gtest/gtest-test-part.h          |   17 +-
>  src/gtest/include/gtest/gtest.h                    |  304 +++--
>  src/gtest/include/gtest/gtest_pred_impl.h          |   12 +-
>  .../gtest/internal/gtest-death-test-internal.h     |   21 +-
>  src/gtest/include/gtest/internal/gtest-filepath.h  |   14 +-
>  src/gtest/include/gtest/internal/gtest-internal.h  |  182 +--
>  .../include/gtest/internal/gtest-linked_ptr.h      |    8 +-
>  .../gtest/internal/gtest-param-util-generated.h    |  593 +++++++---
>  .../internal/gtest-param-util-generated.h.pump     |    2 +-
>  .../include/gtest/internal/gtest-param-util.h      |    8 +-
>  src/gtest/include/gtest/internal/gtest-port.h      |  274 ++++-
>  src/gtest/include/gtest/internal/gtest-string.h    |  217 +---
>  src/gtest/include/gtest/internal/gtest-tuple.h     |   92 +-
>  .../include/gtest/internal/gtest-tuple.h.pump      |   13 +-
>  src/gtest/include/gtest/internal/gtest-type-util.h |   21 +-
>  .../include/gtest/internal/gtest-type-util.h.pump  |   21 +-
>  src/gtest/src/gtest-death-test.cc                  |  280 +++--
>  src/gtest/src/gtest-filepath.cc                    |   30 +-
>  src/gtest/src/gtest-internal-inl.h                 |  242 +++-
>  src/gtest/src/gtest-port.cc                        |  119 +-
>  src/gtest/src/gtest-printers.cc                    |  101 +-
>  src/gtest/src/gtest-test-part.cc                   |    6 +-
>  src/gtest/src/gtest-typed-test.cc                  |    6 +-
>  src/gtest/src/gtest.cc                             | 1241 +++++++++++---------
>  src/gtest/src/gtest_main.cc                        |    5 +-
>  31 files changed, 2509 insertions(+), 1508 deletions(-)
> 
> diff --git a/src/gtest/include/gtest/gtest-death-test.h b/src/gtest/include/gtest/gtest-death-test.h
> index a27883f..957a69c 100644
> --- a/src/gtest/include/gtest/gtest-death-test.h
> +++ b/src/gtest/include/gtest/gtest-death-test.h
> @@ -51,6 +51,17 @@ GTEST_DECLARE_string_(death_test_style);
>  
>  #if GTEST_HAS_DEATH_TEST
>  
> +namespace internal {
> +
> +// Returns a Boolean value indicating whether the caller is currently
> +// executing in the context of the death test child process.  Tools such as
> +// Valgrind heap checkers may need this to modify their behavior in death
> +// tests.  IMPORTANT: This is an internal utility.  Using it may break the
> +// implementation of death tests.  User code MUST NOT use it.
> +GTEST_API_ bool InDeathTestChild();
> +
> +}  // namespace internal
> +
>  // The following macros are useful for writing death tests.
>  
>  // Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
> @@ -75,7 +86,7 @@ GTEST_DECLARE_string_(death_test_style);
>  //   for (int i = 0; i < 5; i++) {
>  //     EXPECT_DEATH(server.ProcessRequest(i),
>  //                  "Invalid request .* in ProcessRequest()")
> -//         << "Failed to die on request " << i);
> +//                  << "Failed to die on request " << i;
>  //   }
>  //
>  //   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
> @@ -245,10 +256,10 @@ class GTEST_API_ KilledBySignal {
>  # ifdef NDEBUG
>  
>  #  define EXPECT_DEBUG_DEATH(statement, regex) \
> -  do { statement; } while (::testing::internal::AlwaysFalse())
> +  GTEST_EXECUTE_STATEMENT_(statement, regex)
>  
>  #  define ASSERT_DEBUG_DEATH(statement, regex) \
> -  do { statement; } while (::testing::internal::AlwaysFalse())
> +  GTEST_EXECUTE_STATEMENT_(statement, regex)
>  
>  # else
>  
> diff --git a/src/gtest/include/gtest/gtest-message.h b/src/gtest/include/gtest/gtest-message.h
> index 9b7142f..fe879bc 100644
> --- a/src/gtest/include/gtest/gtest-message.h
> +++ b/src/gtest/include/gtest/gtest-message.h
> @@ -48,8 +48,11 @@
>  
>  #include <limits>
>  
> -#include "gtest/internal/gtest-string.h"
> -#include "gtest/internal/gtest-internal.h"
> +#include "gtest/internal/gtest-port.h"
> +
> +// Ensures that there is at least one operator<< in the global namespace.
> +// See Message& operator<<(...) below for why.
> +void operator<<(const testing::internal::Secret&, int);
>  
>  namespace testing {
>  
> @@ -87,15 +90,7 @@ class GTEST_API_ Message {
>  
>   public:
>    // Constructs an empty Message.
> -  // We allocate the stringstream separately because otherwise each use of
> -  // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
> -  // stack frame leading to huge stack frames in some cases; gcc does not reuse
> -  // the stack space.
> -  Message() : ss_(new ::std::stringstream) {
> -    // By default, we want there to be enough precision when printing
> -    // a double to a Message.
> -    *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
> -  }
> +  Message();
>  
>    // Copy constructor.
>    Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
> @@ -118,7 +113,22 @@ class GTEST_API_ Message {
>    // Streams a non-pointer value to this object.
>    template <typename T>
>    inline Message& operator <<(const T& val) {
> -    ::GTestStreamToHelper(ss_.get(), val);
> +    // Some libraries overload << for STL containers.  These
> +    // overloads are defined in the global namespace instead of ::std.
> +    //
> +    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
> +    // overloads are visible in either the std namespace or the global
> +    // namespace, but not other namespaces, including the testing
> +    // namespace which Google Test's Message class is in.
> +    //
> +    // To allow STL containers (and other types that has a << operator
> +    // defined in the global namespace) to be used in Google Test
> +    // assertions, testing::Message must access the custom << operator
> +    // from the global namespace.  With this using declaration,
> +    // overloads of << defined in the global namespace and those
> +    // visible via Koenig lookup are both exposed in this function.
> +    using ::operator <<;
> +    *ss_ << val;
>      return *this;
>    }
>  
> @@ -140,7 +150,7 @@ class GTEST_API_ Message {
>      if (pointer == NULL) {
>        *ss_ << "(null)";
>      } else {
> -      ::GTestStreamToHelper(ss_.get(), pointer);
> +      *ss_ << pointer;
>      }
>      return *this;
>    }
> @@ -164,12 +174,8 @@ class GTEST_API_ Message {
>  
>    // These two overloads allow streaming a wide C string to a Message
>    // using the UTF-8 encoding.
> -  Message& operator <<(const wchar_t* wide_c_str) {
> -    return *this << internal::String::ShowWideCString(wide_c_str);
> -  }
> -  Message& operator <<(wchar_t* wide_c_str) {
> -    return *this << internal::String::ShowWideCString(wide_c_str);
> -  }
> +  Message& operator <<(const wchar_t* wide_c_str);
> +  Message& operator <<(wchar_t* wide_c_str);
>  
>  #if GTEST_HAS_STD_WSTRING
>    // Converts the given wide string to a narrow string using the UTF-8
> @@ -183,13 +189,11 @@ class GTEST_API_ Message {
>    Message& operator <<(const ::wstring& wstr);
>  #endif  // GTEST_HAS_GLOBAL_WSTRING
>  
> -  // Gets the text streamed to this object so far as a String.
> +  // Gets the text streamed to this object so far as an std::string.
>    // Each '\0' character in the buffer is replaced with "\\0".
>    //
>    // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
> -  internal::String GetString() const {
> -    return internal::StringStreamToString(ss_.get());
> -  }
> +  std::string GetString() const;
>  
>   private:
>  
> @@ -199,16 +203,20 @@ class GTEST_API_ Message {
>    // decide between class template specializations for T and T*, so a
>    // tr1::type_traits-like is_pointer works, and we can overload on that.
>    template <typename T>
> -  inline void StreamHelper(internal::true_type /*dummy*/, T* pointer) {
> +  inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
>      if (pointer == NULL) {
>        *ss_ << "(null)";
>      } else {
> -      ::GTestStreamToHelper(ss_.get(), pointer);
> +      *ss_ << pointer;
>      }
>    }
>    template <typename T>
> -  inline void StreamHelper(internal::false_type /*dummy*/, const T& value) {
> -    ::GTestStreamToHelper(ss_.get(), value);
> +  inline void StreamHelper(internal::false_type /*is_pointer*/,
> +                           const T& value) {
> +    // See the comments in Message& operator <<(const T&) above for why
> +    // we need this using statement.
> +    using ::operator <<;
> +    *ss_ << value;
>    }
>  #endif  // GTEST_OS_SYMBIAN
>  
> @@ -225,6 +233,18 @@ inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
>    return os << sb.GetString();
>  }
>  
> +namespace internal {
> +
> +// Converts a streamable value to an std::string.  A NULL pointer is
> +// converted to "(null)".  When the input value is a ::string,
> +// ::std::string, ::wstring, or ::std::wstring object, each NUL
> +// character in it is replaced with "\\0".
> +template <typename T>
> +std::string StreamableToString(const T& streamable) {
> +  return (Message() << streamable).GetString();
> +}
> +
> +}  // namespace internal
>  }  // namespace testing
>  
>  #endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
> diff --git a/src/gtest/include/gtest/gtest-param-test.h b/src/gtest/include/gtest/gtest-param-test.h
> index 6407cfd..d6702c8 100644
> --- a/src/gtest/include/gtest/gtest-param-test.h
> +++ b/src/gtest/include/gtest/gtest-param-test.h
> @@ -1257,7 +1257,7 @@ inline internal::ParamGenerator<bool> Bool() {
>  // Boolean flags:
>  //
>  // class FlagDependentTest
> -//     : public testing::TestWithParam<tuple(bool, bool)> > {
> +//     : public testing::TestWithParam<tuple<bool, bool> > {
>  //   virtual void SetUp() {
>  //     // Assigns external_flag_1 and external_flag_2 values from the tuple.
>  //     tie(external_flag_1, external_flag_2) = GetParam();
> diff --git a/src/gtest/include/gtest/gtest-param-test.h.pump b/src/gtest/include/gtest/gtest-param-test.h.pump
> index 401cb51..2dc9303 100644
> --- a/src/gtest/include/gtest/gtest-param-test.h.pump
> +++ b/src/gtest/include/gtest/gtest-param-test.h.pump
> @@ -414,7 +414,7 @@ inline internal::ParamGenerator<bool> Bool() {
>  // Boolean flags:
>  //
>  // class FlagDependentTest
> -//     : public testing::TestWithParam<tuple(bool, bool)> > {
> +//     : public testing::TestWithParam<tuple<bool, bool> > {
>  //   virtual void SetUp() {
>  //     // Assigns external_flag_1 and external_flag_2 values from the tuple.
>  //     tie(external_flag_1, external_flag_2) = GetParam();
> diff --git a/src/gtest/include/gtest/gtest-printers.h b/src/gtest/include/gtest/gtest-printers.h
> index 9cbab3f..0639d9f 100644
> --- a/src/gtest/include/gtest/gtest-printers.h
> +++ b/src/gtest/include/gtest/gtest-printers.h
> @@ -630,9 +630,12 @@ void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
>    }
>  }
>  // This overload prints a (const) char array compactly.
> -GTEST_API_ void UniversalPrintArray(const char* begin,
> -                                    size_t len,
> -                                    ::std::ostream* os);
> +GTEST_API_ void UniversalPrintArray(
> +    const char* begin, size_t len, ::std::ostream* os);
> +
> +// This overload prints a (const) wchar_t array compactly.
> +GTEST_API_ void UniversalPrintArray(
> +    const wchar_t* begin, size_t len, ::std::ostream* os);
>  
>  // Implements printing an array type T[N].
>  template <typename T, size_t N>
> @@ -673,19 +676,72 @@ class UniversalPrinter<T&> {
>  // Prints a value tersely: for a reference type, the referenced value
>  // (but not the address) is printed; for a (const) char pointer, the
>  // NUL-terminated string (but not the pointer) is printed.
> +
>  template <typename T>
> -void UniversalTersePrint(const T& value, ::std::ostream* os) {
> -  UniversalPrint(value, os);
> -}
> -inline void UniversalTersePrint(const char* str, ::std::ostream* os) {
> -  if (str == NULL) {
> -    *os << "NULL";
> -  } else {
> -    UniversalPrint(string(str), os);
> +class UniversalTersePrinter {
> + public:
> +  static void Print(const T& value, ::std::ostream* os) {
> +    UniversalPrint(value, os);
>    }
> -}
> -inline void UniversalTersePrint(char* str, ::std::ostream* os) {
> -  UniversalTersePrint(static_cast<const char*>(str), os);
> +};
> +template <typename T>
> +class UniversalTersePrinter<T&> {
> + public:
> +  static void Print(const T& value, ::std::ostream* os) {
> +    UniversalPrint(value, os);
> +  }
> +};
> +template <typename T, size_t N>
> +class UniversalTersePrinter<T[N]> {
> + public:
> +  static void Print(const T (&value)[N], ::std::ostream* os) {
> +    UniversalPrinter<T[N]>::Print(value, os);
> +  }
> +};
> +template <>
> +class UniversalTersePrinter<const char*> {
> + public:
> +  static void Print(const char* str, ::std::ostream* os) {
> +    if (str == NULL) {
> +      *os << "NULL";
> +    } else {
> +      UniversalPrint(string(str), os);
> +    }
> +  }
> +};
> +template <>
> +class UniversalTersePrinter<char*> {
> + public:
> +  static void Print(char* str, ::std::ostream* os) {
> +    UniversalTersePrinter<const char*>::Print(str, os);
> +  }
> +};
> +
> +#if GTEST_HAS_STD_WSTRING
> +template <>
> +class UniversalTersePrinter<const wchar_t*> {
> + public:
> +  static void Print(const wchar_t* str, ::std::ostream* os) {
> +    if (str == NULL) {
> +      *os << "NULL";
> +    } else {
> +      UniversalPrint(::std::wstring(str), os);
> +    }
> +  }
> +};
> +#endif
> +
> +template <>
> +class UniversalTersePrinter<wchar_t*> {
> + public:
> +  static void Print(wchar_t* str, ::std::ostream* os) {
> +    UniversalTersePrinter<const wchar_t*>::Print(str, os);
> +  }
> +};
> +
> +template <typename T>
> +void UniversalTersePrint(const T& value, ::std::ostream* os) {
> +  UniversalTersePrinter<T>::Print(value, os);
>  }
>  
>  // Prints a value using the type inferred by the compiler.  The
> @@ -694,7 +750,10 @@ inline void UniversalTersePrint(char* str, ::std::ostream* os) {
>  // NUL-terminated string.
>  template <typename T>
>  void UniversalPrint(const T& value, ::std::ostream* os) {
> -  UniversalPrinter<T>::Print(value, os);
> +  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
> +  // UniversalPrinter with T directly.
> +  typedef T T1;
> +  UniversalPrinter<T1>::Print(value, os);
>  }
>  
>  #if GTEST_HAS_TR1_TUPLE
> @@ -787,7 +846,7 @@ Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
>  template <typename T>
>  ::std::string PrintToString(const T& value) {
>    ::std::stringstream ss;
> -  internal::UniversalTersePrint(value, &ss);
> +  internal::UniversalTersePrinter<T>::Print(value, &ss);
>    return ss.str();
>  }
>  
> diff --git a/src/gtest/include/gtest/gtest-spi.h b/src/gtest/include/gtest/gtest-spi.h
> index b226e55..f63fa9a 100644
> --- a/src/gtest/include/gtest/gtest-spi.h
> +++ b/src/gtest/include/gtest/gtest-spi.h
> @@ -223,7 +223,7 @@ class GTEST_API_ SingleFailureChecker {
>          (substr));\
>      {\
>        ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
> -          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS,\
> +          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
>            &gtest_failures);\
>        if (::testing::internal::AlwaysTrue()) { statement; }\
>      }\
> diff --git a/src/gtest/include/gtest/gtest-test-part.h b/src/gtest/include/gtest/gtest-test-part.h
> index 8aeea14..77eb844 100644
> --- a/src/gtest/include/gtest/gtest-test-part.h
> +++ b/src/gtest/include/gtest/gtest-test-part.h
> @@ -62,7 +62,7 @@ class GTEST_API_ TestPartResult {
>                   int a_line_number,
>                   const char* a_message)
>        : type_(a_type),
> -        file_name_(a_file_name),
> +        file_name_(a_file_name == NULL ? "" : a_file_name),
>          line_number_(a_line_number),
>          summary_(ExtractSummary(a_message)),
>          message_(a_message) {
> @@ -73,7 +73,9 @@ class GTEST_API_ TestPartResult {
>  
>    // Gets the name of the source file where the test part took place, or
>    // NULL if it's unknown.
> -  const char* file_name() const { return file_name_.c_str(); }
> +  const char* file_name() const {
> +    return file_name_.empty() ? NULL : file_name_.c_str();
> +  }
>  
>    // Gets the line in the source file where the test part took place,
>    // or -1 if it's unknown.
> @@ -96,21 +98,22 @@ class GTEST_API_ TestPartResult {
>  
>    // Returns true iff the test part fatally failed.
>    bool fatally_failed() const { return type_ == kFatalFailure; }
> +
>   private:
>    Type type_;
>  
>    // Gets the summary of the failure message by omitting the stack
>    // trace in it.
> -  static internal::String ExtractSummary(const char* message);
> +  static std::string ExtractSummary(const char* message);
>  
>    // The name of the source file where the test part took place, or
> -  // NULL if the source file is unknown.
> -  internal::String file_name_;
> +  // "" if the source file is unknown.
> +  std::string file_name_;
>    // The line in the source file where the test part took place, or -1
>    // if the line number is unknown.
>    int line_number_;
> -  internal::String summary_;  // The test failure summary.
> -  internal::String message_;  // The test failure message.
> +  std::string summary_;  // The test failure summary.
> +  std::string message_;  // The test failure message.
>  };
>  
>  // Prints a TestPartResult object.
> diff --git a/src/gtest/include/gtest/gtest.h b/src/gtest/include/gtest/gtest.h
> index cd01c7b..6fa0a39 100644
> --- a/src/gtest/include/gtest/gtest.h
> +++ b/src/gtest/include/gtest/gtest.h
> @@ -52,6 +52,7 @@
>  #define GTEST_INCLUDE_GTEST_GTEST_H_
>  
>  #include <limits>
> +#include <ostream>
>  #include <vector>
>  
>  #include "gtest/internal/gtest-internal.h"
> @@ -153,25 +154,15 @@ class ExecDeathTest;
>  class NoExecDeathTest;
>  class FinalSuccessChecker;
>  class GTestFlagSaver;
> +class StreamingListenerTest;
>  class TestResultAccessor;
>  class TestEventListenersAccessor;
>  class TestEventRepeater;
> +class UnitTestRecordPropertyTestHelper;
>  class WindowsDeathTest;
>  class UnitTestImpl* GetUnitTestImpl();
>  void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
> -                                    const String& message);
> -
> -// Converts a streamable value to a String.  A NULL pointer is
> -// converted to "(null)".  When the input value is a ::string,
> -// ::std::string, ::wstring, or ::std::wstring object, each NUL
> -// character in it is replaced with "\\0".
> -// Declared in gtest-internal.h but defined here, so that it has access
> -// to the definition of the Message class, required by the ARM
> -// compiler.
> -template <typename T>
> -String StreamableToString(const T& streamable) {
> -  return (Message() << streamable).GetString();
> -}
> +                                    const std::string& message);
>  
>  }  // namespace internal
>  
> @@ -391,20 +382,21 @@ class GTEST_API_ Test {
>    // non-fatal) failure.
>    static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
>  
> -  // Logs a property for the current test.  Only the last value for a given
> -  // key is remembered.
> -  // These are public static so they can be called from utility functions
> -  // that are not members of the test fixture.
> -  // The arguments are const char* instead strings, as Google Test is used
> -  // on platforms where string doesn't compile.
> -  //
> -  // Note that a driving consideration for these RecordProperty methods
> -  // was to produce xml output suited to the Greenspan charting utility,
> -  // which at present will only chart values that fit in a 32-bit int. It
> -  // is the user's responsibility to restrict their values to 32-bit ints
> -  // if they intend them to be used with Greenspan.
> -  static void RecordProperty(const char* key, const char* value);
> -  static void RecordProperty(const char* key, int value);
> +  // Logs a property for the current test, test case, or for the entire
> +  // invocation of the test program when used outside of the context of a
> +  // test case.  Only the last value for a given key is remembered.  These
> +  // are public static so they can be called from utility functions that are
> +  // not members of the test fixture.  Calls to RecordProperty made during
> +  // lifespan of the test (from the moment its constructor starts to the
> +  // moment its destructor finishes) will be output in XML as attributes of
> +  // the <testcase> element.  Properties recorded from fixture's
> +  // SetUpTestCase or TearDownTestCase are logged as attributes of the
> +  // corresponding <testsuite> element.  Calls to RecordProperty made in the
> +  // global context (before or after invocation of RUN_ALL_TESTS and from
> +  // SetUp/TearDown method of Environment objects registered with Google
> +  // Test) will be output as attributes of the <testsuites> element.
> +  static void RecordProperty(const std::string& key, const std::string& value);
> +  static void RecordProperty(const std::string& key, int value);
>  
>   protected:
>    // Creates a Test object.
> @@ -473,7 +465,7 @@ class TestProperty {
>    // C'tor.  TestProperty does NOT have a default constructor.
>    // Always use this constructor (with parameters) to create a
>    // TestProperty object.
> -  TestProperty(const char* a_key, const char* a_value) :
> +  TestProperty(const std::string& a_key, const std::string& a_value) :
>      key_(a_key), value_(a_value) {
>    }
>  
> @@ -488,15 +480,15 @@ class TestProperty {
>    }
>  
>    // Sets a new value, overriding the one supplied in the constructor.
> -  void SetValue(const char* new_value) {
> +  void SetValue(const std::string& new_value) {
>      value_ = new_value;
>    }
>  
>   private:
>    // The key supplied by the user.
> -  internal::String key_;
> +  std::string key_;
>    // The value supplied by the user.
> -  internal::String value_;
> +  std::string value_;
>  };
>  
>  // The result of a single Test.  This includes a list of
> @@ -547,6 +539,7 @@ class GTEST_API_ TestResult {
>  
>   private:
>    friend class TestInfo;
> +  friend class TestCase;
>    friend class UnitTest;
>    friend class internal::DefaultGlobalTestPartResultReporter;
>    friend class internal::ExecDeathTest;
> @@ -571,13 +564,16 @@ class GTEST_API_ TestResult {
>    // a non-fatal failure if invalid (e.g., if it conflicts with reserved
>    // key names). If a property is already recorded for the same key, the
>    // value will be updated, rather than storing multiple values for the same
> -  // key.
> -  void RecordProperty(const TestProperty& test_property);
> +  // key.  xml_element specifies the element for which the property is being
> +  // recorded and is used for validation.
> +  void RecordProperty(const std::string& xml_element,
> +                      const TestProperty& test_property);
>  
>    // Adds a failure if the key is a reserved attribute of Google Test
>    // testcase tags.  Returns true if the property is valid.
>    // TODO(russr): Validate attribute names are legal and human readable.
> -  static bool ValidateTestProperty(const TestProperty& test_property);
> +  static bool ValidateTestProperty(const std::string& xml_element,
> +                                   const TestProperty& test_property);
>  
>    // Adds a test part result to the list.
>    void AddTestPartResult(const TestPartResult& test_part_result);
> @@ -650,9 +646,9 @@ class GTEST_API_ TestInfo {
>      return NULL;
>    }
>  
> -  // Returns true if this test should run, that is if the test is not disabled
> -  // (or it is disabled but the also_run_disabled_tests flag has been specified)
> -  // and its full name matches the user-specified filter.
> +  // Returns true if this test should run, that is if the test is not
> +  // disabled (or it is disabled but the also_run_disabled_tests flag has
> +  // been specified) and its full name matches the user-specified filter.
>    //
>    // Google Test allows the user to filter the tests by their full names.
>    // The full name of a test Bar in test case Foo is defined as
> @@ -668,19 +664,28 @@ class GTEST_API_ TestInfo {
>    // contains the character 'A' or starts with "Foo.".
>    bool should_run() const { return should_run_; }
>  
> +  // Returns true iff this test will appear in the XML report.
> +  bool is_reportable() const {
> +    // For now, the XML report includes all tests matching the filter.
> +    // In the future, we may trim tests that are excluded because of
> +    // sharding.
> +    return matches_filter_;
> +  }
> +
>    // Returns the result of the test.
>    const TestResult* result() const { return &result_; }
>  
>   private:
> -
>  #if GTEST_HAS_DEATH_TEST
>    friend class internal::DefaultDeathTestFactory;
>  #endif  // GTEST_HAS_DEATH_TEST
>    friend class Test;
>    friend class TestCase;
>    friend class internal::UnitTestImpl;
> +  friend class internal::StreamingListenerTest;
>    friend TestInfo* internal::MakeAndRegisterTestInfo(
> -      const char* test_case_name, const char* name,
> +      const char* test_case_name,
> +      const char* name,
>        const char* type_param,
>        const char* value_param,
>        internal::TypeId fixture_class_id,
> @@ -690,9 +695,10 @@ class GTEST_API_ TestInfo {
>  
>    // Constructs a TestInfo object. The newly constructed instance assumes
>    // ownership of the factory object.
> -  TestInfo(const char* test_case_name, const char* name,
> -           const char* a_type_param,
> -           const char* a_value_param,
> +  TestInfo(const std::string& test_case_name,
> +           const std::string& name,
> +           const char* a_type_param,   // NULL if not a type-parameterized test
> +           const char* a_value_param,  // NULL if not a value-parameterized test
>             internal::TypeId fixture_class_id,
>             internal::TestFactoryBase* factory);
>  
> @@ -778,9 +784,15 @@ class GTEST_API_ TestCase {
>    // Gets the number of failed tests in this test case.
>    int failed_test_count() const;
>  
> +  // Gets the number of disabled tests that will be reported in the XML report.
> +  int reportable_disabled_test_count() const;
> +
>    // Gets the number of disabled tests in this test case.
>    int disabled_test_count() const;
>  
> +  // Gets the number of tests to be printed in the XML report.
> +  int reportable_test_count() const;
> +
>    // Get the number of tests in this test case that should run.
>    int test_to_run_count() const;
>  
> @@ -800,6 +812,10 @@ class GTEST_API_ TestCase {
>    // total_test_count() - 1. If i is not in that range, returns NULL.
>    const TestInfo* GetTestInfo(int i) const;
>  
> +  // Returns the TestResult that holds test properties recorded during
> +  // execution of SetUpTestCase and TearDownTestCase.
> +  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
> +
>   private:
>    friend class Test;
>    friend class internal::UnitTestImpl;
> @@ -852,11 +868,22 @@ class GTEST_API_ TestCase {
>      return test_info->should_run() && test_info->result()->Failed();
>    }
>  
> +  // Returns true iff the test is disabled and will be reported in the XML
> +  // report.
> +  static bool TestReportableDisabled(const TestInfo* test_info) {
> +    return test_info->is_reportable() && test_info->is_disabled_;
> +  }
> +
>    // Returns true iff test is disabled.
>    static bool TestDisabled(const TestInfo* test_info) {
>      return test_info->is_disabled_;
>    }
>  
> +  // Returns true iff this test will appear in the XML report.
> +  static bool TestReportable(const TestInfo* test_info) {
> +    return test_info->is_reportable();
> +  }
> +
>    // Returns true if the given test should run.
>    static bool ShouldRunTest(const TestInfo* test_info) {
>      return test_info->should_run();
> @@ -869,7 +896,7 @@ class GTEST_API_ TestCase {
>    void UnshuffleTests();
>  
>    // Name of the test case.
> -  internal::String name_;
> +  std::string name_;
>    // Name of the parameter type, or NULL if this is not a typed or a
>    // type-parameterized test.
>    const internal::scoped_ptr<const ::std::string> type_param_;
> @@ -888,6 +915,9 @@ class GTEST_API_ TestCase {
>    bool should_run_;
>    // Elapsed time, in milliseconds.
>    TimeInMillis elapsed_time_;
> +  // Holds test properties recorded during execution of SetUpTestCase and
> +  // TearDownTestCase.
> +  TestResult ad_hoc_test_result_;
>  
>    // We disallow copying TestCases.
>    GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
> @@ -1107,11 +1137,13 @@ class GTEST_API_ UnitTest {
>  
>    // Returns the TestCase object for the test that's currently running,
>    // or NULL if no test is running.
> -  const TestCase* current_test_case() const;
> +  const TestCase* current_test_case() const
> +      GTEST_LOCK_EXCLUDED_(mutex_);
>  
>    // Returns the TestInfo object for the test that's currently running,
>    // or NULL if no test is running.
> -  const TestInfo* current_test_info() const;
> +  const TestInfo* current_test_info() const
> +      GTEST_LOCK_EXCLUDED_(mutex_);
>  
>    // Returns the random seed used at the start of the current test run.
>    int random_seed() const;
> @@ -1121,7 +1153,8 @@ class GTEST_API_ UnitTest {
>    // value-parameterized tests and instantiate and register them.
>    //
>    // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
> -  internal::ParameterizedTestCaseRegistry& parameterized_test_registry();
> +  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
> +      GTEST_LOCK_EXCLUDED_(mutex_);
>  #endif  // GTEST_HAS_PARAM_TEST
>  
>    // Gets the number of successful test cases.
> @@ -1143,15 +1176,25 @@ class GTEST_API_ UnitTest {
>    // Gets the number of failed tests.
>    int failed_test_count() const;
>  
> +  // Gets the number of disabled tests that will be reported in the XML report.
> +  int reportable_disabled_test_count() const;
> +
>    // Gets the number of disabled tests.
>    int disabled_test_count() const;
>  
> +  // Gets the number of tests to be printed in the XML report.
> +  int reportable_test_count() const;
> +
>    // Gets the number of all tests.
>    int total_test_count() const;
>  
>    // Gets the number of tests that should run.
>    int test_to_run_count() const;
>  
> +  // Gets the time of the test program start, in ms from the start of the
> +  // UNIX epoch.
> +  TimeInMillis start_timestamp() const;
> +
>    // Gets the elapsed time, in milliseconds.
>    TimeInMillis elapsed_time() const;
>  
> @@ -1166,6 +1209,10 @@ class GTEST_API_ UnitTest {
>    // total_test_case_count() - 1. If i is not in that range, returns NULL.
>    const TestCase* GetTestCase(int i) const;
>  
> +  // Returns the TestResult containing information on test failures and
> +  // properties logged outside of individual test cases.
> +  const TestResult& ad_hoc_test_result() const;
> +
>    // Returns the list of event listeners that can be used to track events
>    // inside Google Test.
>    TestEventListeners& listeners();
> @@ -1189,12 +1236,16 @@ class GTEST_API_ UnitTest {
>    void AddTestPartResult(TestPartResult::Type result_type,
>                           const char* file_name,
>                           int line_number,
> -                         const internal::String& message,
> -                         const internal::String& os_stack_trace);
> +                         const std::string& message,
> +                         const std::string& os_stack_trace)
> +      GTEST_LOCK_EXCLUDED_(mutex_);
>  
> -  // Adds a TestProperty to the current TestResult object. If the result already
> -  // contains a property with the same key, the value will be updated.
> -  void RecordPropertyForCurrentTest(const char* key, const char* value);
> +  // Adds a TestProperty to the current TestResult object when invoked from
> +  // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
> +  // from SetUpTestCase or TearDownTestCase, or to the global property set
> +  // when invoked elsewhere.  If the result already contains a property with
> +  // the same key, the value will be updated.
> +  void RecordProperty(const std::string& key, const std::string& value);
>  
>    // Gets the i-th test case among all the test cases. i can range from 0 to
>    // total_test_case_count() - 1. If i is not in that range, returns NULL.
> @@ -1209,11 +1260,13 @@ class GTEST_API_ UnitTest {
>    friend class Test;
>    friend class internal::AssertHelper;
>    friend class internal::ScopedTrace;
> +  friend class internal::StreamingListenerTest;
> +  friend class internal::UnitTestRecordPropertyTestHelper;
>    friend Environment* AddGlobalTestEnvironment(Environment* env);
>    friend internal::UnitTestImpl* internal::GetUnitTestImpl();
>    friend void internal::ReportFailureInUnknownLocation(
>        TestPartResult::Type result_type,
> -      const internal::String& message);
> +      const std::string& message);
>  
>    // Creates an empty UnitTest.
>    UnitTest();
> @@ -1223,10 +1276,12 @@ class GTEST_API_ UnitTest {
>  
>    // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
>    // Google Test trace stack.
> -  void PushGTestTrace(const internal::TraceInfo& trace);
> +  void PushGTestTrace(const internal::TraceInfo& trace)
> +      GTEST_LOCK_EXCLUDED_(mutex_);
>  
>    // Pops a trace from the per-thread Google Test trace stack.
> -  void PopGTestTrace();
> +  void PopGTestTrace()
> +      GTEST_LOCK_EXCLUDED_(mutex_);
>  
>    // Protects mutable state in *impl_.  This is mutable as some const
>    // methods need to lock it too.
> @@ -1281,24 +1336,101 @@ GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
>  
>  namespace internal {
>  
> +// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
> +// value of type ToPrint that is an operand of a comparison assertion
> +// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
> +// the comparison, and is used to help determine the best way to
> +// format the value.  In particular, when the value is a C string
> +// (char pointer) and the other operand is an STL string object, we
> +// want to format the C string as a string, since we know it is
> +// compared by value with the string object.  If the value is a char
> +// pointer but the other operand is not an STL string object, we don't
> +// know whether the pointer is supposed to point to a NUL-terminated
> +// string, and thus want to print it as a pointer to be safe.
> +//
> +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
> +
> +// The default case.
> +template <typename ToPrint, typename OtherOperand>
> +class FormatForComparison {
> + public:
> +  static ::std::string Format(const ToPrint& value) {
> +    return ::testing::PrintToString(value);
> +  }
> +};
> +
> +// Array.
> +template <typename ToPrint, size_t N, typename OtherOperand>
> +class FormatForComparison<ToPrint[N], OtherOperand> {
> + public:
> +  static ::std::string Format(const ToPrint* value) {
> +    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
> +  }
> +};
> +
> +// By default, print C string as pointers to be safe, as we don't know
> +// whether they actually point to a NUL-terminated string.
> +
> +#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
> +  template <typename OtherOperand>                                      \
> +  class FormatForComparison<CharType*, OtherOperand> {                  \
> +   public:                                                              \
> +    static ::std::string Format(CharType* value) {                      \
> +      return ::testing::PrintToString(static_cast<const void*>(value)); \
> +    }                                                                   \
> +  }
> +
> +GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
> +GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
> +GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
> +GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
> +
> +#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
> +
> +// If a C string is compared with an STL string object, we know it's meant
> +// to point to a NUL-terminated string, and thus can print it as a string.
> +
> +#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
> +  template <>                                                           \
> +  class FormatForComparison<CharType*, OtherStringType> {               \
> +   public:                                                              \
> +    static ::std::string Format(CharType* value) {                      \
> +      return ::testing::PrintToString(value);                           \
> +    }                                                                   \
> +  }
> +
> +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
> +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
> +
> +#if GTEST_HAS_GLOBAL_STRING
> +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
> +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
> +#endif
> +
> +#if GTEST_HAS_GLOBAL_WSTRING
> +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
> +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
> +#endif
> +
> +#if GTEST_HAS_STD_WSTRING
> +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
> +GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
> +#endif
> +
> +#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
> +
>  // Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
>  // operand to be used in a failure message.  The type (but not value)
>  // of the other operand may affect the format.  This allows us to
>  // print a char* as a raw pointer when it is compared against another
> -// char*, and print it as a C string when it is compared against an
> -// std::string object, for example.
> -//
> -// The default implementation ignores the type of the other operand.
> -// Some specialized versions are used to handle formatting wide or
> -// narrow C strings.
> +// char* or void*, and print it as a C string when it is compared
> +// against an std::string object, for example.
>  //
>  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
>  template <typename T1, typename T2>
> -String FormatForComparisonFailureMessage(const T1& value,
> -                                         const T2& /* other_operand */) {
> -  // C++Builder compiles this incorrectly if the namespace isn't explicitly
> -  // given.
> -  return ::testing::PrintToString(value);
> +std::string FormatForComparisonFailureMessage(
> +    const T1& value, const T2& /* other_operand */) {
> +  return FormatForComparison<T1, T2>::Format(value);
>  }
>  
>  // The helper function for {ASSERT|EXPECT}_EQ.
> @@ -1310,7 +1442,7 @@ AssertionResult CmpHelperEQ(const char* expected_expression,
>  #ifdef _MSC_VER
>  # pragma warning(push)          // Saves the current warning state.
>  # pragma warning(disable:4389)  // Temporarily disables warning on
> -                               // signed/unsigned mismatch.
> +                                // signed/unsigned mismatch.
>  #endif
>  
>    if (expected == actual) {
> @@ -1446,11 +1578,11 @@ GTEST_IMPL_CMP_HELPER_(NE, !=);
>  // Implements the helper function for {ASSERT|EXPECT}_LE
>  GTEST_IMPL_CMP_HELPER_(LE, <=);
>  // Implements the helper function for {ASSERT|EXPECT}_LT
> -GTEST_IMPL_CMP_HELPER_(LT, < );
> +GTEST_IMPL_CMP_HELPER_(LT, <);
>  // Implements the helper function for {ASSERT|EXPECT}_GE
>  GTEST_IMPL_CMP_HELPER_(GE, >=);
>  // Implements the helper function for {ASSERT|EXPECT}_GT
> -GTEST_IMPL_CMP_HELPER_(GT, > );
> +GTEST_IMPL_CMP_HELPER_(GT, >);
>  
>  #undef GTEST_IMPL_CMP_HELPER_
>  
> @@ -1614,9 +1746,9 @@ class GTEST_API_ AssertHelper {
>          : type(t), file(srcfile), line(line_num), message(msg) { }
>  
>      TestPartResult::Type const type;
> -    const char*        const file;
> -    int                const line;
> -    String             const message;
> +    const char* const file;
> +    int const line;
> +    std::string const message;
>  
>     private:
>      GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
> @@ -1675,7 +1807,12 @@ class WithParamInterface {
>    // references static data, to reduce the opportunity for incorrect uses
>    // like writing 'WithParamInterface<bool>::GetParam()' for a test that
>    // uses a fixture whose parameter type is int.
> -  const ParamType& GetParam() const { return *parameter_; }
> +  const ParamType& GetParam() const {
> +    GTEST_CHECK_(parameter_ != NULL)
> +        << "GetParam() can only be called inside a value-parameterized test "
> +        << "-- did you intend to write TEST_P instead of TEST_F?";
> +    return *parameter_;
> +  }
>  
>   private:
>    // Sets parameter value. The caller is responsible for making sure the value
> @@ -1721,12 +1858,6 @@ class TestWithParam : public Test, public WithParamInterface<T> {
>  // usually want the fail-fast behavior of FAIL and ASSERT_*, but those
>  // writing data-driven tests often find themselves using ADD_FAILURE
>  // and EXPECT_* more.
> -//
> -// Examples:
> -//
> -//   EXPECT_TRUE(server.StatusIsOK());
> -//   ASSERT_FALSE(server.HasPendingRequest(port))
> -//       << "There are still pending requests " << "on port " << port;
>  
>  // Generates a nonfatal failure with a generic message.
>  #define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
> @@ -1900,7 +2031,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {
>  # define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
>  #endif
>  
> -// C String Comparisons.  All tests treat NULL and any non-NULL string
> +// C-string Comparisons.  All tests treat NULL and any non-NULL string
>  // as different.  Two NULLs are equal.
>  //
>  //    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
> @@ -2141,15 +2272,20 @@ bool StaticAssertTypeEq() {
>    GTEST_TEST_(test_fixture, test_name, test_fixture, \
>                ::testing::internal::GetTypeId<test_fixture>())
>  
> -// Use this macro in main() to run all tests.  It returns 0 if all
> +}  // namespace testing
> +
> +// Use this function in main() to run all tests.  It returns 0 if all
>  // tests are successful, or 1 otherwise.
>  //
>  // RUN_ALL_TESTS() should be invoked after the command line has been
>  // parsed by InitGoogleTest().
> +//
> +// This function was formerly a macro; thus, it is in the global
> +// namespace and has an all-caps name.
> +int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
>  
> -#define RUN_ALL_TESTS()\
> -  (::testing::UnitTest::GetInstance()->Run())
> -
> -}  // namespace testing
> +inline int RUN_ALL_TESTS() {
> +  return ::testing::UnitTest::GetInstance()->Run();
> +}
>  
>  #endif  // GTEST_INCLUDE_GTEST_GTEST_H_
> diff --git a/src/gtest/include/gtest/gtest_pred_impl.h b/src/gtest/include/gtest/gtest_pred_impl.h
> index 3805f85..30ae712 100644
> --- a/src/gtest/include/gtest/gtest_pred_impl.h
> +++ b/src/gtest/include/gtest/gtest_pred_impl.h
> @@ -27,7 +27,7 @@
>  // (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
> +// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
>  // 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
>  //
>  // Implements a family of generic predicate assertion macros.
> @@ -98,7 +98,7 @@ AssertionResult AssertPred1Helper(const char* pred_text,
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
>  // Don't use this in your code.
>  #define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
> -  GTEST_ASSERT_(pred_format(#v1, v1),\
> +  GTEST_ASSERT_(pred_format(#v1, v1), \
>                  on_failure)
>  
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
> @@ -144,7 +144,7 @@ AssertionResult AssertPred2Helper(const char* pred_text,
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
>  // Don't use this in your code.
>  #define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
> -  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2),\
> +  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
>                  on_failure)
>  
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
> @@ -197,7 +197,7 @@ AssertionResult AssertPred3Helper(const char* pred_text,
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
>  // Don't use this in your code.
>  #define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
> -  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3),\
> +  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
>                  on_failure)
>  
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
> @@ -257,7 +257,7 @@ AssertionResult AssertPred4Helper(const char* pred_text,
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
>  // Don't use this in your code.
>  #define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
> -  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4),\
> +  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
>                  on_failure)
>  
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
> @@ -324,7 +324,7 @@ AssertionResult AssertPred5Helper(const char* pred_text,
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
>  // Don't use this in your code.
>  #define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
> -  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5),\
> +  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
>                  on_failure)
>  
>  // Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
> diff --git a/src/gtest/include/gtest/internal/gtest-death-test-internal.h b/src/gtest/include/gtest/internal/gtest-death-test-internal.h
> index 1d9f83b..2b3a78f 100644
> --- a/src/gtest/include/gtest/internal/gtest-death-test-internal.h
> +++ b/src/gtest/include/gtest/internal/gtest-death-test-internal.h
> @@ -127,11 +127,11 @@ class GTEST_API_ DeathTest {
>    // the last death test.
>    static const char* LastMessage();
>  
> -  static void set_last_death_test_message(const String& message);
> +  static void set_last_death_test_message(const std::string& message);
>  
>   private:
>    // A string containing a description of the outcome of the last death test.
> -  static String last_death_test_message_;
> +  static std::string last_death_test_message_;
>  
>    GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
>  };
> @@ -217,12 +217,23 @@ GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
>  // The symbol "fail" here expands to something into which a message
>  // can be streamed.
>  
> +// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
> +// NDEBUG mode. In this case we need the statements to be executed, the regex is
> +// ignored, and the macro must accept a streamed message even though the message
> +// is never printed.
> +# define GTEST_EXECUTE_STATEMENT_(statement, regex) \
> +  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
> +  if (::testing::internal::AlwaysTrue()) { \
> +     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
> +  } else \
> +    ::testing::Message()
> +
>  // A class representing the parsed contents of the
>  // --gtest_internal_run_death_test flag, as it existed when
>  // RUN_ALL_TESTS was called.
>  class InternalRunDeathTestFlag {
>   public:
> -  InternalRunDeathTestFlag(const String& a_file,
> +  InternalRunDeathTestFlag(const std::string& a_file,
>                             int a_line,
>                             int an_index,
>                             int a_write_fd)
> @@ -234,13 +245,13 @@ class InternalRunDeathTestFlag {
>        posix::Close(write_fd_);
>    }
>  
> -  String file() const { return file_; }
> +  const std::string& file() const { return file_; }
>    int line() const { return line_; }
>    int index() const { return index_; }
>    int write_fd() const { return write_fd_; }
>  
>   private:
> -  String file_;
> +  std::string file_;
>    int line_;
>    int index_;
>    int write_fd_;
> diff --git a/src/gtest/include/gtest/internal/gtest-filepath.h b/src/gtest/include/gtest/internal/gtest-filepath.h
> index b36b3cf..7a13b4b 100644
> --- a/src/gtest/include/gtest/internal/gtest-filepath.h
> +++ b/src/gtest/include/gtest/internal/gtest-filepath.h
> @@ -61,11 +61,7 @@ class GTEST_API_ FilePath {
>    FilePath() : pathname_("") { }
>    FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
>  
> -  explicit FilePath(const char* pathname) : pathname_(pathname) {
> -    Normalize();
> -  }
> -
> -  explicit FilePath(const String& pathname) : pathname_(pathname) {
> +  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
>      Normalize();
>    }
>  
> @@ -78,7 +74,7 @@ class GTEST_API_ FilePath {
>      pathname_ = rhs.pathname_;
>    }
>  
> -  String ToString() const { return pathname_; }
> +  const std::string& string() const { return pathname_; }
>    const char* c_str() const { return pathname_.c_str(); }
>  
>    // Returns the current working directory, or "" if unsuccessful.
> @@ -111,8 +107,8 @@ class GTEST_API_ FilePath {
>                                           const FilePath& base_name,
>                                           const char* extension);
>  
> -  // Returns true iff the path is NULL or "".
> -  bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; }
> +  // Returns true iff the path is "".
> +  bool IsEmpty() const { return pathname_.empty(); }
>  
>    // If input name has a trailing separator character, removes it and returns
>    // the name, otherwise return the name string unmodified.
> @@ -201,7 +197,7 @@ class GTEST_API_ FilePath {
>    // separators. Returns NULL if no path separator was found.
>    const char* FindLastPathSeparator() const;
>  
> -  String pathname_;
> +  std::string pathname_;
>  };  // class FilePath
>  
>  }  // namespace internal
> diff --git a/src/gtest/include/gtest/internal/gtest-internal.h b/src/gtest/include/gtest/internal/gtest-internal.h
> index 7aa1197..0dcc3a3 100644
> --- a/src/gtest/include/gtest/internal/gtest-internal.h
> +++ b/src/gtest/include/gtest/internal/gtest-internal.h
> @@ -46,12 +46,18 @@
>  # include <unistd.h>
>  #endif  // GTEST_OS_LINUX
>  
> +#if GTEST_HAS_EXCEPTIONS
> +# include <stdexcept>
> +#endif
> +
>  #include <ctype.h>
> +#include <float.h>
>  #include <string.h>
>  #include <iomanip>
>  #include <limits>
>  #include <set>
>  
> +#include "gtest/gtest-message.h"
>  #include "gtest/internal/gtest-string.h"
>  #include "gtest/internal/gtest-filepath.h"
>  #include "gtest/internal/gtest-type-util.h"
> @@ -67,36 +73,6 @@
>  #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
>  #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
>  
> -// Google Test defines the testing::Message class to allow construction of
> -// test messages via the << operator.  The idea is that anything
> -// streamable to std::ostream can be streamed to a testing::Message.
> -// This allows a user to use his own types in Google Test assertions by
> -// overloading the << operator.
> -//
> -// util/gtl/stl_logging-inl.h overloads << for STL containers.  These
> -// overloads cannot be defined in the std namespace, as that will be
> -// undefined behavior.  Therefore, they are defined in the global
> -// namespace instead.
> -//
> -// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
> -// overloads are visible in either the std namespace or the global
> -// namespace, but not other namespaces, including the testing
> -// namespace which Google Test's Message class is in.
> -//
> -// To allow STL containers (and other types that has a << operator
> -// defined in the global namespace) to be used in Google Test assertions,
> -// testing::Message must access the custom << operator from the global
> -// namespace.  Hence this helper function.
> -//
> -// Note: Jeffrey Yasskin suggested an alternative fix by "using
> -// ::operator<<;" in the definition of Message's operator<<.  That fix
> -// doesn't require a helper function, but unfortunately doesn't
> -// compile with MSVC.
> -template <typename T>
> -inline void GTestStreamToHelper(std::ostream* os, const T& val) {
> -  *os << val;
> -}
> -
>  class ProtocolMessage;
>  namespace proto2 { class Message; }
>  
> @@ -122,17 +98,12 @@ class TestInfoImpl;                    // Opaque implementation of TestInfo
>  class UnitTestImpl;                    // Opaque implementation of UnitTest
>  
>  // How many times InitGoogleTest() has been called.
> -extern int g_init_gtest_count;
> +GTEST_API_ extern int g_init_gtest_count;
>  
>  // The text used in failure messages to indicate the start of the
>  // stack trace.
>  GTEST_API_ extern const char kStackTraceMarker[];
>  
> -// A secret type that Google Test users don't know about.  It has no
> -// definition on purpose.  Therefore it's impossible to create a
> -// Secret object, which is what we want.
> -class Secret;
> -
>  // Two overloaded helpers for checking at compile time whether an
>  // expression is a null pointer literal (i.e. NULL or any 0-valued
>  // compile-time integral constant).  Their return values have
> @@ -163,8 +134,23 @@ char (&IsNullLiteralHelper(...))[2];  // NOLINT
>  #endif  // GTEST_ELLIPSIS_NEEDS_POD_
>  
>  // Appends the user-supplied message to the Google-Test-generated message.
> -GTEST_API_ String AppendUserMessage(const String& gtest_msg,
> -                                    const Message& user_msg);
> +GTEST_API_ std::string AppendUserMessage(
> +    const std::string& gtest_msg, const Message& user_msg);
> +
> +#if GTEST_HAS_EXCEPTIONS
> +
> +// This exception is thrown by (and only by) a failed Google Test
> +// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
> +// are enabled).  We derive it from std::runtime_error, which is for
> +// errors presumably detectable only at run time.  Since
> +// std::runtime_error inherits from std::exception, many testing
> +// frameworks know how to extract and print the message inside it.
> +class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
> + public:
> +  explicit GoogleTestFailureException(const TestPartResult& failure);
> +};
> +
> +#endif  // GTEST_HAS_EXCEPTIONS
>  
>  // A helper class for creating scoped traces in user programs.
>  class GTEST_API_ ScopedTrace {
> @@ -185,77 +171,6 @@ class GTEST_API_ ScopedTrace {
>                              // c'tor and d'tor.  Therefore it doesn't
>                              // need to be used otherwise.
>  
> -// Converts a streamable value to a String.  A NULL pointer is
> -// converted to "(null)".  When the input value is a ::string,
> -// ::std::string, ::wstring, or ::std::wstring object, each NUL
> -// character in it is replaced with "\\0".
> -// Declared here but defined in gtest.h, so that it has access
> -// to the definition of the Message class, required by the ARM
> -// compiler.
> -template <typename T>
> -String StreamableToString(const T& streamable);
> -
> -// The Symbian compiler has a bug that prevents it from selecting the
> -// correct overload of FormatForComparisonFailureMessage (see below)
> -// unless we pass the first argument by reference.  If we do that,
> -// however, Visual Age C++ 10.1 generates a compiler error.  Therefore
> -// we only apply the work-around for Symbian.
> -#if defined(__SYMBIAN32__)
> -# define GTEST_CREF_WORKAROUND_ const&
> -#else
> -# define GTEST_CREF_WORKAROUND_
> -#endif
> -
> -// When this operand is a const char* or char*, if the other operand
> -// is a ::std::string or ::string, we print this operand as a C string
> -// rather than a pointer (we do the same for wide strings); otherwise
> -// we print it as a pointer to be safe.
> -
> -// This internal macro is used to avoid duplicated code.
> -#define GTEST_FORMAT_IMPL_(operand2_type, operand1_printer)\
> -inline String FormatForComparisonFailureMessage(\
> -    operand2_type::value_type* GTEST_CREF_WORKAROUND_ str, \
> -    const operand2_type& /*operand2*/) {\
> -  return operand1_printer(str);\
> -}\
> -inline String FormatForComparisonFailureMessage(\
> -    const operand2_type::value_type* GTEST_CREF_WORKAROUND_ str, \
> -    const operand2_type& /*operand2*/) {\
> -  return operand1_printer(str);\
> -}
> -
> -GTEST_FORMAT_IMPL_(::std::string, String::ShowCStringQuoted)
> -#if GTEST_HAS_STD_WSTRING
> -GTEST_FORMAT_IMPL_(::std::wstring, String::ShowWideCStringQuoted)
> -#endif  // GTEST_HAS_STD_WSTRING
> -
> -#if GTEST_HAS_GLOBAL_STRING
> -GTEST_FORMAT_IMPL_(::string, String::ShowCStringQuoted)
> -#endif  // GTEST_HAS_GLOBAL_STRING
> -#if GTEST_HAS_GLOBAL_WSTRING
> -GTEST_FORMAT_IMPL_(::wstring, String::ShowWideCStringQuoted)
> -#endif  // GTEST_HAS_GLOBAL_WSTRING
> -
> -#undef GTEST_FORMAT_IMPL_
> -
> -// The next four overloads handle the case where the operand being
> -// printed is a char/wchar_t pointer and the other operand is not a
> -// string/wstring object.  In such cases, we just print the operand as
> -// a pointer to be safe.
> -#define GTEST_FORMAT_CHAR_PTR_IMPL_(CharType)                       \
> -  template <typename T>                                             \
> -  String FormatForComparisonFailureMessage(CharType* GTEST_CREF_WORKAROUND_ p, \
> -                                           const T&) { \
> -    return PrintToString(static_cast<const void*>(p));              \
> -  }
> -
> -GTEST_FORMAT_CHAR_PTR_IMPL_(char)
> -GTEST_FORMAT_CHAR_PTR_IMPL_(const char)
> -GTEST_FORMAT_CHAR_PTR_IMPL_(wchar_t)
> -GTEST_FORMAT_CHAR_PTR_IMPL_(const wchar_t)
> -
> -#undef GTEST_FORMAT_CHAR_PTR_IMPL_
> -
>  // Constructs and returns the message for an equality assertion
>  // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
>  //
> @@ -273,12 +188,12 @@ GTEST_FORMAT_CHAR_PTR_IMPL_(const wchar_t)
>  // be inserted into the message.
>  GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
>                                       const char* actual_expression,
> -                                     const String& expected_value,
> -                                     const String& actual_value,
> +                                     const std::string& expected_value,
> +                                     const std::string& actual_value,
>                                       bool ignoring_case);
>  
>  // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
> -GTEST_API_ String GetBoolAssertionFailureMessage(
> +GTEST_API_ std::string GetBoolAssertionFailureMessage(
>      const AssertionResult& assertion_result,
>      const char* expression_text,
>      const char* actual_predicate_value,
> @@ -353,7 +268,7 @@ class FloatingPoint {
>    // bits.  Therefore, 4 should be enough for ordinary use.
>    //
>    // See the following article for more details on ULP:
> -  // http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm.
> +  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
>    static const size_t kMaxUlps = 4;
>  
>    // Constructs a FloatingPoint from a raw floating-point number.
> @@ -380,6 +295,9 @@ class FloatingPoint {
>      return ReinterpretBits(kExponentBitMask);
>    }
>  
> +  // Returns the maximum representable finite floating-point number.
> +  static RawType Max();
> +
>    // Non-static methods
>  
>    // Returns the bits that represents this number.
> @@ -460,6 +378,13 @@ class FloatingPoint {
>    FloatingPointUnion u_;
>  };
>  
> +// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
> +// macro defined by <windows.h>.
> +template <>
> +inline float FloatingPoint<float>::Max() { return FLT_MAX; }
> +template <>
> +inline double FloatingPoint<double>::Max() { return DBL_MAX; }
> +
>  // Typedefs the instances of the FloatingPoint template class that we
>  // care to use.
>  typedef FloatingPoint<float> Float;
> @@ -554,7 +479,7 @@ typedef void (*TearDownTestCaseFunc)();
>  //   test_case_name:   name of the test case
>  //   name:             name of the test
>  //   type_param        the name of the test's type parameter, or NULL if
> -//                     this is not  a typed or a type-parameterized test.
> +//                     this is not a typed or a type-parameterized test.
>  //   value_param       text representation of the test's value parameter,
>  //                     or NULL if this is not a type-parameterized test.
>  //   fixture_class_id: ID of the test fixture class
> @@ -564,7 +489,8 @@ typedef void (*TearDownTestCaseFunc)();
>  //                     The newly created TestInfo instance will assume
>  //                     ownership of the factory object.
>  GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
> -    const char* test_case_name, const char* name,
> +    const char* test_case_name,
> +    const char* name,
>      const char* type_param,
>      const char* value_param,
>      TypeId fixture_class_id,
> @@ -624,9 +550,9 @@ inline const char* SkipComma(const char* str) {
>  
>  // Returns the prefix of 'str' before the first comma in it; returns
>  // the entire string if it contains no comma.
> -inline String GetPrefixUntilComma(const char* str) {
> +inline std::string GetPrefixUntilComma(const char* str) {
>    const char* comma = strchr(str, ',');
> -  return comma == NULL ? String(str) : String(str, comma - str);
> +  return comma == NULL ? str : std::string(str, comma);
>  }
>  
>  // TypeParameterizedTest<Fixture, TestSel, Types>::Register()
> @@ -652,8 +578,8 @@ class TypeParameterizedTest {
>      // First, registers the first type-parameterized test in the type
>      // list.
>      MakeAndRegisterTestInfo(
> -        String::Format("%s%s%s/%d", prefix, prefix[0] == '\0' ? "" : "/",
> -                       case_name, index).c_str(),
> +        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
> +         + StreamableToString(index)).c_str(),
>          GetPrefixUntilComma(test_names).c_str(),
>          GetTypeName<Type>().c_str(),
>          NULL,  // No value parameter.
> @@ -711,7 +637,7 @@ class TypeParameterizedTestCase<Fixture, Templates0, Types> {
>  
>  #endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
>  
> -// Returns the current OS stack trace as a String.
> +// Returns the current OS stack trace as an std::string.
>  //
>  // The maximum number of stack frames to be included is specified by
>  // the gtest_stack_trace_depth flag.  The skip_count parameter
> @@ -721,8 +647,8 @@ class TypeParameterizedTestCase<Fixture, Templates0, Types> {
>  // For example, if Foo() calls Bar(), which in turn calls
>  // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
>  // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
> -GTEST_API_ String GetCurrentOsStackTraceExceptTop(UnitTest* unit_test,
> -                                                  int skip_count);
> +GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
> +    UnitTest* unit_test, int skip_count);
>  
>  // Helpers for suppressing warnings on unreachable code or constant
>  // condition.
> @@ -797,13 +723,19 @@ struct RemoveConst<const T> { typedef T type; };  // NOLINT
>  // MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
>  // definition to fail to remove the const in 'const int[3]' and 'const
>  // char[3][4]'.  The following specialization works around the bug.
> -// However, it causes trouble with GCC and thus needs to be
> -// conditionally compiled.
> -#if defined(_MSC_VER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
>  template <typename T, size_t N>
>  struct RemoveConst<const T[N]> {
>    typedef typename RemoveConst<T>::type type[N];
>  };
> +
> +#if defined(_MSC_VER) && _MSC_VER < 1400
> +// This is the only specialization that allows VC++ 7.1 to remove const in
> +// 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
> +// and thus needs to be conditionally compiled.
> +template <typename T, size_t N>
> +struct RemoveConst<T[N]> {
> +  typedef typename RemoveConst<T>::type type[N];
> +};
>  #endif
>  
>  // A handy wrapper around RemoveConst that works when the argument
> diff --git a/src/gtest/include/gtest/internal/gtest-linked_ptr.h b/src/gtest/include/gtest/internal/gtest-linked_ptr.h
> index 57147b4..b1362cd 100644
> --- a/src/gtest/include/gtest/internal/gtest-linked_ptr.h
> +++ b/src/gtest/include/gtest/internal/gtest-linked_ptr.h
> @@ -105,8 +105,8 @@ class linked_ptr_internal {
>    // framework.
>  
>    // Join an existing circle.
> -  // L < g_linked_ptr_mutex
> -  void join(linked_ptr_internal const* ptr) {
> +  void join(linked_ptr_internal const* ptr)
> +      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
>      MutexLock lock(&g_linked_ptr_mutex);
>  
>      linked_ptr_internal const* p = ptr;
> @@ -117,8 +117,8 @@ class linked_ptr_internal {
>  
>    // Leave whatever circle we're part of.  Returns true if we were the
>    // last member of the circle.  Once this is done, you can join() another.
> -  // L < g_linked_ptr_mutex
> -  bool depart() {
> +  bool depart()
> +      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
>      MutexLock lock(&g_linked_ptr_mutex);
>  
>      if (next_ == this) return true;
> diff --git a/src/gtest/include/gtest/internal/gtest-param-util-generated.h b/src/gtest/include/gtest/internal/gtest-param-util-generated.h
> index 2582675..e805485 100644
> --- a/src/gtest/include/gtest/internal/gtest-param-util-generated.h
> +++ b/src/gtest/include/gtest/internal/gtest-param-util-generated.h
> @@ -95,7 +95,7 @@ class ValueArray2 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
>      return ValuesIn(array);
>    }
>  
> @@ -114,7 +114,8 @@ class ValueArray3 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_)};
>      return ValuesIn(array);
>    }
>  
> @@ -135,7 +136,8 @@ class ValueArray4 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_)};
>      return ValuesIn(array);
>    }
>  
> @@ -157,7 +159,8 @@ class ValueArray5 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
>      return ValuesIn(array);
>    }
>  
> @@ -181,7 +184,9 @@ class ValueArray6 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_)};
>      return ValuesIn(array);
>    }
>  
> @@ -206,7 +211,9 @@ class ValueArray7 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_)};
>      return ValuesIn(array);
>    }
>  
> @@ -233,7 +240,9 @@ class ValueArray8 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
>      return ValuesIn(array);
>    }
>  
> @@ -261,7 +270,10 @@ class ValueArray9 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_)};
>      return ValuesIn(array);
>    }
>  
> @@ -290,7 +302,10 @@ class ValueArray10 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_)};
>      return ValuesIn(array);
>    }
>  
> @@ -321,7 +336,10 @@ class ValueArray11 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
>      return ValuesIn(array);
>    }
>  
> @@ -353,8 +371,11 @@ class ValueArray12 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_)};
>      return ValuesIn(array);
>    }
>  
> @@ -388,8 +409,11 @@ class ValueArray13 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_)};
>      return ValuesIn(array);
>    }
>  
> @@ -424,8 +448,11 @@ class ValueArray14 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
>      return ValuesIn(array);
>    }
>  
> @@ -461,8 +488,12 @@ class ValueArray15 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_)};
>      return ValuesIn(array);
>    }
>  
> @@ -501,8 +532,12 @@ class ValueArray16 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_)};
>      return ValuesIn(array);
>    }
>  
> @@ -542,8 +577,12 @@ class ValueArray17 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
>      return ValuesIn(array);
>    }
>  
> @@ -584,8 +623,13 @@ class ValueArray18 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_)};
>      return ValuesIn(array);
>    }
>  
> @@ -627,8 +671,13 @@ class ValueArray19 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_)};
>      return ValuesIn(array);
>    }
>  
> @@ -672,8 +721,13 @@ class ValueArray20 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
>      return ValuesIn(array);
>    }
>  
> @@ -719,8 +773,14 @@ class ValueArray21 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_)};
>      return ValuesIn(array);
>    }
>  
> @@ -767,8 +827,14 @@ class ValueArray22 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_)};
>      return ValuesIn(array);
>    }
>  
> @@ -817,9 +883,14 @@ class ValueArray23 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_,
> -        v23_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
>      return ValuesIn(array);
>    }
>  
> @@ -869,9 +940,15 @@ class ValueArray24 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_)};
>      return ValuesIn(array);
>    }
>  
> @@ -922,9 +999,15 @@ class ValueArray25 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_)};
>      return ValuesIn(array);
>    }
>  
> @@ -977,9 +1060,15 @@ class ValueArray26 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1034,9 +1123,16 @@ class ValueArray27 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1092,9 +1188,16 @@ class ValueArray28 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1151,9 +1254,16 @@ class ValueArray29 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1212,9 +1322,17 @@ class ValueArray30 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1275,9 +1393,17 @@ class ValueArray31 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1339,9 +1465,17 @@ class ValueArray32 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1405,9 +1539,18 @@ class ValueArray33 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1472,9 +1615,18 @@ class ValueArray34 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1540,10 +1692,18 @@ class ValueArray35 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_,
> -        v35_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1611,10 +1771,19 @@ class ValueArray36 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1684,10 +1853,19 @@ class ValueArray37 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1758,10 +1936,19 @@ class ValueArray38 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1833,10 +2020,20 @@ class ValueArray39 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1910,10 +2107,20 @@ class ValueArray40 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_)};
>      return ValuesIn(array);
>    }
>  
> @@ -1989,10 +2196,20 @@ class ValueArray41 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2069,10 +2286,21 @@ class ValueArray42 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2150,10 +2378,21 @@ class ValueArray43 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_), static_cast<T>(v43_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2233,10 +2472,21 @@ class ValueArray44 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2317,10 +2567,22 @@ class ValueArray45 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> +        static_cast<T>(v45_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2403,10 +2665,22 @@ class ValueArray46 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> +        static_cast<T>(v45_), static_cast<T>(v46_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2491,11 +2765,22 @@ class ValueArray47 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_,
> -        v47_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> +        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2581,11 +2866,23 @@ class ValueArray48 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_,
> -        v48_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> +        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
> +        static_cast<T>(v48_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2672,11 +2969,23 @@ class ValueArray49 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_,
> -        v48_, v49_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> +        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
> +        static_cast<T>(v48_), static_cast<T>(v49_)};
>      return ValuesIn(array);
>    }
>  
> @@ -2764,11 +3073,23 @@ class ValueArray50 {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_,
> -        v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_,
> -        v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_,
> -        v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_,
> -        v48_, v49_, v50_};
> +    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> +        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> +        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> +        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> +        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> +        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> +        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> +        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> +        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> +        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> +        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> +        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> +        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> +        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> +        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> +        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
> +        static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
>      return ValuesIn(array);
>    }
>  
> diff --git a/src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump b/src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump
> index dbe9386..009206f 100644
> --- a/src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump
> +++ b/src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump
> @@ -98,7 +98,7 @@ class ValueArray$i {
>  
>    template <typename T>
>    operator ParamGenerator<T>() const {
> -    const T array[] = {$for j, [[v$(j)_]]};
> +    const T array[] = {$for j, [[static_cast<T>(v$(j)_)]]};
>      return ValuesIn(array);
>    }
>  
> diff --git a/src/gtest/include/gtest/internal/gtest-param-util.h b/src/gtest/include/gtest/internal/gtest-param-util.h
> index 0ef9718..d5e1028 100644
> --- a/src/gtest/include/gtest/internal/gtest-param-util.h
> +++ b/src/gtest/include/gtest/internal/gtest-param-util.h
> @@ -494,10 +494,10 @@ class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
>          const string& instantiation_name = gen_it->first;
>          ParamGenerator<ParamType> generator((*gen_it->second)());
>  
> -        Message test_case_name_stream;
> +        string test_case_name;
>          if ( !instantiation_name.empty() )
> -          test_case_name_stream << instantiation_name << "/";
> -        test_case_name_stream << test_info->test_case_base_name;
> +          test_case_name = instantiation_name + "/";
> +        test_case_name += test_info->test_case_base_name;
>  
>          int i = 0;
>          for (typename ParamGenerator<ParamType>::iterator param_it =
> @@ -506,7 +506,7 @@ class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
>            Message test_name_stream;
>            test_name_stream << test_info->test_base_name << "/" << i;
>            MakeAndRegisterTestInfo(
> -              test_case_name_stream.GetString().c_str(),
> +              test_case_name.c_str(),
>                test_name_stream.GetString().c_str(),
>                NULL,  // No type parameter.
>                PrintToString(*param_it).c_str(),
> diff --git a/src/gtest/include/gtest/internal/gtest-port.h b/src/gtest/include/gtest/internal/gtest-port.h
> index 157b47f..dc4fe0c 100644
> --- a/src/gtest/include/gtest/internal/gtest-port.h
> +++ b/src/gtest/include/gtest/internal/gtest-port.h
> @@ -32,6 +32,10 @@
>  // Low-level types and utilities for porting Google Test to various
>  // platforms.  They are subject to change without notice.  DO NOT USE
>  // THEM IN USER CODE.
> +//
> +// This file is fundamental to Google Test.  All other Google Test source
> +// files are expected to #include this.  Therefore, it cannot #include
> +// any other Google Test header.
>  
>  #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
>  #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
> @@ -72,6 +76,8 @@
>  //                              Test's own tr1 tuple implementation should be
>  //                              used.  Unused when the user sets
>  //                              GTEST_HAS_TR1_TUPLE to 0.
> +//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
> +//                              is building in C++11/C++98 mode.
>  //   GTEST_LINKED_AS_SHARED_LIBRARY
>  //                            - Define to 1 when compiling tests that use
>  //                              Google Test as a shared library (known as
> @@ -90,7 +96,11 @@
>  //   GTEST_OS_LINUX    - Linux
>  //     GTEST_OS_LINUX_ANDROID - Google Android
>  //   GTEST_OS_MAC      - Mac OS X
> +//     GTEST_OS_IOS    - iOS
> +//       GTEST_OS_IOS_SIMULATOR - iOS simulator
>  //   GTEST_OS_NACL     - Google Native Client (NaCl)
> +//   GTEST_OS_OPENBSD  - OpenBSD
> +//   GTEST_OS_QNX      - QNX
>  //   GTEST_OS_SOLARIS  - Sun Solaris
>  //   GTEST_OS_SYMBIAN  - Symbian
>  //   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
> @@ -175,7 +185,7 @@
>  //   GTEST_FLAG()       - references a flag.
>  //   GTEST_DECLARE_*()  - declares a flag.
>  //   GTEST_DEFINE_*()   - defines a flag.
> -//   GetArgvs()         - returns the command line as a vector of strings.
> +//   GetInjectableArgvs() - returns the command line as a vector of strings.
>  //
>  // Environment variable utilities:
>  //   GetEnv()             - gets the value of an environment variable.
> @@ -193,6 +203,11 @@
>  # include <sys/stat.h>
>  #endif  // !_WIN32_WCE
>  
> +#if defined __APPLE__
> +# include <AvailabilityMacros.h>
> +# include <TargetConditionals.h>
> +#endif
> +
>  #include <iostream>  // NOLINT
>  #include <sstream>  // NOLINT
>  #include <string>  // NOLINT
> @@ -227,11 +242,17 @@
>  # endif  // _WIN32_WCE
>  #elif defined __APPLE__
>  # define GTEST_OS_MAC 1
> +# if TARGET_OS_IPHONE
> +#  define GTEST_OS_IOS 1
> +#  if TARGET_IPHONE_SIMULATOR
> +#   define GTEST_OS_IOS_SIMULATOR 1
> +#  endif
> +# endif
>  #elif defined __linux__
>  # define GTEST_OS_LINUX 1
> -# ifdef ANDROID
> +# if defined __ANDROID__
>  #  define GTEST_OS_LINUX_ANDROID 1
> -# endif  // ANDROID
> +# endif
>  #elif defined __MVS__
>  # define GTEST_OS_ZOS 1
>  #elif defined(__sun) && defined(__SVR4)
> @@ -242,8 +263,25 @@
>  # define GTEST_OS_HPUX 1
>  #elif defined __native_client__
>  # define GTEST_OS_NACL 1
> +#elif defined __OpenBSD__
> +# define GTEST_OS_OPENBSD 1
> +#elif defined __QNX__
> +# define GTEST_OS_QNX 1
>  #endif  // __CYGWIN__
>  
> +#ifndef GTEST_LANG_CXX11
> +// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
> +// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
> +// value for __cplusplus, and recent versions of clang, gcc, and
> +// probably other compilers set that too in C++11 mode.
> +# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
> +// Compiling in at least C++11 mode.
> +#  define GTEST_LANG_CXX11 1
> +# else
> +#  define GTEST_LANG_CXX11 0
> +# endif
> +#endif
> +
>  // Brings in definitions for functions used in the testing::internal::posix
>  // namespace (read, write, close, chdir, isatty, stat). We do not currently
>  // use them on Windows Mobile.
> @@ -252,20 +290,25 @@
>  // is not the case, we need to include headers that provide the functions
>  // mentioned above.
>  # include <unistd.h>
> -# if !GTEST_OS_NACL
> -// TODO(vladl@google.com): Remove this condition when Native Client SDK adds
> -// strings.h (tracked in
> -// http://code.google.com/p/nativeclient/issues/detail?id=1175).
> -#  include <strings.h>  // Native Client doesn't provide strings.h.
> -# endif
> +# include <strings.h>
>  #elif !GTEST_OS_WINDOWS_MOBILE
>  # include <direct.h>
>  # include <io.h>
>  #endif
>  
> +#if GTEST_OS_LINUX_ANDROID
> +// Used to define __ANDROID_API__ matching the target NDK API level.
> +#  include <android/api-level.h>  // NOLINT
> +#endif
> +
>  // Defines this to true iff Google Test can use POSIX regular expressions.
>  #ifndef GTEST_HAS_POSIX_RE
> -# define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
> +# if GTEST_OS_LINUX_ANDROID
> +// On Android, <regex.h> is only available starting with Gingerbread.
> +#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
> +# else
> +#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
> +# endif
>  #endif
>  
>  #if GTEST_HAS_POSIX_RE
> @@ -380,11 +423,27 @@
>  # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
>  
>  #  ifdef __GXX_RTTI
> -#   define GTEST_HAS_RTTI 1
> +// When building against STLport with the Android NDK and with
> +// -frtti -fno-exceptions, the build fails at link time with undefined
> +// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
> +// so disable RTTI when detected.
> +#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
> +       !defined(__EXCEPTIONS)
> +#    define GTEST_HAS_RTTI 0
> +#   else
> +#    define GTEST_HAS_RTTI 1
> +#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
>  #  else
>  #   define GTEST_HAS_RTTI 0
>  #  endif  // __GXX_RTTI
>  
> +// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
> +// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
> +// first version with C++ support.
> +# elif defined(__clang__)
> +
> +#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
> +
>  // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
>  // both the typeid and dynamic_cast features are present.
>  # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
> @@ -417,7 +476,8 @@
>  //
>  // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
>  // to your compiler flags.
> -# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX)
> +# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
> +    || GTEST_OS_QNX)
>  #endif  // GTEST_HAS_PTHREAD
>  
>  #if GTEST_HAS_PTHREAD
> @@ -433,8 +493,13 @@
>  // this macro to 0 to prevent Google Test from using tuple (any
>  // feature depending on tuple with be disabled in this mode).
>  #ifndef GTEST_HAS_TR1_TUPLE
> +# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
> +// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
> +#  define GTEST_HAS_TR1_TUPLE 0
> +# else
>  // The user didn't tell us not to do it, so we assume it's OK.
> -# define GTEST_HAS_TR1_TUPLE 1
> +#  define GTEST_HAS_TR1_TUPLE 1
> +# endif
>  #endif  // GTEST_HAS_TR1_TUPLE
>  
>  // Determines whether Google Test's own tr1 tuple implementation
> @@ -443,14 +508,28 @@
>  // The user didn't tell us, so we need to figure it out.
>  
>  // We use our own TR1 tuple if we aren't sure the user has an
> -// implementation of it already.  At this time, GCC 4.0.0+ and MSVC
> -// 2010 are the only mainstream compilers that come with a TR1 tuple
> -// implementation.  NVIDIA's CUDA NVCC compiler pretends to be GCC by
> -// defining __GNUC__ and friends, but cannot compile GCC's tuple
> -// implementation.  MSVC 2008 (9.0) provides TR1 tuple in a 323 MB
> -// Feature Pack download, which we cannot assume the user has.
> -# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \
> -    || _MSC_VER >= 1600
> +// implementation of it already.  At this time, libstdc++ 4.0.0+ and
> +// MSVC 2010 are the only mainstream standard libraries that come
> +// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
> +// pretends to be GCC by defining __GNUC__ and friends, but cannot
> +// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
> +// tuple in a 323 MB Feature Pack download, which we cannot assume the
> +// user has.  QNX's QCC compiler is a modified GCC but it doesn't
> +// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
> +// and it can be used with some compilers that define __GNUC__.
> +# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
> +      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
> +#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
> +# endif
> +
> +// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
> +// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
> +// can build with clang but need to use gcc4.2's libstdc++).
> +# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
> +#  define GTEST_ENV_HAS_STD_TUPLE_ 1
> +# endif
> +
> +# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
>  #  define GTEST_USE_OWN_TR1_TUPLE 0
>  # else
>  #  define GTEST_USE_OWN_TR1_TUPLE 1
> @@ -465,6 +544,22 @@
>  
>  # if GTEST_USE_OWN_TR1_TUPLE
>  #  include "gtest/internal/gtest-tuple.h"
> +# elif GTEST_ENV_HAS_STD_TUPLE_
> +#  include <tuple>
> +// C++11 puts its tuple into the ::std namespace rather than
> +// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
> +// This causes undefined behavior, but supported compilers react in
> +// the way we intend.
> +namespace std {
> +namespace tr1 {
> +using ::std::get;
> +using ::std::make_tuple;
> +using ::std::tuple;
> +using ::std::tuple_element;
> +using ::std::tuple_size;
> +}
> +}
> +
>  # elif GTEST_OS_SYMBIAN
>  
>  // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
> @@ -515,7 +610,16 @@
>  // The user didn't tell us, so we need to figure it out.
>  
>  # if GTEST_OS_LINUX && !defined(__ia64__)
> -#  define GTEST_HAS_CLONE 1
> +#  if GTEST_OS_LINUX_ANDROID
> +// On Android, clone() is only available on ARM starting with Gingerbread.
> +#    if defined(__arm__) && __ANDROID_API__ >= 9
> +#     define GTEST_HAS_CLONE 1
> +#    else
> +#     define GTEST_HAS_CLONE 0
> +#    endif
> +#  else
> +#   define GTEST_HAS_CLONE 1
> +#  endif
>  # else
>  #  define GTEST_HAS_CLONE 0
>  # endif  // GTEST_OS_LINUX && !defined(__ia64__)
> @@ -538,9 +642,11 @@
>  // Google Test does not support death tests for VC 7.1 and earlier as
>  // abort() in a VC 7.1 application compiled as GUI in debug config
>  // pops up a dialog window that cannot be suppressed programmatically.
> -#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
> +#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
> +     (GTEST_OS_MAC && !GTEST_OS_IOS) || GTEST_OS_IOS_SIMULATOR || \
>       (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
> -     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX)
> +     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
> +     GTEST_OS_OPENBSD || GTEST_OS_QNX)
>  # define GTEST_HAS_DEATH_TEST 1
>  # include <vector>  // NOLINT
>  #endif
> @@ -669,13 +775,23 @@
>  # define GTEST_NO_INLINE_
>  #endif
>  
> +// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
> +#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
> +# define GTEST_HAS_CXXABI_H_ 1
> +#else
> +# define GTEST_HAS_CXXABI_H_ 0
> +#endif
> +
>  namespace testing {
>  
>  class Message;
>  
>  namespace internal {
>  
> -class String;
> +// A secret type that Google Test users don't know about.  It has no
> +// definition on purpose.  Therefore it's impossible to create a
> +// Secret object, which is what we want.
> +class Secret;
>  
>  // The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
>  // expression is true. For example, you could use it to verify the
> @@ -697,8 +813,8 @@ struct CompileAssert {
>  };
>  
>  #define GTEST_COMPILE_ASSERT_(expr, msg) \
> -  typedef ::testing::internal::CompileAssert<(bool(expr))> \
> -      msg[bool(expr) ? 1 : -1]
> +  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
> +      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
>  
>  // Implementation details of GTEST_COMPILE_ASSERT_:
>  //
> @@ -796,6 +912,7 @@ class scoped_ptr {
>        ptr_ = p;
>      }
>    }
> +
>   private:
>    T* ptr_;
>  
> @@ -858,10 +975,9 @@ class GTEST_API_ RE {
>   private:
>    void Init(const char* regex);
>  
> -  // We use a const char* instead of a string, as Google Test may be used
> -  // where string is not available.  We also do not use Google Test's own
> -  // String type here, in order to simplify dependencies between the
> -  // files.
> +  // We use a const char* instead of an std::string, as Google Test used to be
> +  // used where std::string is not available.  TODO(wan@google.com): change to
> +  // std::string.
>    const char* pattern_;
>    bool is_valid_;
>  
> @@ -1044,20 +1160,21 @@ Derived* CheckedDowncastToActualType(Base* base) {
>  //   GetCapturedStderr - stops capturing stderr and returns the captured string.
>  //
>  GTEST_API_ void CaptureStdout();
> -GTEST_API_ String GetCapturedStdout();
> +GTEST_API_ std::string GetCapturedStdout();
>  GTEST_API_ void CaptureStderr();
> -GTEST_API_ String GetCapturedStderr();
> +GTEST_API_ std::string GetCapturedStderr();
>  
>  #endif  // GTEST_HAS_STREAM_REDIRECTION
>  
>  
>  #if GTEST_HAS_DEATH_TEST
>  
> -// A copy of all command line arguments.  Set by InitGoogleTest().
> -extern ::std::vector<String> g_argvs;
> +const ::std::vector<testing::internal::string>& GetInjectableArgvs();
> +void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
> +                             new_argvs);
>  
> -// GTEST_HAS_DEATH_TEST implies we have ::std::string.
> -const ::std::vector<String>& GetArgvs();
> +// A copy of all command line arguments.  Set by InitGoogleTest().
> +extern ::std::vector<testing::internal::string> g_argvs;
>  
>  #endif  // GTEST_HAS_DEATH_TEST
>  
> @@ -1084,22 +1201,37 @@ inline void SleepMilliseconds(int n) {
>  // use it in user tests, either directly or indirectly.
>  class Notification {
>   public:
> -  Notification() : notified_(false) {}
> +  Notification() : notified_(false) {
> +    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
> +  }
> +  ~Notification() {
> +    pthread_mutex_destroy(&mutex_);
> +  }
>  
>    // Notifies all threads created with this notification to start. Must
>    // be called from the controller thread.
> -  void Notify() { notified_ = true; }
> +  void Notify() {
> +    pthread_mutex_lock(&mutex_);
> +    notified_ = true;
> +    pthread_mutex_unlock(&mutex_);
> +  }
>  
>    // Blocks until the controller thread notifies. Must be called from a test
>    // thread.
>    void WaitForNotification() {
> -    while(!notified_) {
> +    for (;;) {
> +      pthread_mutex_lock(&mutex_);
> +      const bool notified = notified_;
> +      pthread_mutex_unlock(&mutex_);
> +      if (notified)
> +        break;
>        SleepMilliseconds(10);
>      }
>    }
>  
>   private:
> -  volatile bool notified_;
> +  pthread_mutex_t mutex_;
> +  bool notified_;
>  
>    GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
>  };
> @@ -1207,21 +1339,23 @@ class MutexBase {
>    void Lock() {
>      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
>      owner_ = pthread_self();
> +    has_owner_ = true;
>    }
>  
>    // Releases this mutex.
>    void Unlock() {
> -    // We don't protect writing to owner_ here, as it's the caller's
> -    // responsibility to ensure that the current thread holds the
> +    // Since the lock is being released the owner_ field should no longer be
> +    // considered valid. We don't protect writing to has_owner_ here, as it's
> +    // the caller's responsibility to ensure that the current thread holds the
>      // mutex when this is called.
> -    owner_ = 0;
> +    has_owner_ = false;
>      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
>    }
>  
>    // Does nothing if the current thread holds the mutex. Otherwise, crashes
>    // with high probability.
>    void AssertHeld() const {
> -    GTEST_CHECK_(owner_ == pthread_self())
> +    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
>          << "The current thread is not holding the mutex @" << this;
>    }
>  
> @@ -1232,7 +1366,14 @@ class MutexBase {
>    // have to be public.
>   public:
>    pthread_mutex_t mutex_;  // The underlying pthread mutex.
> -  pthread_t owner_;  // The thread holding the mutex; 0 means no one holds it.
> +  // has_owner_ indicates whether the owner_ field below contains a valid thread
> +  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
> +  // accesses to the owner_ field should be protected by a check of this field.
> +  // An alternative might be to memset() owner_ to all zeros, but there's no
> +  // guarantee that a zero'd pthread_t is necessarily invalid or even different
> +  // from pthread_self().
> +  bool has_owner_;
> +  pthread_t owner_;  // The thread holding the mutex.
>  };
>  
>  // Forward-declares a static mutex.
> @@ -1240,8 +1381,13 @@ class MutexBase {
>      extern ::testing::internal::MutexBase mutex
>  
>  // Defines and statically (i.e. at link time) initializes a static mutex.
> +// The initialization list here does not explicitly initialize each field,
> +// instead relying on default initialization for the unspecified fields. In
> +// particular, the owner_ field (a pthread_t) is not explicitly initialized.
> +// This allows initialization to work whether pthread_t is a scalar or struct.
> +// The flag -Wmissing-field-initializers must not be specified for this to work.
>  # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
> -    ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 }
> +    ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false }
>  
>  // The Mutex class can only be used for mutexes created at runtime. It
>  // shares its API with MutexBase otherwise.
> @@ -1249,7 +1395,7 @@ class Mutex : public MutexBase {
>   public:
>    Mutex() {
>      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
> -    owner_ = 0;
> +    has_owner_ = false;
>    }
>    ~Mutex() {
>      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
> @@ -1399,6 +1545,8 @@ class ThreadLocal {
>  class Mutex {
>   public:
>    Mutex() {}
> +  void Lock() {}
> +  void Unlock() {}
>    void AssertHeld() const {}
>  };
>  
> @@ -1529,6 +1677,10 @@ inline bool IsUpper(char ch) {
>  inline bool IsXDigit(char ch) {
>    return isxdigit(static_cast<unsigned char>(ch)) != 0;
>  }
> +inline bool IsXDigit(wchar_t ch) {
> +  const unsigned char low_byte = static_cast<unsigned char>(ch);
> +  return ch == low_byte && isxdigit(low_byte) != 0;
> +}
>  
>  inline char ToLower(char ch) {
>    return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
> @@ -1666,6 +1818,23 @@ inline void Abort() { abort(); }
>  
>  }  // namespace posix
>  
> +// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
> +// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
> +// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
> +// function in order to achieve that.  We use macro definition here because
> +// snprintf is a variadic function.
> +#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
> +// MSVC 2005 and above support variadic macros.
> +# define GTEST_SNPRINTF_(buffer, size, format, ...) \
> +     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
> +#elif defined(_MSC_VER)
> +// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
> +// complain about _snprintf.
> +# define GTEST_SNPRINTF_ _snprintf
> +#else
> +# define GTEST_SNPRINTF_ snprintf
> +#endif
> +
>  // The maximum number a BiggestInt can represent.  This definition
>  // works no matter BiggestInt is represented in one's complement or
>  // two's complement.
> @@ -1718,7 +1887,6 @@ class TypeWithSize<4> {
>  template <>
>  class TypeWithSize<8> {
>   public:
> -
>  #if GTEST_OS_WINDOWS
>    typedef __int64 Int;
>    typedef unsigned __int64 UInt;
> @@ -1745,7 +1913,7 @@ typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
>  #define GTEST_DECLARE_int32_(name) \
>      GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
>  #define GTEST_DECLARE_string_(name) \
> -    GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name)
> +    GTEST_API_ extern ::std::string GTEST_FLAG(name)
>  
>  // Macros for defining flags.
>  #define GTEST_DEFINE_bool_(name, default_val, doc) \
> @@ -1753,7 +1921,11 @@ typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
>  #define GTEST_DEFINE_int32_(name, default_val, doc) \
>      GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
>  #define GTEST_DEFINE_string_(name, default_val, doc) \
> -    GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val)
> +    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
> +
> +// Thread annotations
> +#define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
> +#define GTEST_LOCK_EXCLUDED_(locks)
>  
>  // Parses 'str' for a 32-bit signed integer.  If successful, writes the result
>  // to *value and returns true; otherwise leaves *value unchanged and returns
> diff --git a/src/gtest/include/gtest/internal/gtest-string.h b/src/gtest/include/gtest/internal/gtest-string.h
> index dc3a07b..97f1a7f 100644
> --- a/src/gtest/include/gtest/internal/gtest-string.h
> +++ b/src/gtest/include/gtest/internal/gtest-string.h
> @@ -47,50 +47,18 @@
>  #endif
>  
>  #include <string.h>
> -#include "gtest/internal/gtest-port.h"
> -
>  #include <string>
>  
> +#include "gtest/internal/gtest-port.h"
> +
>  namespace testing {
>  namespace internal {
>  
> -// String - a UTF-8 string class.
> -//
> -// For historic reasons, we don't use std::string.
> -//
> -// TODO(wan@google.com): replace this class with std::string or
> -// implement it in terms of the latter.
> -//
> -// Note that String can represent both NULL and the empty string,
> -// while std::string cannot represent NULL.
> -//
> -// NULL and the empty string are considered different.  NULL is less
> -// than anything (including the empty string) except itself.
> -//
> -// This class only provides minimum functionality necessary for
> -// implementing Google Test.  We do not intend to implement a full-fledged
> -// string class here.
> -//
> -// Since the purpose of this class is to provide a substitute for
> -// std::string on platforms where it cannot be used, we define a copy
> -// constructor and assignment operators such that we don't need
> -// conditional compilation in a lot of places.
> -//
> -// In order to make the representation efficient, the d'tor of String
> -// is not virtual.  Therefore DO NOT INHERIT FROM String.
> +// String - an abstract class holding static string utilities.
>  class GTEST_API_ String {
>   public:
>    // Static utility methods
>  
> -  // Returns the input enclosed in double quotes if it's not NULL;
> -  // otherwise returns "(null)".  For example, "\"Hello\"" is returned
> -  // for input "Hello".
> -  //
> -  // This is useful for printing a C string in the syntax of a literal.
> -  //
> -  // Known issue: escape sequences are not handled yet.
> -  static String ShowCStringQuoted(const char* c_str);
> -
>    // Clones a 0-terminated C string, allocating memory using new.  The
>    // caller is responsible for deleting the return value using
>    // delete[].  Returns the cloned string, or NULL if the input is
> @@ -137,11 +105,7 @@ class GTEST_API_ String {
>    // NULL will be converted to "(null)".  If an error occurred during
>    // the conversion, "(failed to convert from wide string)" is
>    // returned.
> -  static String ShowWideCString(const wchar_t* wide_c_str);
> -
> -  // Similar to ShowWideCString(), except that this function encloses
> -  // the converted string in double quotes.
> -  static String ShowWideCStringQuoted(const wchar_t* wide_c_str);
> +  static std::string ShowWideCString(const wchar_t* wide_c_str);
>  
>    // Compares two wide C strings.  Returns true iff they have the same
>    // content.
> @@ -175,174 +139,27 @@ class GTEST_API_ String {
>    static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
>                                                 const wchar_t* rhs);
>  
> -  // Formats a list of arguments to a String, using the same format
> -  // spec string as for printf.
> -  //
> -  // We do not use the StringPrintf class as it is not universally
> -  // available.
> -  //
> -  // The result is limited to 4096 characters (including the tailing
> -  // 0).  If 4096 characters are not enough to format the input,
> -  // "<buffer exceeded>" is returned.
> -  static String Format(const char* format, ...);
> -
> -  // C'tors
> -
> -  // The default c'tor constructs a NULL string.
> -  String() : c_str_(NULL), length_(0) {}
> -
> -  // Constructs a String by cloning a 0-terminated C string.
> -  String(const char* a_c_str) {  // NOLINT
> -    if (a_c_str == NULL) {
> -      c_str_ = NULL;
> -      length_ = 0;
> -    } else {
> -      ConstructNonNull(a_c_str, strlen(a_c_str));
> -    }
> -  }
> +  // Returns true iff the given string ends with the given suffix, ignoring
> +  // case. Any string is considered to end with an empty suffix.
> +  static bool EndsWithCaseInsensitive(
> +      const std::string& str, const std::string& suffix);
>  
> -  // Constructs a String by copying a given number of chars from a
> -  // buffer.  E.g. String("hello", 3) creates the string "hel",
> -  // String("a\0bcd", 4) creates "a\0bc", String(NULL, 0) creates "",
> -  // and String(NULL, 1) results in access violation.
> -  String(const char* buffer, size_t a_length) {
> -    ConstructNonNull(buffer, a_length);
> -  }
> +  // Formats an int value as "%02d".
> +  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
>  
> -  // The copy c'tor creates a new copy of the string.  The two
> -  // String objects do not share content.
> -  String(const String& str) : c_str_(NULL), length_(0) { *this = str; }
> +  // Formats an int value as "%X".
> +  static std::string FormatHexInt(int value);
>  
> -  // D'tor.  String is intended to be a final class, so the d'tor
> -  // doesn't need to be virtual.
> -  ~String() { delete[] c_str_; }
> -
> -  // Allows a String to be implicitly converted to an ::std::string or
> -  // ::string, and vice versa.  Converting a String containing a NULL
> -  // pointer to ::std::string or ::string is undefined behavior.
> -  // Converting a ::std::string or ::string containing an embedded NUL
> -  // character to a String will result in the prefix up to the first
> -  // NUL character.
> -  String(const ::std::string& str) {
> -    ConstructNonNull(str.c_str(), str.length());
> -  }
> -
> -  operator ::std::string() const { return ::std::string(c_str(), length()); }
> -
> -#if GTEST_HAS_GLOBAL_STRING
> -  String(const ::string& str) {
> -    ConstructNonNull(str.c_str(), str.length());
> -  }
> -
> -  operator ::string() const { return ::string(c_str(), length()); }
> -#endif  // GTEST_HAS_GLOBAL_STRING
> -
> -  // Returns true iff this is an empty string (i.e. "").
> -  bool empty() const { return (c_str() != NULL) && (length() == 0); }
> -
> -  // Compares this with another String.
> -  // Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
> -  // if this is greater than rhs.
> -  int Compare(const String& rhs) const;
> -
> -  // Returns true iff this String equals the given C string.  A NULL
> -  // string and a non-NULL string are considered not equal.
> -  bool operator==(const char* a_c_str) const { return Compare(a_c_str) == 0; }
> -
> -  // Returns true iff this String is less than the given String.  A
> -  // NULL string is considered less than "".
> -  bool operator<(const String& rhs) const { return Compare(rhs) < 0; }
> -
> -  // Returns true iff this String doesn't equal the given C string.  A NULL
> -  // string and a non-NULL string are considered not equal.
> -  bool operator!=(const char* a_c_str) const { return !(*this == a_c_str); }
> -
> -  // Returns true iff this String ends with the given suffix.  *Any*
> -  // String is considered to end with a NULL or empty suffix.
> -  bool EndsWith(const char* suffix) const;
> -
> -  // Returns true iff this String ends with the given suffix, not considering
> -  // case. Any String is considered to end with a NULL or empty suffix.
> -  bool EndsWithCaseInsensitive(const char* suffix) const;
> -
> -  // Returns the length of the encapsulated string, or 0 if the
> -  // string is NULL.
> -  size_t length() const { return length_; }
> -
> -  // Gets the 0-terminated C string this String object represents.
> -  // The String object still owns the string.  Therefore the caller
> -  // should NOT delete the return value.
> -  const char* c_str() const { return c_str_; }
> -
> -  // Assigns a C string to this object.  Self-assignment works.
> -  const String& operator=(const char* a_c_str) {
> -    return *this = String(a_c_str);
> -  }
> -
> -  // Assigns a String object to this object.  Self-assignment works.
> -  const String& operator=(const String& rhs) {
> -    if (this != &rhs) {
> -      delete[] c_str_;
> -      if (rhs.c_str() == NULL) {
> -        c_str_ = NULL;
> -        length_ = 0;
> -      } else {
> -        ConstructNonNull(rhs.c_str(), rhs.length());
> -      }
> -    }
> -
> -    return *this;
> -  }
> +  // Formats a byte as "%02X".
> +  static std::string FormatByte(unsigned char value);
>  
>   private:
> -  // Constructs a non-NULL String from the given content.  This
> -  // function can only be called when c_str_ has not been allocated.
> -  // ConstructNonNull(NULL, 0) results in an empty string ("").
> -  // ConstructNonNull(NULL, non_zero) is undefined behavior.
> -  void ConstructNonNull(const char* buffer, size_t a_length) {
> -    char* const str = new char[a_length + 1];
> -    memcpy(str, buffer, a_length);
> -    str[a_length] = '\0';
> -    c_str_ = str;
> -    length_ = a_length;
> -  }
> -
> -  const char* c_str_;
> -  size_t length_;
> +  String();  // Not meant to be instantiated.
>  };  // class String
>  
> -// Streams a String to an ostream.  Each '\0' character in the String
> -// is replaced with "\\0".
> -inline ::std::ostream& operator<<(::std::ostream& os, const String& str) {
> -  if (str.c_str() == NULL) {
> -    os << "(null)";
> -  } else {
> -    const char* const c_str = str.c_str();
> -    for (size_t i = 0; i != str.length(); i++) {
> -      if (c_str[i] == '\0') {
> -        os << "\\0";
> -      } else {
> -        os << c_str[i];
> -      }
> -    }
> -  }
> -  return os;
> -}
> -
> -// Gets the content of the stringstream's buffer as a String.  Each '\0'
> +// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
>  // character in the buffer is replaced with "\\0".
> -GTEST_API_ String StringStreamToString(::std::stringstream* stream);
> -
> -// Converts a streamable value to a String.  A NULL pointer is
> -// converted to "(null)".  When the input value is a ::string,
> -// ::std::string, ::wstring, or ::std::wstring object, each NUL
> -// character in it is replaced with "\\0".
> -
> -// Declared here but defined in gtest.h, so that it has access
> -// to the definition of the Message class, required by the ARM
> -// compiler.
> -template <typename T>
> -String StreamableToString(const T& streamable);
> +GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
>  
>  }  // namespace internal
>  }  // namespace testing
> diff --git a/src/gtest/include/gtest/internal/gtest-tuple.h b/src/gtest/include/gtest/internal/gtest-tuple.h
> index d1af50e..7b3dfc3 100644
> --- a/src/gtest/include/gtest/internal/gtest-tuple.h
> +++ b/src/gtest/include/gtest/internal/gtest-tuple.h
> @@ -1,4 +1,6 @@
> -// This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
> +// This file was GENERATED by command:
> +//     pump.py gtest-tuple.h.pump
> +// DO NOT EDIT BY HAND!!!
>  
>  // Copyright 2009 Google Inc.
>  // All Rights Reserved.
> @@ -140,34 +142,54 @@ template <bool kIndexValid, int kIndex, class Tuple>
>  struct TupleElement;
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 0, GTEST_10_TUPLE_(T)> { typedef T0 type; };
> +struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
> +  typedef T0 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 1, GTEST_10_TUPLE_(T)> { typedef T1 type; };
> +struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
> +  typedef T1 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 2, GTEST_10_TUPLE_(T)> { typedef T2 type; };
> +struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
> +  typedef T2 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 3, GTEST_10_TUPLE_(T)> { typedef T3 type; };
> +struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
> +  typedef T3 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 4, GTEST_10_TUPLE_(T)> { typedef T4 type; };
> +struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
> +  typedef T4 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 5, GTEST_10_TUPLE_(T)> { typedef T5 type; };
> +struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
> +  typedef T5 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 6, GTEST_10_TUPLE_(T)> { typedef T6 type; };
> +struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
> +  typedef T6 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 7, GTEST_10_TUPLE_(T)> { typedef T7 type; };
> +struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
> +  typedef T7 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 8, GTEST_10_TUPLE_(T)> { typedef T8 type; };
> +struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
> +  typedef T8 type;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> { typedef T9 type; };
> +struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
> +  typedef T9 type;
> +};
>  
>  }  // namespace gtest_internal
>  
> @@ -708,37 +730,59 @@ inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
>  template <typename Tuple> struct tuple_size;
>  
>  template <GTEST_0_TYPENAMES_(T)>
> -struct tuple_size<GTEST_0_TUPLE_(T)> { static const int value = 0; };
> +struct tuple_size<GTEST_0_TUPLE_(T) > {
> +  static const int value = 0;
> +};
>  
>  template <GTEST_1_TYPENAMES_(T)>
> -struct tuple_size<GTEST_1_TUPLE_(T)> { static const int value = 1; };
> +struct tuple_size<GTEST_1_TUPLE_(T) > {
> +  static const int value = 1;
> +};
>  
>  template <GTEST_2_TYPENAMES_(T)>
> -struct tuple_size<GTEST_2_TUPLE_(T)> { static const int value = 2; };
> +struct tuple_size<GTEST_2_TUPLE_(T) > {
> +  static const int value = 2;
> +};
>  
>  template <GTEST_3_TYPENAMES_(T)>
> -struct tuple_size<GTEST_3_TUPLE_(T)> { static const int value = 3; };
> +struct tuple_size<GTEST_3_TUPLE_(T) > {
> +  static const int value = 3;
> +};
>  
>  template <GTEST_4_TYPENAMES_(T)>
> -struct tuple_size<GTEST_4_TUPLE_(T)> { static const int value = 4; };
> +struct tuple_size<GTEST_4_TUPLE_(T) > {
> +  static const int value = 4;
> +};
>  
>  template <GTEST_5_TYPENAMES_(T)>
> -struct tuple_size<GTEST_5_TUPLE_(T)> { static const int value = 5; };
> +struct tuple_size<GTEST_5_TUPLE_(T) > {
> +  static const int value = 5;
> +};
>  
>  template <GTEST_6_TYPENAMES_(T)>
> -struct tuple_size<GTEST_6_TUPLE_(T)> { static const int value = 6; };
> +struct tuple_size<GTEST_6_TUPLE_(T) > {
> +  static const int value = 6;
> +};
>  
>  template <GTEST_7_TYPENAMES_(T)>
> -struct tuple_size<GTEST_7_TUPLE_(T)> { static const int value = 7; };
> +struct tuple_size<GTEST_7_TUPLE_(T) > {
> +  static const int value = 7;
> +};
>  
>  template <GTEST_8_TYPENAMES_(T)>
> -struct tuple_size<GTEST_8_TUPLE_(T)> { static const int value = 8; };
> +struct tuple_size<GTEST_8_TUPLE_(T) > {
> +  static const int value = 8;
> +};
>  
>  template <GTEST_9_TYPENAMES_(T)>
> -struct tuple_size<GTEST_9_TUPLE_(T)> { static const int value = 9; };
> +struct tuple_size<GTEST_9_TUPLE_(T) > {
> +  static const int value = 9;
> +};
>  
>  template <GTEST_10_TYPENAMES_(T)>
> -struct tuple_size<GTEST_10_TUPLE_(T)> { static const int value = 10; };
> +struct tuple_size<GTEST_10_TUPLE_(T) > {
> +  static const int value = 10;
> +};
>  
>  template <int k, class Tuple>
>  struct tuple_element {
> @@ -922,8 +966,8 @@ template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
>  inline bool operator==(const GTEST_10_TUPLE_(T)& t,
>                         const GTEST_10_TUPLE_(U)& u) {
>    return gtest_internal::SameSizeTuplePrefixComparator<
> -      tuple_size<GTEST_10_TUPLE_(T)>::value,
> -      tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u);
> +      tuple_size<GTEST_10_TUPLE_(T) >::value,
> +      tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
>  }
>  
>  template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
> diff --git a/src/gtest/include/gtest/internal/gtest-tuple.h.pump b/src/gtest/include/gtest/internal/gtest-tuple.h.pump
> index ef51909..c7d9e03 100644
> --- a/src/gtest/include/gtest/internal/gtest-tuple.h.pump
> +++ b/src/gtest/include/gtest/internal/gtest-tuple.h.pump
> @@ -118,8 +118,9 @@ struct TupleElement;
>  
>  $for i [[
>  template <GTEST_$(n)_TYPENAMES_(T)>
> -struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T)> [[]]
> -{ typedef T$i type; };
> +struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T) > {
> +  typedef T$i type;
> +};
>  
>  
>  ]]
> @@ -220,7 +221,9 @@ template <typename Tuple> struct tuple_size;
>  
>  $for j [[
>  template <GTEST_$(j)_TYPENAMES_(T)>
> -struct tuple_size<GTEST_$(j)_TUPLE_(T)> { static const int value = $j; };
> +struct tuple_size<GTEST_$(j)_TUPLE_(T) > {
> +  static const int value = $j;
> +};
>  
>  
>  ]]
> @@ -302,8 +305,8 @@ template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
>  inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t,
>                         const GTEST_$(n)_TUPLE_(U)& u) {
>    return gtest_internal::SameSizeTuplePrefixComparator<
> -      tuple_size<GTEST_$(n)_TUPLE_(T)>::value,
> -      tuple_size<GTEST_$(n)_TUPLE_(U)>::value>::Eq(t, u);
> +      tuple_size<GTEST_$(n)_TUPLE_(T) >::value,
> +      tuple_size<GTEST_$(n)_TUPLE_(U) >::value>::Eq(t, u);
>  }
>  
>  template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
> diff --git a/src/gtest/include/gtest/internal/gtest-type-util.h b/src/gtest/include/gtest/internal/gtest-type-util.h
> index b7b01b0..e46f7cf 100644
> --- a/src/gtest/include/gtest/internal/gtest-type-util.h
> +++ b/src/gtest/include/gtest/internal/gtest-type-util.h
> @@ -45,15 +45,14 @@
>  #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
>  
>  #include "gtest/internal/gtest-port.h"
> -#include "gtest/internal/gtest-string.h"
>  
>  // #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
>  // libstdc++ (which is where cxxabi.h comes from).
> -# ifdef __GLIBCXX__
> +# if GTEST_HAS_CXXABI_H_
>  #  include <cxxabi.h>
>  # elif defined(__HP_aCC)
>  #  include <acxx_demangle.h>
> -# endif  // __GLIBCXX__
> +# endif  // GTEST_HASH_CXXABI_H_
>  
>  namespace testing {
>  namespace internal {
> @@ -62,24 +61,24 @@ namespace internal {
>  // NB: This function is also used in Google Mock, so don't move it inside of
>  // the typed-test-only section below.
>  template <typename T>
> -String GetTypeName() {
> +std::string GetTypeName() {
>  # if GTEST_HAS_RTTI
>  
>    const char* const name = typeid(T).name();
> -#  if defined(__GLIBCXX__) || defined(__HP_aCC)
> +#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
>    int status = 0;
>    // gcc's implementation of typeid(T).name() mangles the type name,
>    // so we have to demangle it.
> -#   ifdef __GLIBCXX__
> +#   if GTEST_HAS_CXXABI_H_
>    using abi::__cxa_demangle;
> -#   endif // __GLIBCXX__
> +#   endif  // GTEST_HAS_CXXABI_H_
>    char* const readable_name = __cxa_demangle(name, 0, 0, &status);
> -  const String name_str(status == 0 ? readable_name : name);
> +  const std::string name_str(status == 0 ? readable_name : name);
>    free(readable_name);
>    return name_str;
>  #  else
>    return name;
> -#  endif  // __GLIBCXX__ || __HP_aCC
> +#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
>  
>  # else
>  
> @@ -3300,7 +3299,9 @@ struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
>  // INSTANTIATE_TYPED_TEST_CASE_P().
>  
>  template <typename T>
> -struct TypeList { typedef Types1<T> type; };
> +struct TypeList {
> +  typedef Types1<T> type;
> +};
>  
>  template <typename T1, typename T2, typename T3, typename T4, typename T5,
>      typename T6, typename T7, typename T8, typename T9, typename T10,
> diff --git a/src/gtest/include/gtest/internal/gtest-type-util.h.pump b/src/gtest/include/gtest/internal/gtest-type-util.h.pump
> index 27f331d..251fdf0 100644
> --- a/src/gtest/include/gtest/internal/gtest-type-util.h.pump
> +++ b/src/gtest/include/gtest/internal/gtest-type-util.h.pump
> @@ -43,15 +43,14 @@ $var n = 50  $$ Maximum length of type lists we want to support.
>  #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
>  
>  #include "gtest/internal/gtest-port.h"
> -#include "gtest/internal/gtest-string.h"
>  
>  // #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
>  // libstdc++ (which is where cxxabi.h comes from).
> -# ifdef __GLIBCXX__
> +# if GTEST_HAS_CXXABI_H_
>  #  include <cxxabi.h>
>  # elif defined(__HP_aCC)
>  #  include <acxx_demangle.h>
> -# endif  // __GLIBCXX__
> +# endif  // GTEST_HASH_CXXABI_H_
>  
>  namespace testing {
>  namespace internal {
> @@ -60,24 +59,24 @@ namespace internal {
>  // NB: This function is also used in Google Mock, so don't move it inside of
>  // the typed-test-only section below.
>  template <typename T>
> -String GetTypeName() {
> +std::string GetTypeName() {
>  # if GTEST_HAS_RTTI
>  
>    const char* const name = typeid(T).name();
> -#  if defined(__GLIBCXX__) || defined(__HP_aCC)
> +#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
>    int status = 0;
>    // gcc's implementation of typeid(T).name() mangles the type name,
>    // so we have to demangle it.
> -#   ifdef __GLIBCXX__
> +#   if GTEST_HAS_CXXABI_H_
>    using abi::__cxa_demangle;
> -#   endif // __GLIBCXX__
> +#   endif  // GTEST_HAS_CXXABI_H_
>    char* const readable_name = __cxa_demangle(name, 0, 0, &status);
> -  const String name_str(status == 0 ? readable_name : name);
> +  const std::string name_str(status == 0 ? readable_name : name);
>    free(readable_name);
>    return name_str;
>  #  else
>    return name;
> -#  endif  // __GLIBCXX__ || __HP_aCC
> +#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
>  
>  # else
>  
> @@ -279,7 +278,9 @@ struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> {
>  // INSTANTIATE_TYPED_TEST_CASE_P().
>  
>  template <typename T>
> -struct TypeList { typedef Types1<T> type; };
> +struct TypeList {
> +  typedef Types1<T> type;
> +};
>  
>  
>  $range i 1..n
> diff --git a/src/gtest/src/gtest-death-test.cc b/src/gtest/src/gtest-death-test.cc
> index 8b2e413..a6023fc 100644
> --- a/src/gtest/src/gtest-death-test.cc
> +++ b/src/gtest/src/gtest-death-test.cc
> @@ -43,6 +43,11 @@
>  # include <errno.h>
>  # include <fcntl.h>
>  # include <limits.h>
> +
> +# if GTEST_OS_LINUX
> +#  include <signal.h>
> +# endif  // GTEST_OS_LINUX
> +
>  # include <stdarg.h>
>  
>  # if GTEST_OS_WINDOWS
> @@ -52,6 +57,10 @@
>  #  include <sys/wait.h>
>  # endif  // GTEST_OS_WINDOWS
>  
> +# if GTEST_OS_QNX
> +#  include <spawn.h>
> +# endif  // GTEST_OS_QNX
> +
>  #endif  // GTEST_HAS_DEATH_TEST
>  
>  #include "gtest/gtest-message.h"
> @@ -100,13 +109,42 @@ GTEST_DEFINE_string_(
>      "Indicates the file, line number, temporal index of "
>      "the single death test to run, and a file descriptor to "
>      "which a success code may be sent, all separated by "
> -    "colons.  This flag is specified if and only if the current "
> +    "the '|' characters.  This flag is specified if and only if the current "
>      "process is a sub-process launched for running a thread-safe "
>      "death test.  FOR INTERNAL USE ONLY.");
>  }  // namespace internal
>  
>  #if GTEST_HAS_DEATH_TEST
>  
> +namespace internal {
> +
> +// Valid only for fast death tests. Indicates the code is running in the
> +// child process of a fast style death test.
> +static bool g_in_fast_death_test_child = false;
> +
> +// Returns a Boolean value indicating whether the caller is currently
> +// executing in the context of the death test child process.  Tools such as
> +// Valgrind heap checkers may need this to modify their behavior in death
> +// tests.  IMPORTANT: This is an internal utility.  Using it may break the
> +// implementation of death tests.  User code MUST NOT use it.
> +bool InDeathTestChild() {
> +# if GTEST_OS_WINDOWS
> +
> +  // On Windows, death tests are thread-safe regardless of the value of the
> +  // death_test_style flag.
> +  return !GTEST_FLAG(internal_run_death_test).empty();
> +
> +# else
> +
> +  if (GTEST_FLAG(death_test_style) == "threadsafe")
> +    return !GTEST_FLAG(internal_run_death_test).empty();
> +  else
> +    return g_in_fast_death_test_child;
> +#endif
> +}
> +
> +}  // namespace internal
> +
>  // ExitedWithCode constructor.
>  ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
>  }
> @@ -141,7 +179,7 @@ namespace internal {
>  
>  // Generates a textual description of a given exit code, in the format
>  // specified by wait(2).
> -static String ExitSummary(int exit_code) {
> +static std::string ExitSummary(int exit_code) {
>    Message m;
>  
>  # if GTEST_OS_WINDOWS
> @@ -176,7 +214,7 @@ bool ExitedUnsuccessfully(int exit_status) {
>  // one thread running, or cannot determine the number of threads, prior
>  // to executing the given statement.  It is the responsibility of the
>  // caller not to pass a thread_count of 1.
> -static String DeathTestThreadWarning(size_t thread_count) {
> +static std::string DeathTestThreadWarning(size_t thread_count) {
>    Message msg;
>    msg << "Death tests use fork(), which is unsafe particularly"
>        << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
> @@ -210,7 +248,7 @@ enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
>  // message is propagated back to the parent process.  Otherwise, the
>  // message is simply printed to stderr.  In either case, the program
>  // then exits with status 1.
> -void DeathTestAbort(const String& message) {
> +void DeathTestAbort(const std::string& message) {
>    // On a POSIX system, this function may be called from a threadsafe-style
>    // death test child process, which operates on a very small stack.  Use
>    // the heap for any additional non-minuscule memory requirements.
> @@ -234,9 +272,10 @@ void DeathTestAbort(const String& message) {
>  # define GTEST_DEATH_TEST_CHECK_(expression) \
>    do { \
>      if (!::testing::internal::IsTrue(expression)) { \
> -      DeathTestAbort(::testing::internal::String::Format( \
> -          "CHECK failed: File %s, line %d: %s", \
> -          __FILE__, __LINE__, #expression)); \
> +      DeathTestAbort( \
> +          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
> +          + ::testing::internal::StreamableToString(__LINE__) + ": " \
> +          + #expression); \
>      } \
>    } while (::testing::internal::AlwaysFalse())
>  
> @@ -254,15 +293,16 @@ void DeathTestAbort(const String& message) {
>        gtest_retval = (expression); \
>      } while (gtest_retval == -1 && errno == EINTR); \
>      if (gtest_retval == -1) { \
> -      DeathTestAbort(::testing::internal::String::Format( \
> -          "CHECK failed: File %s, line %d: %s != -1", \
> -          __FILE__, __LINE__, #expression)); \
> +      DeathTestAbort( \
> +          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
> +          + ::testing::internal::StreamableToString(__LINE__) + ": " \
> +          + #expression + " != -1"); \
>      } \
>    } while (::testing::internal::AlwaysFalse())
>  
>  // Returns the message describing the last system error in errno.
> -String GetLastErrnoDescription() {
> -    return String(errno == 0 ? "" : posix::StrError(errno));
> +std::string GetLastErrnoDescription() {
> +    return errno == 0 ? "" : posix::StrError(errno);
>  }
>  
>  // This is called from a death test parent process to read a failure
> @@ -312,11 +352,11 @@ const char* DeathTest::LastMessage() {
>    return last_death_test_message_.c_str();
>  }
>  
> -void DeathTest::set_last_death_test_message(const String& message) {
> +void DeathTest::set_last_death_test_message(const std::string& message) {
>    last_death_test_message_ = message;
>  }
>  
> -String DeathTest::last_death_test_message_;
> +std::string DeathTest::last_death_test_message_;
>  
>  // Provides cross platform implementation for some death functionality.
>  class DeathTestImpl : public DeathTest {
> @@ -491,7 +531,7 @@ bool DeathTestImpl::Passed(bool status_ok) {
>    if (!spawned())
>      return false;
>  
> -  const String error_message = GetCapturedStderr();
> +  const std::string error_message = GetCapturedStderr();
>  
>    bool success = false;
>    Message buffer;
> @@ -673,22 +713,19 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
>        FALSE,   // The initial state is non-signalled.
>        NULL));  // The even is unnamed.
>    GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
> -  const String filter_flag = String::Format("--%s%s=%s.%s",
> -                                            GTEST_FLAG_PREFIX_, kFilterFlag,
> -                                            info->test_case_name(),
> -                                            info->name());
> -  const String internal_flag = String::Format(
> -    "--%s%s=%s|%d|%d|%u|%Iu|%Iu",
> -      GTEST_FLAG_PREFIX_,
> -      kInternalRunDeathTestFlag,
> -      file_, line_,
> -      death_test_index,
> -      static_cast<unsigned int>(::GetCurrentProcessId()),
> -      // size_t has the same with as pointers on both 32-bit and 64-bit
> +  const std::string filter_flag =
> +      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" +
> +      info->test_case_name() + "." + info->name();
> +  const std::string internal_flag =
> +      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
> +      "=" + file_ + "|" + StreamableToString(line_) + "|" +
> +      StreamableToString(death_test_index) + "|" +
> +      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
> +      // size_t has the same width as pointers on both 32-bit and 64-bit
>        // Windows platforms.
>        // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
> -      reinterpret_cast<size_t>(write_handle),
> -      reinterpret_cast<size_t>(event_handle_.Get()));
> +      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
> +      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
>  
>    char executable_path[_MAX_PATH + 1];  // NOLINT
>    GTEST_DEATH_TEST_CHECK_(
> @@ -696,10 +733,9 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
>                                              executable_path,
>                                              _MAX_PATH));
>  
> -  String command_line = String::Format("%s %s \"%s\"",
> -                                       ::GetCommandLineA(),
> -                                       filter_flag.c_str(),
> -                                       internal_flag.c_str());
> +  std::string command_line =
> +      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
> +      internal_flag + "\"";
>  
>    DeathTest::set_last_death_test_message("");
>  
> @@ -816,6 +852,7 @@ DeathTest::TestRole NoExecDeathTest::AssumeRole() {
>      // Event forwarding to the listeners of event listener API mush be shut
>      // down in death test subprocesses.
>      GetUnitTestImpl()->listeners()->SuppressEventForwarding();
> +    g_in_fast_death_test_child = true;
>      return EXECUTE_TEST;
>    } else {
>      GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
> @@ -835,6 +872,11 @@ class ExecDeathTest : public ForkingDeathTest {
>        ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
>    virtual TestRole AssumeRole();
>   private:
> +  static ::std::vector<testing::internal::string>
> +  GetArgvsForDeathTestChildProcess() {
> +    ::std::vector<testing::internal::string> args = GetInjectableArgvs();
> +    return args;
> +  }
>    // The name of the file in which the death test is located.
>    const char* const file_;
>    // The line number on which the death test is located.
> @@ -869,6 +911,7 @@ class Arguments {
>    char* const* Argv() {
>      return &args_[0];
>    }
> +
>   private:
>    std::vector<char*> args_;
>  };
> @@ -894,6 +937,7 @@ extern "C" char** environ;
>  inline char** GetEnviron() { return environ; }
>  #  endif  // GTEST_OS_MAC
>  
> +#  if !GTEST_OS_QNX
>  // The main function for a threadsafe-style death test child process.
>  // This function is called in a clone()-ed process and thus must avoid
>  // any potentially unsafe operations like malloc or libc functions.
> @@ -908,9 +952,8 @@ static int ExecDeathTestChildMain(void* child_arg) {
>        UnitTest::GetInstance()->original_working_dir();
>    // We can safely call chdir() as it's a direct system call.
>    if (chdir(original_dir) != 0) {
> -    DeathTestAbort(String::Format("chdir(\"%s\") failed: %s",
> -                                  original_dir,
> -                                  GetLastErrnoDescription().c_str()));
> +    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
> +                   GetLastErrnoDescription());
>      return EXIT_FAILURE;
>    }
>  
> @@ -920,12 +963,12 @@ static int ExecDeathTestChildMain(void* child_arg) {
>    // invoke the test program via a valid path that contains at least
>    // one path separator.
>    execve(args->argv[0], args->argv, GetEnviron());
> -  DeathTestAbort(String::Format("execve(%s, ...) in %s failed: %s",
> -                                args->argv[0],
> -                                original_dir,
> -                                GetLastErrnoDescription().c_str()));
> +  DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
> +                 original_dir + " failed: " +
> +                 GetLastErrnoDescription());
>    return EXIT_FAILURE;
>  }
> +#  endif  // !GTEST_OS_QNX
>  
>  // Two utility routines that together determine the direction the stack
>  // grows.
> @@ -936,25 +979,75 @@ static int ExecDeathTestChildMain(void* child_arg) {
>  // GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
>  // StackLowerThanAddress into StackGrowsDown, which then doesn't give
>  // correct answer.
> -bool StackLowerThanAddress(const void* ptr) GTEST_NO_INLINE_;
> -bool StackLowerThanAddress(const void* ptr) {
> +void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_;
> +void StackLowerThanAddress(const void* ptr, bool* result) {
>    int dummy;
> -  return &dummy < ptr;
> +  *result = (&dummy < ptr);
>  }
>  
>  bool StackGrowsDown() {
>    int dummy;
> -  return StackLowerThanAddress(&dummy);
> +  bool result;
> +  StackLowerThanAddress(&dummy, &result);
> +  return result;
>  }
>  
> -// A threadsafe implementation of fork(2) for threadsafe-style death tests
> -// that uses clone(2).  It dies with an error message if anything goes
> -// wrong.
> -static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
> +// Spawns a child process with the same executable as the current process in
> +// a thread-safe manner and instructs it to run the death test.  The
> +// implementation uses fork(2) + exec.  On systems where clone(2) is
> +// available, it is used instead, being slightly more thread-safe.  On QNX,
> +// fork supports only single-threaded environments, so this function uses
> +// spawn(2) there instead.  The function dies with an error message if
> +// anything goes wrong.
> +static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
>    ExecDeathTestArgs args = { argv, close_fd };
>    pid_t child_pid = -1;
>  
> -#  if GTEST_HAS_CLONE
> +#  if GTEST_OS_QNX
> +  // Obtains the current directory and sets it to be closed in the child
> +  // process.
> +  const int cwd_fd = open(".", O_RDONLY);
> +  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
> +  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
> +  // We need to execute the test program in the same environment where
> +  // it was originally invoked.  Therefore we change to the original
> +  // working directory first.
> +  const char* const original_dir =
> +      UnitTest::GetInstance()->original_working_dir();
> +  // We can safely call chdir() as it's a direct system call.
> +  if (chdir(original_dir) != 0) {
> +    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
> +                   GetLastErrnoDescription());
> +    return EXIT_FAILURE;
> +  }
> +
> +  int fd_flags;
> +  // Set close_fd to be closed after spawn.
> +  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
> +  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
> +                                        fd_flags | FD_CLOEXEC));
> +  struct inheritance inherit = {0};
> +  // spawn is a system call.
> +  child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron());
> +  // Restores the current working directory.
> +  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
> +  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
> +
> +#  else   // GTEST_OS_QNX
> +#   if GTEST_OS_LINUX
> +  // When a SIGPROF signal is received while fork() or clone() are executing,
> +  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
> +  // it after the call to fork()/clone() is complete.
> +  struct sigaction saved_sigprof_action;
> +  struct sigaction ignore_sigprof_action;
> +  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
> +  sigemptyset(&ignore_sigprof_action.sa_mask);
> +  ignore_sigprof_action.sa_handler = SIG_IGN;
> +  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
> +      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
> +#   endif  // GTEST_OS_LINUX
> +
> +#   if GTEST_HAS_CLONE
>    const bool use_fork = GTEST_FLAG(death_test_use_fork);
>  
>    if (!use_fork) {
> @@ -964,21 +1057,37 @@ static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
>      void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
>                               MAP_ANON | MAP_PRIVATE, -1, 0);
>      GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
> +
> +    // Maximum stack alignment in bytes:  For a downward-growing stack, this
> +    // amount is subtracted from size of the stack space to get an address
> +    // that is within the stack space and is aligned on all systems we care
> +    // about.  As far as I know there is no ABI with stack alignment greater
> +    // than 64.  We assume stack and stack_size already have alignment of
> +    // kMaxStackAlignment.
> +    const size_t kMaxStackAlignment = 64;
>      void* const stack_top =
> -        static_cast<char*>(stack) + (stack_grows_down ? stack_size : 0);
> +        static_cast<char*>(stack) +
> +            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
> +    GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
> +        reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0);
>  
>      child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
>  
>      GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
>    }
> -#  else
> +#   else
>    const bool use_fork = true;
> -#  endif  // GTEST_HAS_CLONE
> +#   endif  // GTEST_HAS_CLONE
>  
>    if (use_fork && (child_pid = fork()) == 0) {
>        ExecDeathTestChildMain(&args);
>        _exit(0);
>    }
> +#  endif  // GTEST_OS_QNX
> +#  if GTEST_OS_LINUX
> +  GTEST_DEATH_TEST_CHECK_SYSCALL_(
> +      sigaction(SIGPROF, &saved_sigprof_action, NULL));
> +#  endif  // GTEST_OS_LINUX
>  
>    GTEST_DEATH_TEST_CHECK_(child_pid != -1);
>    return child_pid;
> @@ -1006,16 +1115,16 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
>    // it be closed when the child process does an exec:
>    GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
>  
> -  const String filter_flag =
> -      String::Format("--%s%s=%s.%s",
> -                     GTEST_FLAG_PREFIX_, kFilterFlag,
> -                     info->test_case_name(), info->name());
> -  const String internal_flag =
> -      String::Format("--%s%s=%s|%d|%d|%d",
> -                     GTEST_FLAG_PREFIX_, kInternalRunDeathTestFlag,
> -                     file_, line_, death_test_index, pipe_fd[1]);
> +  const std::string filter_flag =
> +      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
> +      + info->test_case_name() + "." + info->name();
> +  const std::string internal_flag =
> +      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
> +      + file_ + "|" + StreamableToString(line_) + "|"
> +      + StreamableToString(death_test_index) + "|"
> +      + StreamableToString(pipe_fd[1]);
>    Arguments args;
> -  args.AddArguments(GetArgvs());
> +  args.AddArguments(GetArgvsForDeathTestChildProcess());
>    args.AddArgument(filter_flag.c_str());
>    args.AddArgument(internal_flag.c_str());
>  
> @@ -1026,7 +1135,7 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
>    // is necessary.
>    FlushInfoLog();
>  
> -  const pid_t child_pid = ExecDeathTestFork(args.Argv(), pipe_fd[0]);
> +  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
>    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
>    set_child_pid(child_pid);
>    set_read_fd(pipe_fd[0]);
> @@ -1052,9 +1161,10 @@ bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
>  
>    if (flag != NULL) {
>      if (death_test_index > flag->index()) {
> -      DeathTest::set_last_death_test_message(String::Format(
> -          "Death test count (%d) somehow exceeded expected maximum (%d)",
> -          death_test_index, flag->index()));
> +      DeathTest::set_last_death_test_message(
> +          "Death test count (" + StreamableToString(death_test_index)
> +          + ") somehow exceeded expected maximum ("
> +          + StreamableToString(flag->index()) + ")");
>        return false;
>      }
>  
> @@ -1083,9 +1193,9 @@ bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
>  # endif  // GTEST_OS_WINDOWS
>  
>    else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
> -    DeathTest::set_last_death_test_message(String::Format(
> -        "Unknown death test style \"%s\" encountered",
> -        GTEST_FLAG(death_test_style).c_str()));
> +    DeathTest::set_last_death_test_message(
> +        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
> +        + "\" encountered");
>      return false;
>    }
>  
> @@ -1123,8 +1233,8 @@ int GetStatusFileDescriptor(unsigned int parent_process_id,
>                                                     FALSE,  // Non-inheritable.
>                                                     parent_process_id));
>    if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
> -    DeathTestAbort(String::Format("Unable to open parent process %u",
> -                                  parent_process_id));
> +    DeathTestAbort("Unable to open parent process " +
> +                   StreamableToString(parent_process_id));
>    }
>  
>    // TODO(vladl@google.com): Replace the following check with a
> @@ -1144,9 +1254,10 @@ int GetStatusFileDescriptor(unsigned int parent_process_id,
>                                   // DUPLICATE_SAME_ACCESS is used.
>                           FALSE,  // Request non-inheritable handler.
>                           DUPLICATE_SAME_ACCESS)) {
> -    DeathTestAbort(String::Format(
> -        "Unable to duplicate the pipe handle %Iu from the parent process %u",
> -        write_handle_as_size_t, parent_process_id));
> +    DeathTestAbort("Unable to duplicate the pipe handle " +
> +                   StreamableToString(write_handle_as_size_t) +
> +                   " from the parent process " +
> +                   StreamableToString(parent_process_id));
>    }
>  
>    const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
> @@ -1157,17 +1268,18 @@ int GetStatusFileDescriptor(unsigned int parent_process_id,
>                           0x0,
>                           FALSE,
>                           DUPLICATE_SAME_ACCESS)) {
> -    DeathTestAbort(String::Format(
> -        "Unable to duplicate the event handle %Iu from the parent process %u",
> -        event_handle_as_size_t, parent_process_id));
> +    DeathTestAbort("Unable to duplicate the event handle " +
> +                   StreamableToString(event_handle_as_size_t) +
> +                   " from the parent process " +
> +                   StreamableToString(parent_process_id));
>    }
>  
>    const int write_fd =
>        ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
>    if (write_fd == -1) {
> -    DeathTestAbort(String::Format(
> -        "Unable to convert pipe handle %Iu to a file descriptor",
> -        write_handle_as_size_t));
> +    DeathTestAbort("Unable to convert pipe handle " +
> +                   StreamableToString(write_handle_as_size_t) +
> +                   " to a file descriptor");
>    }
>  
>    // Signals the parent that the write end of the pipe has been acquired
> @@ -1204,9 +1316,8 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
>        || !ParseNaturalNumber(fields[3], &parent_process_id)
>        || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
>        || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
> -    DeathTestAbort(String::Format(
> -        "Bad --gtest_internal_run_death_test flag: %s",
> -        GTEST_FLAG(internal_run_death_test).c_str()));
> +    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
> +                   GTEST_FLAG(internal_run_death_test));
>    }
>    write_fd = GetStatusFileDescriptor(parent_process_id,
>                                       write_handle_as_size_t,
> @@ -1217,9 +1328,8 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
>        || !ParseNaturalNumber(fields[1], &line)
>        || !ParseNaturalNumber(fields[2], &index)
>        || !ParseNaturalNumber(fields[3], &write_fd)) {
> -    DeathTestAbort(String::Format(
> -        "Bad --gtest_internal_run_death_test flag: %s",
> -        GTEST_FLAG(internal_run_death_test).c_str()));
> +    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
> +        + GTEST_FLAG(internal_run_death_test));
>    }
>  
>  # endif  // GTEST_OS_WINDOWS
> diff --git a/src/gtest/src/gtest-filepath.cc b/src/gtest/src/gtest-filepath.cc
> index 91b2571..6be58b6 100644
> --- a/src/gtest/src/gtest-filepath.cc
> +++ b/src/gtest/src/gtest-filepath.cc
> @@ -29,6 +29,7 @@
>  //
>  // Authors: keith.ray@gmail.com (Keith Ray)
>  
> +#include "gtest/gtest-message.h"
>  #include "gtest/internal/gtest-filepath.h"
>  #include "gtest/internal/gtest-port.h"
>  
> @@ -39,8 +40,8 @@
>  #elif GTEST_OS_WINDOWS
>  # include <direct.h>
>  # include <io.h>
> -#elif GTEST_OS_SYMBIAN || GTEST_OS_NACL
> -// Symbian OpenC and NaCl have PATH_MAX in sys/syslimits.h
> +#elif GTEST_OS_SYMBIAN
> +// Symbian OpenC has PATH_MAX in sys/syslimits.h
>  # include <sys/syslimits.h>
>  #else
>  # include <limits.h>
> @@ -116,9 +117,10 @@ FilePath FilePath::GetCurrentDir() {
>  // FilePath("dir/file"). If a case-insensitive extension is not
>  // found, returns a copy of the original FilePath.
>  FilePath FilePath::RemoveExtension(const char* extension) const {
> -  String dot_extension(String::Format(".%s", extension));
> -  if (pathname_.EndsWithCaseInsensitive(dot_extension.c_str())) {
> -    return FilePath(String(pathname_.c_str(), pathname_.length() - 4));
> +  const std::string dot_extension = std::string(".") + extension;
> +  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
> +    return FilePath(pathname_.substr(
> +        0, pathname_.length() - dot_extension.length()));
>    }
>    return *this;
>  }
> @@ -147,7 +149,7 @@ const char* FilePath::FindLastPathSeparator() const {
>  // On Windows platform, '\' is the path separator, otherwise it is '/'.
>  FilePath FilePath::RemoveDirectoryName() const {
>    const char* const last_sep = FindLastPathSeparator();
> -  return last_sep ? FilePath(String(last_sep + 1)) : *this;
> +  return last_sep ? FilePath(last_sep + 1) : *this;
>  }
>  
>  // RemoveFileName returns the directory path with the filename removed.
> @@ -158,9 +160,9 @@ FilePath FilePath::RemoveDirectoryName() const {
>  // On Windows platform, '\' is the path separator, otherwise it is '/'.
>  FilePath FilePath::RemoveFileName() const {
>    const char* const last_sep = FindLastPathSeparator();
> -  String dir;
> +  std::string dir;
>    if (last_sep) {
> -    dir = String(c_str(), last_sep + 1 - c_str());
> +    dir = std::string(c_str(), last_sep + 1 - c_str());
>    } else {
>      dir = kCurrentDirectoryString;
>    }
> @@ -177,11 +179,12 @@ FilePath FilePath::MakeFileName(const FilePath& directory,
>                                  const FilePath& base_name,
>                                  int number,
>                                  const char* extension) {
> -  String file;
> +  std::string file;
>    if (number == 0) {
> -    file = String::Format("%s.%s", base_name.c_str(), extension);
> +    file = base_name.string() + "." + extension;
>    } else {
> -    file = String::Format("%s_%d.%s", base_name.c_str(), number, extension);
> +    file = base_name.string() + "_" + StreamableToString(number)
> +        + "." + extension;
>    }
>    return ConcatPaths(directory, FilePath(file));
>  }
> @@ -193,8 +196,7 @@ FilePath FilePath::ConcatPaths(const FilePath& directory,
>    if (directory.IsEmpty())
>      return relative_path;
>    const FilePath dir(directory.RemoveTrailingPathSeparator());
> -  return FilePath(String::Format("%s%c%s", dir.c_str(), kPathSeparator,
> -                                 relative_path.c_str()));
> +  return FilePath(dir.string() + kPathSeparator + relative_path.string());
>  }
>  
>  // Returns true if pathname describes something findable in the file-system,
> @@ -338,7 +340,7 @@ bool FilePath::CreateFolder() const {
>  // On Windows platform, uses \ as the separator, other platforms use /.
>  FilePath FilePath::RemoveTrailingPathSeparator() const {
>    return IsDirectory()
> -      ? FilePath(String(pathname_.c_str(), pathname_.length() - 1))
> +      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
>        : *this;
>  }
>  
> diff --git a/src/gtest/src/gtest-internal-inl.h b/src/gtest/src/gtest-internal-inl.h
> index 65a2101..35df303 100644
> --- a/src/gtest/src/gtest-internal-inl.h
> +++ b/src/gtest/src/gtest-internal-inl.h
> @@ -58,6 +58,11 @@
>  
>  #include "gtest/internal/gtest-port.h"
>  
> +#if GTEST_CAN_STREAM_RESULTS_
> +# include <arpa/inet.h>  // NOLINT
> +# include <netdb.h>  // NOLINT
> +#endif
> +
>  #if GTEST_OS_WINDOWS
>  # include <windows.h>  // NOLINT
>  #endif  // GTEST_OS_WINDOWS
> @@ -112,6 +117,12 @@ GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
>  // Formats the given time in milliseconds as seconds.
>  GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
>  
> +// Converts the given time in milliseconds to a date string in the ISO 8601
> +// format, without the timezone information.  N.B.: due to the use the
> +// non-reentrant localtime() function, this function is not thread safe.  Do
> +// not use it in any code that can be called from multiple threads.
> +GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
> +
>  // Parses a string for an Int32 flag, in the form of "--flag=value".
>  //
>  // On success, stores the value of the flag in *value, and returns
> @@ -190,37 +201,35 @@ class GTestFlagSaver {
>      GTEST_FLAG(stream_result_to) = stream_result_to_;
>      GTEST_FLAG(throw_on_failure) = throw_on_failure_;
>    }
> +
>   private:
>    // Fields for saving the original values of flags.
>    bool also_run_disabled_tests_;
>    bool break_on_failure_;
>    bool catch_exceptions_;
> -  String color_;
> -  String death_test_style_;
> +  std::string color_;
> +  std::string death_test_style_;
>    bool death_test_use_fork_;
> -  String filter_;
> -  String internal_run_death_test_;
> +  std::string filter_;
> +  std::string internal_run_death_test_;
>    bool list_tests_;
> -  String output_;
> +  std::string output_;
>    bool print_time_;
> -  bool pretty_;
>    internal::Int32 random_seed_;
>    internal::Int32 repeat_;
>    bool shuffle_;
>    internal::Int32 stack_trace_depth_;
> -  String stream_result_to_;
> +  std::string stream_result_to_;
>    bool throw_on_failure_;
>  } GTEST_ATTRIBUTE_UNUSED_;
>  
>  // Converts a Unicode code point to a narrow string in UTF-8 encoding.
>  // code_point parameter is of type UInt32 because wchar_t may not be
>  // wide enough to contain a code point.
> -// The output buffer str must containt at least 32 characters.
> -// The function returns the address of the output buffer.
>  // If the code_point is not a valid Unicode code point
> -// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output
> -// as '(Invalid Unicode 0xXXXXXXXX)'.
> -GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str);
> +// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
> +// to "(Invalid Unicode 0xXXXXXXXX)".
> +GTEST_API_ std::string CodePointToUtf8(UInt32 code_point);
>  
>  // Converts a wide string to a narrow string in UTF-8 encoding.
>  // The wide string is assumed to have the following encoding:
> @@ -235,7 +244,7 @@ GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str);
>  // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
>  // and contains invalid UTF-16 surrogate pairs, values in those pairs
>  // will be encoded as individual Unicode characters from Basic Normal Plane.
> -GTEST_API_ String WideStringToUtf8(const wchar_t* str, int num_chars);
> +GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
>  
>  // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
>  // if the variable is present. If a file already exists at this location, this
> @@ -339,16 +348,15 @@ class TestPropertyKeyIs {
>    // Constructor.
>    //
>    // TestPropertyKeyIs has NO default constructor.
> -  explicit TestPropertyKeyIs(const char* key)
> -      : key_(key) {}
> +  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
>  
>    // Returns true iff the test name of test property matches on key_.
>    bool operator()(const TestProperty& test_property) const {
> -    return String(test_property.key()).Compare(key_) == 0;
> +    return test_property.key() == key_;
>    }
>  
>   private:
> -  String key_;
> +  std::string key_;
>  };
>  
>  // Class UnitTestOptions.
> @@ -366,12 +374,12 @@ class GTEST_API_ UnitTestOptions {
>    // Functions for processing the gtest_output flag.
>  
>    // Returns the output format, or "" for normal printed output.
> -  static String GetOutputFormat();
> +  static std::string GetOutputFormat();
>  
>    // Returns the absolute path of the requested output file, or the
>    // default (test_detail.xml in the original working directory) if
>    // none was explicitly specified.
> -  static String GetAbsolutePathToOutputFile();
> +  static std::string GetAbsolutePathToOutputFile();
>  
>    // Functions for processing the gtest_filter flag.
>  
> @@ -384,8 +392,8 @@ class GTEST_API_ UnitTestOptions {
>  
>    // Returns true iff the user-specified filter matches the test case
>    // name and the test name.
> -  static bool FilterMatchesTest(const String &test_case_name,
> -                                const String &test_name);
> +  static bool FilterMatchesTest(const std::string &test_case_name,
> +                                const std::string &test_name);
>  
>  #if GTEST_OS_WINDOWS
>    // Function for supporting the gtest_catch_exception flag.
> @@ -398,7 +406,7 @@ class GTEST_API_ UnitTestOptions {
>  
>    // Returns true if "name" matches the ':' separated list of glob-style
>    // filters in "filter".
> -  static bool MatchesFilter(const String& name, const char* filter);
> +  static bool MatchesFilter(const std::string& name, const char* filter);
>  };
>  
>  // Returns the current application's name, removing directory path if that
> @@ -411,13 +419,13 @@ class OsStackTraceGetterInterface {
>    OsStackTraceGetterInterface() {}
>    virtual ~OsStackTraceGetterInterface() {}
>  
> -  // Returns the current OS stack trace as a String.  Parameters:
> +  // Returns the current OS stack trace as an std::string.  Parameters:
>    //
>    //   max_depth  - the maximum number of stack frames to be included
>    //                in the trace.
>    //   skip_count - the number of top frames to be skipped; doesn't count
>    //                against max_depth.
> -  virtual String CurrentStackTrace(int max_depth, int skip_count) = 0;
> +  virtual string CurrentStackTrace(int max_depth, int skip_count) = 0;
>  
>    // UponLeavingGTest() should be called immediately before Google Test calls
>    // user code. It saves some information about the current stack that
> @@ -432,8 +440,11 @@ class OsStackTraceGetterInterface {
>  class OsStackTraceGetter : public OsStackTraceGetterInterface {
>   public:
>    OsStackTraceGetter() : caller_frame_(NULL) {}
> -  virtual String CurrentStackTrace(int max_depth, int skip_count);
> -  virtual void UponLeavingGTest();
> +
> +  virtual string CurrentStackTrace(int max_depth, int skip_count)
> +      GTEST_LOCK_EXCLUDED_(mutex_);
> +
> +  virtual void UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_);
>  
>    // This string is inserted in place of stack frames that are part of
>    // Google Test's implementation.
> @@ -455,7 +466,7 @@ class OsStackTraceGetter : public OsStackTraceGetterInterface {
>  struct TraceInfo {
>    const char* file;
>    int line;
> -  String message;
> +  std::string message;
>  };
>  
>  // This is the default global test part result reporter used in UnitTestImpl.
> @@ -539,15 +550,25 @@ class GTEST_API_ UnitTestImpl {
>    // Gets the number of failed tests.
>    int failed_test_count() const;
>  
> +  // Gets the number of disabled tests that will be reported in the XML report.
> +  int reportable_disabled_test_count() const;
> +
>    // Gets the number of disabled tests.
>    int disabled_test_count() const;
>  
> +  // Gets the number of tests to be printed in the XML report.
> +  int reportable_test_count() const;
> +
>    // Gets the number of all tests.
>    int total_test_count() const;
>  
>    // Gets the number of tests that should run.
>    int test_to_run_count() const;
>  
> +  // Gets the time of the test program start, in ms from the start of the
> +  // UNIX epoch.
> +  TimeInMillis start_timestamp() const { return start_timestamp_; }
> +
>    // Gets the elapsed time, in milliseconds.
>    TimeInMillis elapsed_time() const { return elapsed_time_; }
>  
> @@ -596,7 +617,7 @@ class GTEST_API_ UnitTestImpl {
>    // getter, and returns it.
>    OsStackTraceGetterInterface* os_stack_trace_getter();
>  
> -  // Returns the current OS stack trace as a String.
> +  // Returns the current OS stack trace as an std::string.
>    //
>    // The maximum number of stack frames to be included is specified by
>    // the gtest_stack_trace_depth flag.  The skip_count parameter
> @@ -606,7 +627,7 @@ class GTEST_API_ UnitTestImpl {
>    // For example, if Foo() calls Bar(), which in turn calls
>    // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
>    // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
> -  String CurrentOsStackTraceExceptTop(int skip_count);
> +  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
>  
>    // Finds and returns a TestCase with the given name.  If one doesn't
>    // exist, creates one and returns it.
> @@ -696,6 +717,12 @@ class GTEST_API_ UnitTestImpl {
>      ad_hoc_test_result_.Clear();
>    }
>  
> +  // Adds a TestProperty to the current TestResult object when invoked in a
> +  // context of a test or a test case, or to the global property set. If the
> +  // result already contains a property with the same key, the value will be
> +  // updated.
> +  void RecordProperty(const TestProperty& test_property);
> +
>    enum ReactionToSharding {
>      HONOR_SHARDING_PROTOCOL,
>      IGNORE_SHARDING_PROTOCOL
> @@ -880,6 +907,10 @@ class GTEST_API_ UnitTestImpl {
>    // Our random number generator.
>    internal::Random random_;
>  
> +  // The time of the test program start, in ms from the start of the
> +  // UNIX epoch.
> +  TimeInMillis start_timestamp_;
> +
>    // How long the test took to run, in milliseconds.
>    TimeInMillis elapsed_time_;
>  
> @@ -935,7 +966,7 @@ GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
>  
>  // Returns the message describing the last system error, regardless of the
>  // platform.
> -GTEST_API_ String GetLastErrnoDescription();
> +GTEST_API_ std::string GetLastErrnoDescription();
>  
>  # if GTEST_OS_WINDOWS
>  // Provides leak-safe Windows kernel handle ownership.
> @@ -1018,8 +1049,9 @@ bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
>  class TestResultAccessor {
>   public:
>    static void RecordProperty(TestResult* test_result,
> +                             const std::string& xml_element,
>                               const TestProperty& property) {
> -    test_result->RecordProperty(property);
> +    test_result->RecordProperty(xml_element, property);
>    }
>  
>    static void ClearTestPartResults(TestResult* test_result) {
> @@ -1032,6 +1064,154 @@ class TestResultAccessor {
>    }
>  };
>  
> +#if GTEST_CAN_STREAM_RESULTS_
> +
> +// Streams test results to the given port on the given host machine.
> +class StreamingListener : public EmptyTestEventListener {
> + public:
> +  // Abstract base class for writing strings to a socket.
> +  class AbstractSocketWriter {
> +   public:
> +    virtual ~AbstractSocketWriter() {}
> +
> +    // Sends a string to the socket.
> +    virtual void Send(const string& message) = 0;
> +
> +    // Closes the socket.
> +    virtual void CloseConnection() {}
> +
> +    // Sends a string and a newline to the socket.
> +    void SendLn(const string& message) {
> +      Send(message + "\n");
> +    }
> +  };
> +
> +  // Concrete class for actually writing strings to a socket.
> +  class SocketWriter : public AbstractSocketWriter {
> +   public:
> +    SocketWriter(const string& host, const string& port)
> +        : sockfd_(-1), host_name_(host), port_num_(port) {
> +      MakeConnection();
> +    }
> +
> +    virtual ~SocketWriter() {
> +      if (sockfd_ != -1)
> +        CloseConnection();
> +    }
> +
> +    // Sends a string to the socket.
> +    virtual void Send(const string& message) {
> +      GTEST_CHECK_(sockfd_ != -1)
> +          << "Send() can be called only when there is a connection.";
> +
> +      const int len = static_cast<int>(message.length());
> +      if (write(sockfd_, message.c_str(), len) != len) {
> +        GTEST_LOG_(WARNING)
> +            << "stream_result_to: failed to stream to "
> +            << host_name_ << ":" << port_num_;
> +      }
> +    }
> +
> +   private:
> +    // Creates a client socket and connects to the server.
> +    void MakeConnection();
> +
> +    // Closes the socket.
> +    void CloseConnection() {
> +      GTEST_CHECK_(sockfd_ != -1)
> +          << "CloseConnection() can be called only when there is a connection.";
> +
> +      close(sockfd_);
> +      sockfd_ = -1;
> +    }
> +
> +    int sockfd_;  // socket file descriptor
> +    const string host_name_;
> +    const string port_num_;
> +
> +    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
> +  };  // class SocketWriter
> +
> +  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
> +  static string UrlEncode(const char* str);
> +
> +  StreamingListener(const string& host, const string& port)
> +      : socket_writer_(new SocketWriter(host, port)) { Start(); }
> +
> +  explicit StreamingListener(AbstractSocketWriter* socket_writer)
> +      : socket_writer_(socket_writer) { Start(); }
> +
> +  void OnTestProgramStart(const UnitTest& /* unit_test */) {
> +    SendLn("event=TestProgramStart");
> +  }
> +
> +  void OnTestProgramEnd(const UnitTest& unit_test) {
> +    // Note that Google Test current only report elapsed time for each
> +    // test iteration, not for the entire test program.
> +    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
> +
> +    // Notify the streaming server to stop.
> +    socket_writer_->CloseConnection();
> +  }
> +
> +  void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
> +    SendLn("event=TestIterationStart&iteration=" +
> +           StreamableToString(iteration));
> +  }
> +
> +  void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
> +    SendLn("event=TestIterationEnd&passed=" +
> +           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
> +           StreamableToString(unit_test.elapsed_time()) + "ms");
> +  }
> +
> +  void OnTestCaseStart(const TestCase& test_case) {
> +    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
> +  }
> +
> +  void OnTestCaseEnd(const TestCase& test_case) {
> +    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
> +           + "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
> +           + "ms");
> +  }
> +
> +  void OnTestStart(const TestInfo& test_info) {
> +    SendLn(std::string("event=TestStart&name=") + test_info.name());
> +  }
> +
> +  void OnTestEnd(const TestInfo& test_info) {
> +    SendLn("event=TestEnd&passed=" +
> +           FormatBool((test_info.result())->Passed()) +
> +           "&elapsed_time=" +
> +           StreamableToString((test_info.result())->elapsed_time()) + "ms");
> +  }
> +
> +  void OnTestPartResult(const TestPartResult& test_part_result) {
> +    const char* file_name = test_part_result.file_name();
> +    if (file_name == NULL)
> +      file_name = "";
> +    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
> +           "&line=" + StreamableToString(test_part_result.line_number()) +
> +           "&message=" + UrlEncode(test_part_result.message()));
> +  }
> +
> + private:
> +  // Sends the given message and a newline to the socket.
> +  void SendLn(const string& message) { socket_writer_->SendLn(message); }
> +
> +  // Called at the start of streaming to notify the receiver what
> +  // protocol we are using.
> +  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
> +
> +  string FormatBool(bool value) { return value ? "1" : "0"; }
> +
> +  const scoped_ptr<AbstractSocketWriter> socket_writer_;
> +
> +  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
> +};  // class StreamingListener
> +
> +#endif  // GTEST_CAN_STREAM_RESULTS_
> +
>  }  // namespace internal
>  }  // namespace testing
>  
> diff --git a/src/gtest/src/gtest-port.cc b/src/gtest/src/gtest-port.cc
> index b860d48..0c4df5f 100644
> --- a/src/gtest/src/gtest-port.cc
> +++ b/src/gtest/src/gtest-port.cc
> @@ -51,6 +51,11 @@
>  # include <mach/vm_map.h>
>  #endif  // GTEST_OS_MAC
>  
> +#if GTEST_OS_QNX
> +# include <devctl.h>
> +# include <sys/procfs.h>
> +#endif  // GTEST_OS_QNX
> +
>  #include "gtest/gtest-spi.h"
>  #include "gtest/gtest-message.h"
>  #include "gtest/internal/gtest-internal.h"
> @@ -98,6 +103,26 @@ size_t GetThreadCount() {
>    }
>  }
>  
> +#elif GTEST_OS_QNX
> +
> +// Returns the number of threads running in the process, or 0 to indicate that
> +// we cannot detect it.
> +size_t GetThreadCount() {
> +  const int fd = open("/proc/self/as", O_RDONLY);
> +  if (fd < 0) {
> +    return 0;
> +  }
> +  procfs_info process_info;
> +  const int status =
> +      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL);
> +  close(fd);
> +  if (status == EOK) {
> +    return static_cast<size_t>(process_info.num_threads);
> +  } else {
> +    return 0;
> +  }
> +}
> +
>  #else
>  
>  size_t GetThreadCount() {
> @@ -222,7 +247,7 @@ bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
>  }
>  
>  // Helper function used by ValidateRegex() to format error messages.
> -String FormatRegexSyntaxError(const char* regex, int index) {
> +std::string FormatRegexSyntaxError(const char* regex, int index) {
>    return (Message() << "Syntax error at index " << index
>            << " in simple regular expression \"" << regex << "\": ").GetString();
>  }
> @@ -429,15 +454,15 @@ const char kUnknownFile[] = "unknown file";
>  // Formats a source file path and a line number as they would appear
>  // in an error message from the compiler used to compile this code.
>  GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
> -  const char* const file_name = file == NULL ? kUnknownFile : file;
> +  const std::string file_name(file == NULL ? kUnknownFile : file);
>  
>    if (line < 0) {
> -    return String::Format("%s:", file_name).c_str();
> +    return file_name + ":";
>    }
>  #ifdef _MSC_VER
> -  return String::Format("%s(%d):", file_name, line).c_str();
> +  return file_name + "(" + StreamableToString(line) + "):";
>  #else
> -  return String::Format("%s:%d:", file_name, line).c_str();
> +  return file_name + ":" + StreamableToString(line) + ":";
>  #endif  // _MSC_VER
>  }
>  
> @@ -448,12 +473,12 @@ GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
>  // to the file location it produces, unlike FormatFileLocation().
>  GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
>      const char* file, int line) {
> -  const char* const file_name = file == NULL ? kUnknownFile : file;
> +  const std::string file_name(file == NULL ? kUnknownFile : file);
>  
>    if (line < 0)
>      return file_name;
>    else
> -    return String::Format("%s:%d", file_name, line).c_str();
> +    return file_name + ":" + StreamableToString(line);
>  }
>  
>  
> @@ -488,8 +513,7 @@ GTestLog::~GTestLog() {
>  class CapturedStream {
>   public:
>    // The ctor redirects the stream to a temporary file.
> -  CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
> -
> +  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
>  # if GTEST_OS_WINDOWS
>      char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
>      char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
> @@ -506,10 +530,29 @@ class CapturedStream {
>                                      << temp_file_path;
>      filename_ = temp_file_path;
>  # else
> -    // There's no guarantee that a test has write access to the
> -    // current directory, so we create the temporary file in the /tmp
> -    // directory instead.
> +    // There's no guarantee that a test has write access to the current
> +    // directory, so we create the temporary file in the /tmp directory
> +    // instead. We use /tmp on most systems, and /sdcard on Android.
> +    // That's because Android doesn't have /tmp.
> +#  if GTEST_OS_LINUX_ANDROID
> +    // Note: Android applications are expected to call the framework's
> +    // Context.getExternalStorageDirectory() method through JNI to get
> +    // the location of the world-writable SD Card directory. However,
> +    // this requires a Context handle, which cannot be retrieved
> +    // globally from native code. Doing so also precludes running the
> +    // code as part of a regular standalone executable, which doesn't
> +    // run in a Dalvik process (e.g. when running it through 'adb shell').
> +    //
> +    // The location /sdcard is directly accessible from native code
> +    // and is the only location (unofficially) supported by the Android
> +    // team. It's generally a symlink to the real SD Card mount point
> +    // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
> +    // other OEM-customized locations. Never rely on these, and always
> +    // use /sdcard.
> +    char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
> +#  else
>      char name_template[] = "/tmp/captured_stream.XXXXXX";
> +#  endif  // GTEST_OS_LINUX_ANDROID
>      const int captured_fd = mkstemp(name_template);
>      filename_ = name_template;
>  # endif  // GTEST_OS_WINDOWS
> @@ -522,7 +565,7 @@ class CapturedStream {
>      remove(filename_.c_str());
>    }
>  
> -  String GetCapturedString() {
> +  std::string GetCapturedString() {
>      if (uncaptured_fd_ != -1) {
>        // Restores the original stream.
>        fflush(NULL);
> @@ -532,14 +575,14 @@ class CapturedStream {
>      }
>  
>      FILE* const file = posix::FOpen(filename_.c_str(), "r");
> -    const String content = ReadEntireFile(file);
> +    const std::string content = ReadEntireFile(file);
>      posix::FClose(file);
>      return content;
>    }
>  
>   private:
> -  // Reads the entire content of a file as a String.
> -  static String ReadEntireFile(FILE* file);
> +  // Reads the entire content of a file as an std::string.
> +  static std::string ReadEntireFile(FILE* file);
>  
>    // Returns the size (in bytes) of a file.
>    static size_t GetFileSize(FILE* file);
> @@ -559,7 +602,7 @@ size_t CapturedStream::GetFileSize(FILE* file) {
>  }
>  
>  // Reads the entire content of a file as a string.
> -String CapturedStream::ReadEntireFile(FILE* file) {
> +std::string CapturedStream::ReadEntireFile(FILE* file) {
>    const size_t file_size = GetFileSize(file);
>    char* const buffer = new char[file_size];
>  
> @@ -575,7 +618,7 @@ String CapturedStream::ReadEntireFile(FILE* file) {
>      bytes_read += bytes_last_read;
>    } while (bytes_last_read > 0 && bytes_read < file_size);
>  
> -  const String content(buffer, bytes_read);
> +  const std::string content(buffer, bytes_read);
>    delete[] buffer;
>  
>    return content;
> @@ -598,8 +641,8 @@ void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
>  }
>  
>  // Stops capturing the output stream and returns the captured string.
> -String GetCapturedStream(CapturedStream** captured_stream) {
> -  const String content = (*captured_stream)->GetCapturedString();
> +std::string GetCapturedStream(CapturedStream** captured_stream) {
> +  const std::string content = (*captured_stream)->GetCapturedString();
>  
>    delete *captured_stream;
>    *captured_stream = NULL;
> @@ -618,21 +661,37 @@ void CaptureStderr() {
>  }
>  
>  // Stops capturing stdout and returns the captured string.
> -String GetCapturedStdout() { return GetCapturedStream(&g_captured_stdout); }
> +std::string GetCapturedStdout() {
> +  return GetCapturedStream(&g_captured_stdout);
> +}
>  
>  // Stops capturing stderr and returns the captured string.
> -String GetCapturedStderr() { return GetCapturedStream(&g_captured_stderr); }
> +std::string GetCapturedStderr() {
> +  return GetCapturedStream(&g_captured_stderr);
> +}
>  
>  #endif  // GTEST_HAS_STREAM_REDIRECTION
>  
>  #if GTEST_HAS_DEATH_TEST
>  
>  // A copy of all command line arguments.  Set by InitGoogleTest().
> -::std::vector<String> g_argvs;
> +::std::vector<testing::internal::string> g_argvs;
>  
> -// Returns the command line as a vector of strings.
> -const ::std::vector<String>& GetArgvs() { return g_argvs; }
> +static const ::std::vector<testing::internal::string>* g_injected_test_argvs =
> +                                        NULL;  // Owned.
>  
> +void SetInjectableArgvs(const ::std::vector<testing::internal::string>* argvs) {
> +  if (g_injected_test_argvs != argvs)
> +    delete g_injected_test_argvs;
> +  g_injected_test_argvs = argvs;
> +}
> +
> +const ::std::vector<testing::internal::string>& GetInjectableArgvs() {
> +  if (g_injected_test_argvs != NULL) {
> +    return *g_injected_test_argvs;
> +  }
> +  return g_argvs;
> +}
>  #endif  // GTEST_HAS_DEATH_TEST
>  
>  #if GTEST_OS_WINDOWS_MOBILE
> @@ -647,8 +706,8 @@ void Abort() {
>  // Returns the name of the environment variable corresponding to the
>  // given flag.  For example, FlagToEnvVar("foo") will return
>  // "GTEST_FOO" in the open-source version.
> -static String FlagToEnvVar(const char* flag) {
> -  const String full_flag =
> +static std::string FlagToEnvVar(const char* flag) {
> +  const std::string full_flag =
>        (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
>  
>    Message env_var;
> @@ -705,7 +764,7 @@ bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
>  //
>  // The value is considered true iff it's not "0".
>  bool BoolFromGTestEnv(const char* flag, bool default_value) {
> -  const String env_var = FlagToEnvVar(flag);
> +  const std::string env_var = FlagToEnvVar(flag);
>    const char* const string_value = posix::GetEnv(env_var.c_str());
>    return string_value == NULL ?
>        default_value : strcmp(string_value, "0") != 0;
> @@ -715,7 +774,7 @@ bool BoolFromGTestEnv(const char* flag, bool default_value) {
>  // variable corresponding to the given flag; if it isn't set or
>  // doesn't represent a valid 32-bit integer, returns default_value.
>  Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
> -  const String env_var = FlagToEnvVar(flag);
> +  const std::string env_var = FlagToEnvVar(flag);
>    const char* const string_value = posix::GetEnv(env_var.c_str());
>    if (string_value == NULL) {
>      // The environment variable is not set.
> @@ -737,7 +796,7 @@ Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
>  // Reads and returns the string environment variable corresponding to
>  // the given flag; if it's not set, returns default_value.
>  const char* StringFromGTestEnv(const char* flag, const char* default_value) {
> -  const String env_var = FlagToEnvVar(flag);
> +  const std::string env_var = FlagToEnvVar(flag);
>    const char* const value = posix::GetEnv(env_var.c_str());
>    return value == NULL ? default_value : value;
>  }
> diff --git a/src/gtest/src/gtest-printers.cc b/src/gtest/src/gtest-printers.cc
> index ed63c7b..75fa408 100644
> --- a/src/gtest/src/gtest-printers.cc
> +++ b/src/gtest/src/gtest-printers.cc
> @@ -55,14 +55,6 @@ namespace {
>  
>  using ::std::ostream;
>  
> -#if GTEST_OS_WINDOWS_MOBILE  // Windows CE does not define _snprintf_s.
> -# define snprintf _snprintf
> -#elif _MSC_VER >= 1400  // VC 8.0 and later deprecate snprintf and _snprintf.
> -# define snprintf _snprintf_s
> -#elif _MSC_VER
> -# define snprintf _snprintf
> -#endif  // GTEST_OS_WINDOWS_MOBILE
> -
>  // Prints a segment of bytes in the given object.
>  void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
>                                  size_t count, ostream* os) {
> @@ -77,7 +69,7 @@ void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
>        else
>          *os << '-';
>      }
> -    snprintf(text, sizeof(text), "%02X", obj_bytes[j]);
> +    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
>      *os << text;
>    }
>  }
> @@ -184,16 +176,16 @@ static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
>          *os << static_cast<char>(c);
>          return kAsIs;
>        } else {
> -        *os << String::Format("\\x%X", static_cast<UnsignedChar>(c));
> +        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
>          return kHexEscape;
>        }
>    }
>    return kSpecialEscape;
>  }
>  
> -// Prints a char c as if it's part of a string literal, escaping it when
> +// Prints a wchar_t c as if it's part of a string literal, escaping it when
>  // necessary; returns how c was formatted.
> -static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
> +static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
>    switch (c) {
>      case L'\'':
>        *os << "'";
> @@ -208,8 +200,9 @@ static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
>  
>  // Prints a char c as if it's part of a string literal, escaping it when
>  // necessary; returns how c was formatted.
> -static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
> -  return PrintAsWideStringLiteralTo(static_cast<unsigned char>(c), os);
> +static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
> +  return PrintAsStringLiteralTo(
> +      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
>  }
>  
>  // Prints a wide or narrow character c and its code.  '\0' is printed
> @@ -228,7 +221,7 @@ void PrintCharAndCodeTo(Char c, ostream* os) {
>    // obvious).
>    if (c == 0)
>      return;
> -  *os << " (" << String::Format("%d", c).c_str();
> +  *os << " (" << static_cast<int>(c);
>  
>    // For more convenience, we print c's code again in hexidecimal,
>    // unless c was already printed in the form '\x##' or the code is in
> @@ -236,8 +229,7 @@ void PrintCharAndCodeTo(Char c, ostream* os) {
>    if (format == kHexEscape || (1 <= c && c <= 9)) {
>      // Do nothing.
>    } else {
> -    *os << String::Format(", 0x%X",
> -                          static_cast<UnsignedChar>(c)).c_str();
> +    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
>    }
>    *os << ")";
>  }
> @@ -255,48 +247,63 @@ void PrintTo(wchar_t wc, ostream* os) {
>    PrintCharAndCodeTo<wchar_t>(wc, os);
>  }
>  
> -// Prints the given array of characters to the ostream.
> -// The array starts at *begin, the length is len, it may include '\0' characters
> -// and may not be null-terminated.
> -static void PrintCharsAsStringTo(const char* begin, size_t len, ostream* os) {
> -  *os << "\"";
> +// Prints the given array of characters to the ostream.  CharType must be either
> +// char or wchar_t.
> +// The array starts at begin, the length is len, it may include '\0' characters
> +// and may not be NUL-terminated.
> +template <typename CharType>
> +static void PrintCharsAsStringTo(
> +    const CharType* begin, size_t len, ostream* os) {
> +  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
> +  *os << kQuoteBegin;
>    bool is_previous_hex = false;
>    for (size_t index = 0; index < len; ++index) {
> -    const char cur = begin[index];
> +    const CharType cur = begin[index];
>      if (is_previous_hex && IsXDigit(cur)) {
>        // Previous character is of '\x..' form and this character can be
>        // interpreted as another hexadecimal digit in its number. Break string to
>        // disambiguate.
> -      *os << "\" \"";
> +      *os << "\" " << kQuoteBegin;
>      }
> -    is_previous_hex = PrintAsNarrowStringLiteralTo(cur, os) == kHexEscape;
> +    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
>    }
>    *os << "\"";
>  }
>  
> +// Prints a (const) char/wchar_t array of 'len' elements, starting at address
> +// 'begin'.  CharType must be either char or wchar_t.
> +template <typename CharType>
> +static void UniversalPrintCharArray(
> +    const CharType* begin, size_t len, ostream* os) {
> +  // The code
> +  //   const char kFoo[] = "foo";
> +  // generates an array of 4, not 3, elements, with the last one being '\0'.
> +  //
> +  // Therefore when printing a char array, we don't print the last element if
> +  // it's '\0', such that the output matches the string literal as it's
> +  // written in the source code.
> +  if (len > 0 && begin[len - 1] == '\0') {
> +    PrintCharsAsStringTo(begin, len - 1, os);
> +    return;
> +  }
> +
> +  // If, however, the last element in the array is not '\0', e.g.
> +  //    const char kFoo[] = { 'f', 'o', 'o' };
> +  // we must print the entire array.  We also print a message to indicate
> +  // that the array is not NUL-terminated.
> +  PrintCharsAsStringTo(begin, len, os);
> +  *os << " (no terminating NUL)";
> +}
> +
>  // Prints a (const) char array of 'len' elements, starting at address 'begin'.
>  void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
> -  PrintCharsAsStringTo(begin, len, os);
> +  UniversalPrintCharArray(begin, len, os);
>  }
>  
> -// Prints the given array of wide characters to the ostream.
> -// The array starts at *begin, the length is len, it may include L'\0'
> -// characters and may not be null-terminated.
> -static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
> -                                     ostream* os) {
> -  *os << "L\"";
> -  bool is_previous_hex = false;
> -  for (size_t index = 0; index < len; ++index) {
> -    const wchar_t cur = begin[index];
> -    if (is_previous_hex && isascii(cur) && IsXDigit(static_cast<char>(cur))) {
> -      // Previous character is of '\x..' form and this character can be
> -      // interpreted as another hexadecimal digit in its number. Break string to
> -      // disambiguate.
> -      *os << "\" L\"";
> -    }
> -    is_previous_hex = PrintAsWideStringLiteralTo(cur, os) == kHexEscape;
> -  }
> -  *os << "\"";
> +// Prints a (const) wchar_t array of 'len' elements, starting at address
> +// 'begin'.
> +void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
> +  UniversalPrintCharArray(begin, len, os);
>  }
>  
>  // Prints the given C string to the ostream.
> @@ -322,7 +329,7 @@ void PrintTo(const wchar_t* s, ostream* os) {
>      *os << "NULL";
>    } else {
>      *os << ImplicitCast_<const void*>(s) << " pointing to ";
> -    PrintWideCharsAsStringTo(s, wcslen(s), os);
> +    PrintCharsAsStringTo(s, wcslen(s), os);
>    }
>  }
>  #endif  // wchar_t is native
> @@ -341,13 +348,13 @@ void PrintStringTo(const ::std::string& s, ostream* os) {
>  // Prints a ::wstring object.
>  #if GTEST_HAS_GLOBAL_WSTRING
>  void PrintWideStringTo(const ::wstring& s, ostream* os) {
> -  PrintWideCharsAsStringTo(s.data(), s.size(), os);
> +  PrintCharsAsStringTo(s.data(), s.size(), os);
>  }
>  #endif  // GTEST_HAS_GLOBAL_WSTRING
>  
>  #if GTEST_HAS_STD_WSTRING
>  void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
> -  PrintWideCharsAsStringTo(s.data(), s.size(), os);
> +  PrintCharsAsStringTo(s.data(), s.size(), os);
>  }
>  #endif  // GTEST_HAS_STD_WSTRING
>  
> diff --git a/src/gtest/src/gtest-test-part.cc b/src/gtest/src/gtest-test-part.cc
> index 5ddc67c..c60eef3 100644
> --- a/src/gtest/src/gtest-test-part.cc
> +++ b/src/gtest/src/gtest-test-part.cc
> @@ -48,10 +48,10 @@ using internal::GetUnitTestImpl;
>  
>  // Gets the summary of the failure message by omitting the stack trace
>  // in it.
> -internal::String TestPartResult::ExtractSummary(const char* message) {
> +std::string TestPartResult::ExtractSummary(const char* message) {
>    const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
> -  return stack_trace == NULL ? internal::String(message) :
> -      internal::String(message, stack_trace - message);
> +  return stack_trace == NULL ? message :
> +      std::string(message, stack_trace);
>  }
>  
>  // Prints a TestPartResult object.
> diff --git a/src/gtest/src/gtest-typed-test.cc b/src/gtest/src/gtest-typed-test.cc
> index a5cc88f..f0079f4 100644
> --- a/src/gtest/src/gtest-typed-test.cc
> +++ b/src/gtest/src/gtest-typed-test.cc
> @@ -58,10 +58,10 @@ const char* TypedTestCasePState::VerifyRegisteredTestNames(
>    registered_tests = SkipSpaces(registered_tests);
>  
>    Message errors;
> -  ::std::set<String> tests;
> +  ::std::set<std::string> tests;
>    for (const char* names = registered_tests; names != NULL;
>         names = SkipComma(names)) {
> -    const String name = GetPrefixUntilComma(names);
> +    const std::string name = GetPrefixUntilComma(names);
>      if (tests.count(name) != 0) {
>        errors << "Test " << name << " is listed more than once.\n";
>        continue;
> @@ -93,7 +93,7 @@ const char* TypedTestCasePState::VerifyRegisteredTestNames(
>      }
>    }
>  
> -  const String& errors_str = errors.GetString();
> +  const std::string& errors_str = errors.GetString();
>    if (errors_str != "") {
>      fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
>              errors_str.c_str());
> diff --git a/src/gtest/src/gtest.cc b/src/gtest/src/gtest.cc
> index 904d9d7..6de53dd 100644
> --- a/src/gtest/src/gtest.cc
> +++ b/src/gtest/src/gtest.cc
> @@ -39,10 +39,13 @@
>  #include <stdarg.h>
>  #include <stdio.h>
>  #include <stdlib.h>
> +#include <time.h>
>  #include <wchar.h>
>  #include <wctype.h>
>  
>  #include <algorithm>
> +#include <iomanip>
> +#include <limits>
>  #include <ostream>  // NOLINT
>  #include <sstream>
>  #include <vector>
> @@ -179,6 +182,10 @@ bool g_help_flag = false;
>  
>  }  // namespace internal
>  
> +static const char* GetDefaultFilter() {
> +  return kUniversalFilter;
> +}
> +
>  GTEST_DEFINE_bool_(
>      also_run_disabled_tests,
>      internal::BoolFromGTestEnv("also_run_disabled_tests", false),
> @@ -201,11 +208,11 @@ GTEST_DEFINE_string_(
>      "Whether to use colors in the output.  Valid values: yes, no, "
>      "and auto.  'auto' means to use colors if the output is "
>      "being sent to a terminal and the TERM environment variable "
> -    "is set to xterm, xterm-color, xterm-256color, linux or cygwin.");
> +    "is set to a terminal type that supports colors.");
>  
>  GTEST_DEFINE_string_(
>      filter,
> -    internal::StringFromGTestEnv("filter", kUniversalFilter),
> +    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
>      "A colon-separated list of glob (not regex) patterns "
>      "for filtering the tests to run, optionally followed by a "
>      "'-' and a : separated list of negative patterns (tests to "
> @@ -305,7 +312,7 @@ UInt32 Random::Generate(UInt32 range) {
>  // Test.  g_init_gtest_count is set to the number of times
>  // InitGoogleTest() has been called.  We don't protect this variable
>  // under a mutex as it is only accessed in the main thread.
> -int g_init_gtest_count = 0;
> +GTEST_API_ int g_init_gtest_count = 0;
>  static bool GTestIsInitialized() { return g_init_gtest_count != 0; }
>  
>  // Iterates over a vector of TestCases, keeping a running sum of the
> @@ -360,10 +367,10 @@ void AssertHelper::operator=(const Message& message) const {
>  }
>  
>  // Mutex for linked pointers.
> -GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
> +GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
>  
>  // Application pathname gotten in InitGoogleTest.
> -String g_executable_path;
> +std::string g_executable_path;
>  
>  // Returns the current application's name, removing directory path if that
>  // is present.
> @@ -382,29 +389,29 @@ FilePath GetCurrentExecutableName() {
>  // Functions for processing the gtest_output flag.
>  
>  // Returns the output format, or "" for normal printed output.
> -String UnitTestOptions::GetOutputFormat() {
> +std::string UnitTestOptions::GetOutputFormat() {
>    const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
> -  if (gtest_output_flag == NULL) return String("");
> +  if (gtest_output_flag == NULL) return std::string("");
>  
>    const char* const colon = strchr(gtest_output_flag, ':');
>    return (colon == NULL) ?
> -      String(gtest_output_flag) :
> -      String(gtest_output_flag, colon - gtest_output_flag);
> +      std::string(gtest_output_flag) :
> +      std::string(gtest_output_flag, colon - gtest_output_flag);
>  }
>  
>  // Returns the name of the requested output file, or the default if none
>  // was explicitly specified.
> -String UnitTestOptions::GetAbsolutePathToOutputFile() {
> +std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
>    const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
>    if (gtest_output_flag == NULL)
> -    return String("");
> +    return "";
>  
>    const char* const colon = strchr(gtest_output_flag, ':');
>    if (colon == NULL)
> -    return String(internal::FilePath::ConcatPaths(
> -               internal::FilePath(
> -                   UnitTest::GetInstance()->original_working_dir()),
> -               internal::FilePath(kDefaultOutputFile)).ToString() );
> +    return internal::FilePath::ConcatPaths(
> +        internal::FilePath(
> +            UnitTest::GetInstance()->original_working_dir()),
> +        internal::FilePath(kDefaultOutputFile)).string();
>  
>    internal::FilePath output_name(colon + 1);
>    if (!output_name.IsAbsolutePath())
> @@ -417,12 +424,12 @@ String UnitTestOptions::GetAbsolutePathToOutputFile() {
>          internal::FilePath(colon + 1));
>  
>    if (!output_name.IsDirectory())
> -    return output_name.ToString();
> +    return output_name.string();
>  
>    internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
>        output_name, internal::GetCurrentExecutableName(),
>        GetOutputFormat().c_str()));
> -  return result.ToString();
> +  return result.string();
>  }
>  
>  // Returns true iff the wildcard pattern matches the string.  The
> @@ -447,7 +454,8 @@ bool UnitTestOptions::PatternMatchesString(const char *pattern,
>    }
>  }
>  
> -bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) {
> +bool UnitTestOptions::MatchesFilter(
> +    const std::string& name, const char* filter) {
>    const char *cur_pattern = filter;
>    for (;;) {
>      if (PatternMatchesString(cur_pattern, name.c_str())) {
> @@ -467,28 +475,24 @@ bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) {
>    }
>  }
>  
> -// TODO(keithray): move String function implementations to gtest-string.cc.
> -
>  // Returns true iff the user-specified filter matches the test case
>  // name and the test name.
> -bool UnitTestOptions::FilterMatchesTest(const String &test_case_name,
> -                                        const String &test_name) {
> -  const String& full_name = String::Format("%s.%s",
> -                                           test_case_name.c_str(),
> -                                           test_name.c_str());
> +bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
> +                                        const std::string &test_name) {
> +  const std::string& full_name = test_case_name + "." + test_name.c_str();
>  
>    // Split --gtest_filter at '-', if there is one, to separate into
>    // positive filter and negative filter portions
>    const char* const p = GTEST_FLAG(filter).c_str();
>    const char* const dash = strchr(p, '-');
> -  String positive;
> -  String negative;
> +  std::string positive;
> +  std::string negative;
>    if (dash == NULL) {
>      positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
> -    negative = String("");
> +    negative = "";
>    } else {
> -    positive = String(p, dash - p);  // Everything up to the dash
> -    negative = String(dash+1);       // Everything after the dash
> +    positive = std::string(p, dash);   // Everything up to the dash
> +    negative = std::string(dash + 1);  // Everything after the dash
>      if (positive.empty()) {
>        // Treat '-test1' as the same as '*-test1'
>        positive = kUniversalFilter;
> @@ -608,7 +612,7 @@ AssertionResult HasOneFailure(const char* /* results_expr */,
>                                const TestPartResultArray& results,
>                                TestPartResult::Type type,
>                                const string& substr) {
> -  const String expected(type == TestPartResult::kFatalFailure ?
> +  const std::string expected(type == TestPartResult::kFatalFailure ?
>                          "1 fatal failure" :
>                          "1 non-fatal failure");
>    Message msg;
> @@ -731,11 +735,22 @@ int UnitTestImpl::failed_test_count() const {
>    return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
>  }
>  
> +// Gets the number of disabled tests that will be reported in the XML report.
> +int UnitTestImpl::reportable_disabled_test_count() const {
> +  return SumOverTestCaseList(test_cases_,
> +                             &TestCase::reportable_disabled_test_count);
> +}
> +
>  // Gets the number of disabled tests.
>  int UnitTestImpl::disabled_test_count() const {
>    return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
>  }
>  
> +// Gets the number of tests to be printed in the XML report.
> +int UnitTestImpl::reportable_test_count() const {
> +  return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count);
> +}
> +
>  // Gets the number of all tests.
>  int UnitTestImpl::total_test_count() const {
>    return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
> @@ -746,7 +761,7 @@ int UnitTestImpl::test_to_run_count() const {
>    return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
>  }
>  
> -// Returns the current OS stack trace as a String.
> +// Returns the current OS stack trace as an std::string.
>  //
>  // The maximum number of stack frames to be included is specified by
>  // the gtest_stack_trace_depth flag.  The skip_count parameter
> @@ -756,9 +771,9 @@ int UnitTestImpl::test_to_run_count() const {
>  // For example, if Foo() calls Bar(), which in turn calls
>  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
>  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
> -String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
> +std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
>    (void)skip_count;
> -  return String("");
> +  return "";
>  }
>  
>  // Returns the current time in milliseconds.
> @@ -815,41 +830,7 @@ TimeInMillis GetTimeInMillis() {
>  
>  // Utilities
>  
> -// class String
> -
> -// Returns the input enclosed in double quotes if it's not NULL;
> -// otherwise returns "(null)".  For example, "\"Hello\"" is returned
> -// for input "Hello".
> -//
> -// This is useful for printing a C string in the syntax of a literal.
> -//
> -// Known issue: escape sequences are not handled yet.
> -String String::ShowCStringQuoted(const char* c_str) {
> -  return c_str ? String::Format("\"%s\"", c_str) : String("(null)");
> -}
> -
> -// Copies at most length characters from str into a newly-allocated
> -// piece of memory of size length+1.  The memory is allocated with new[].
> -// A terminating null byte is written to the memory, and a pointer to it
> -// is returned.  If str is NULL, NULL is returned.
> -static char* CloneString(const char* str, size_t length) {
> -  if (str == NULL) {
> -    return NULL;
> -  } else {
> -    char* const clone = new char[length + 1];
> -    posix::StrNCpy(clone, str, length);
> -    clone[length] = '\0';
> -    return clone;
> -  }
> -}
> -
> -// Clones a 0-terminated C string, allocating memory using new.  The
> -// caller is responsible for deleting[] the return value.  Returns the
> -// cloned string, or NULL if the input is NULL.
> -const char * String::CloneCString(const char* c_str) {
> -  return (c_str == NULL) ?
> -                    NULL : CloneString(c_str, strlen(c_str));
> -}
> +// class String.
>  
>  #if GTEST_OS_WINDOWS_MOBILE
>  // Creates a UTF-16 wide string from the given ANSI string, allocating
> @@ -906,11 +887,6 @@ bool String::CStringEquals(const char * lhs, const char * rhs) {
>  // encoding, and streams the result to the given Message object.
>  static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
>                                       Message* msg) {
> -  // TODO(wan): consider allowing a testing::String object to
> -  // contain '\0'.  This will make it behave more like std::string,
> -  // and will allow ToUtf8String() to return the correct encoding
> -  // for '\0' s.t. we can get rid of the conditional here (and in
> -  // several other places).
>    for (size_t i = 0; i != length; ) {  // NOLINT
>      if (wstr[i] != L'\0') {
>        *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
> @@ -927,6 +903,26 @@ static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
>  
>  }  // namespace internal
>  
> +// Constructs an empty Message.
> +// We allocate the stringstream separately because otherwise each use of
> +// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
> +// stack frame leading to huge stack frames in some cases; gcc does not reuse
> +// the stack space.
> +Message::Message() : ss_(new ::std::stringstream) {
> +  // By default, we want there to be enough precision when printing
> +  // a double to a Message.
> +  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
> +}
> +
> +// These two overloads allow streaming a wide C string to a Message
> +// using the UTF-8 encoding.
> +Message& Message::operator <<(const wchar_t* wide_c_str) {
> +  return *this << internal::String::ShowWideCString(wide_c_str);
> +}
> +Message& Message::operator <<(wchar_t* wide_c_str) {
> +  return *this << internal::String::ShowWideCString(wide_c_str);
> +}
> +
>  #if GTEST_HAS_STD_WSTRING
>  // Converts the given wide string to a narrow string using the UTF-8
>  // encoding, and streams the result to this Message object.
> @@ -945,6 +941,12 @@ Message& Message::operator <<(const ::wstring& wstr) {
>  }
>  #endif  // GTEST_HAS_GLOBAL_WSTRING
>  
> +// Gets the text streamed to this object so far as an std::string.
> +// Each '\0' character in the buffer is replaced with "\\0".
> +std::string Message::GetString() const {
> +  return internal::StringStreamToString(ss_.get());
> +}
> +
>  // AssertionResult constructors.
>  // Used in EXPECT_TRUE/FALSE(assertion_result).
>  AssertionResult::AssertionResult(const AssertionResult& other)
> @@ -997,8 +999,8 @@ namespace internal {
>  // be inserted into the message.
>  AssertionResult EqFailure(const char* expected_expression,
>                            const char* actual_expression,
> -                          const String& expected_value,
> -                          const String& actual_value,
> +                          const std::string& expected_value,
> +                          const std::string& actual_value,
>                            bool ignoring_case) {
>    Message msg;
>    msg << "Value of: " << actual_expression;
> @@ -1018,10 +1020,11 @@ AssertionResult EqFailure(const char* expected_expression,
>  }
>  
>  // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
> -String GetBoolAssertionFailureMessage(const AssertionResult& assertion_result,
> -                                      const char* expression_text,
> -                                      const char* actual_predicate_value,
> -                                      const char* expected_predicate_value) {
> +std::string GetBoolAssertionFailureMessage(
> +    const AssertionResult& assertion_result,
> +    const char* expression_text,
> +    const char* actual_predicate_value,
> +    const char* expected_predicate_value) {
>    const char* actual_message = assertion_result.message();
>    Message msg;
>    msg << "Value of: " << expression_text
> @@ -1168,8 +1171,8 @@ AssertionResult CmpHelperSTREQ(const char* expected_expression,
>  
>    return EqFailure(expected_expression,
>                     actual_expression,
> -                   String::ShowCStringQuoted(expected),
> -                   String::ShowCStringQuoted(actual),
> +                   PrintToString(expected),
> +                   PrintToString(actual),
>                     false);
>  }
>  
> @@ -1184,8 +1187,8 @@ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
>  
>    return EqFailure(expected_expression,
>                     actual_expression,
> -                   String::ShowCStringQuoted(expected),
> -                   String::ShowCStringQuoted(actual),
> +                   PrintToString(expected),
> +                   PrintToString(actual),
>                     true);
>  }
>  
> @@ -1349,7 +1352,7 @@ AssertionResult HRESULTFailureHelper(const char* expr,
>    // want inserts expanded.
>    const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
>                         FORMAT_MESSAGE_IGNORE_INSERTS;
> -  const DWORD kBufSize = 4096;  // String::Format can't exceed this length.
> +  const DWORD kBufSize = 4096;
>    // Gets the system's human readable message string for this HRESULT.
>    char error_text[kBufSize] = { '\0' };
>    DWORD message_length = ::FormatMessageA(kFlags,
> @@ -1359,7 +1362,7 @@ AssertionResult HRESULTFailureHelper(const char* expr,
>                                            error_text,  // output buffer
>                                            kBufSize,  // buf size
>                                            NULL);  // no arguments for inserts
> -  // Trims tailing white space (FormatMessage leaves a trailing cr-lf)
> +  // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
>    for (; message_length && IsSpace(error_text[message_length - 1]);
>            --message_length) {
>      error_text[message_length - 1] = '\0';
> @@ -1367,10 +1370,10 @@ AssertionResult HRESULTFailureHelper(const char* expr,
>  
>  # endif  // GTEST_OS_WINDOWS_MOBILE
>  
> -  const String error_hex(String::Format("0x%08X ", hr));
> +  const std::string error_hex("0x" + String::FormatHexInt(hr));
>    return ::testing::AssertionFailure()
>        << "Expected: " << expr << " " << expected << ".\n"
> -      << "  Actual: " << error_hex << error_text << "\n";
> +      << "  Actual: " << error_hex << " " << error_text << "\n";
>  }
>  
>  }  // namespace
> @@ -1427,12 +1430,15 @@ inline UInt32 ChopLowBits(UInt32* bits, int n) {
>  // Converts a Unicode code point to a narrow string in UTF-8 encoding.
>  // code_point parameter is of type UInt32 because wchar_t may not be
>  // wide enough to contain a code point.
> -// The output buffer str must containt at least 32 characters.
> -// The function returns the address of the output buffer.
>  // If the code_point is not a valid Unicode code point
> -// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output
> -// as '(Invalid Unicode 0xXXXXXXXX)'.
> -char* CodePointToUtf8(UInt32 code_point, char* str) {
> +// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
> +// to "(Invalid Unicode 0xXXXXXXXX)".
> +std::string CodePointToUtf8(UInt32 code_point) {
> +  if (code_point > kMaxCodePoint4) {
> +    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
> +  }
> +
> +  char str[5];  // Big enough for the largest valid code point.
>    if (code_point <= kMaxCodePoint1) {
>      str[1] = '\0';
>      str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
> @@ -1445,22 +1451,12 @@ char* CodePointToUtf8(UInt32 code_point, char* str) {
>      str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
>      str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
>      str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
> -  } else if (code_point <= kMaxCodePoint4) {
> +  } else {  // code_point <= kMaxCodePoint4
>      str[4] = '\0';
>      str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
>      str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
>      str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
>      str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
> -  } else {
> -    // The longest string String::Format can produce when invoked
> -    // with these parameters is 28 character long (not including
> -    // the terminating nul character). We are asking for 32 character
> -    // buffer just in case. This is also enough for strncpy to
> -    // null-terminate the destination string.
> -    posix::StrNCpy(
> -        str, String::Format("(Invalid Unicode 0x%X)", code_point).c_str(), 32);
> -    str[31] = '\0';  // Makes sure no change in the format to strncpy leaves
> -                     // the result unterminated.
>    }
>    return str;
>  }
> @@ -1501,7 +1497,7 @@ inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
>  // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
>  // and contains invalid UTF-16 surrogate pairs, values in those pairs
>  // will be encoded as individual Unicode characters from Basic Normal Plane.
> -String WideStringToUtf8(const wchar_t* str, int num_chars) {
> +std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
>    if (num_chars == -1)
>      num_chars = static_cast<int>(wcslen(str));
>  
> @@ -1519,27 +1515,17 @@ String WideStringToUtf8(const wchar_t* str, int num_chars) {
>        unicode_code_point = static_cast<UInt32>(str[i]);
>      }
>  
> -    char buffer[32];  // CodePointToUtf8 requires a buffer this big.
> -    stream << CodePointToUtf8(unicode_code_point, buffer);
> +    stream << CodePointToUtf8(unicode_code_point);
>    }
>    return StringStreamToString(&stream);
>  }
>  
> -// Converts a wide C string to a String using the UTF-8 encoding.
> +// Converts a wide C string to an std::string using the UTF-8 encoding.
>  // NULL will be converted to "(null)".
> -String String::ShowWideCString(const wchar_t * wide_c_str) {
> -  if (wide_c_str == NULL) return String("(null)");
> -
> -  return String(internal::WideStringToUtf8(wide_c_str, -1).c_str());
> -}
> -
> -// Similar to ShowWideCString(), except that this function encloses
> -// the converted string in double quotes.
> -String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
> -  if (wide_c_str == NULL) return String("(null)");
> +std::string String::ShowWideCString(const wchar_t * wide_c_str) {
> +  if (wide_c_str == NULL)  return "(null)";
>  
> -  return String::Format("L\"%s\"",
> -                        String::ShowWideCString(wide_c_str).c_str());
> +  return internal::WideStringToUtf8(wide_c_str, -1);
>  }
>  
>  // Compares two wide C strings.  Returns true iff they have the same
> @@ -1567,8 +1553,8 @@ AssertionResult CmpHelperSTREQ(const char* expected_expression,
>  
>    return EqFailure(expected_expression,
>                     actual_expression,
> -                   String::ShowWideCStringQuoted(expected),
> -                   String::ShowWideCStringQuoted(actual),
> +                   PrintToString(expected),
> +                   PrintToString(actual),
>                     false);
>  }
>  
> @@ -1583,8 +1569,8 @@ AssertionResult CmpHelperSTRNE(const char* s1_expression,
>  
>    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
>                              << s2_expression << "), actual: "
> -                            << String::ShowWideCStringQuoted(s1)
> -                            << " vs " << String::ShowWideCStringQuoted(s2);
> +                            << PrintToString(s1)
> +                            << " vs " << PrintToString(s2);
>  }
>  
>  // Compares two C strings, ignoring case.  Returns true iff they have
> @@ -1635,135 +1621,69 @@ bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
>  #endif  // OS selector
>  }
>  
> -// Compares this with another String.
> -// Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
> -// if this is greater than rhs.
> -int String::Compare(const String & rhs) const {
> -  const char* const lhs_c_str = c_str();
> -  const char* const rhs_c_str = rhs.c_str();
> -
> -  if (lhs_c_str == NULL) {
> -    return rhs_c_str == NULL ? 0 : -1;  // NULL < anything except NULL
> -  } else if (rhs_c_str == NULL) {
> -    return 1;
> -  }
> -
> -  const size_t shorter_str_len =
> -      length() <= rhs.length() ? length() : rhs.length();
> -  for (size_t i = 0; i != shorter_str_len; i++) {
> -    if (lhs_c_str[i] < rhs_c_str[i]) {
> -      return -1;
> -    } else if (lhs_c_str[i] > rhs_c_str[i]) {
> -      return 1;
> -    }
> -  }
> -  return (length() < rhs.length()) ? -1 :
> -      (length() > rhs.length()) ? 1 : 0;
> +// Returns true iff str ends with the given suffix, ignoring case.
> +// Any string is considered to end with an empty suffix.
> +bool String::EndsWithCaseInsensitive(
> +    const std::string& str, const std::string& suffix) {
> +  const size_t str_len = str.length();
> +  const size_t suffix_len = suffix.length();
> +  return (str_len >= suffix_len) &&
> +         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
> +                                      suffix.c_str());
>  }
>  
> -// Returns true iff this String ends with the given suffix.  *Any*
> -// String is considered to end with a NULL or empty suffix.
> -bool String::EndsWith(const char* suffix) const {
> -  if (suffix == NULL || CStringEquals(suffix, "")) return true;
> -
> -  if (c_str() == NULL) return false;
> -
> -  const size_t this_len = strlen(c_str());
> -  const size_t suffix_len = strlen(suffix);
> -  return (this_len >= suffix_len) &&
> -         CStringEquals(c_str() + this_len - suffix_len, suffix);
> +// Formats an int value as "%02d".
> +std::string String::FormatIntWidth2(int value) {
> +  std::stringstream ss;
> +  ss << std::setfill('0') << std::setw(2) << value;
> +  return ss.str();
>  }
>  
> -// Returns true iff this String ends with the given suffix, ignoring case.
> -// Any String is considered to end with a NULL or empty suffix.
> -bool String::EndsWithCaseInsensitive(const char* suffix) const {
> -  if (suffix == NULL || CStringEquals(suffix, "")) return true;
> -
> -  if (c_str() == NULL) return false;
> -
> -  const size_t this_len = strlen(c_str());
> -  const size_t suffix_len = strlen(suffix);
> -  return (this_len >= suffix_len) &&
> -         CaseInsensitiveCStringEquals(c_str() + this_len - suffix_len, suffix);
> +// Formats an int value as "%X".
> +std::string String::FormatHexInt(int value) {
> +  std::stringstream ss;
> +  ss << std::hex << std::uppercase << value;
> +  return ss.str();
>  }
>  
> -// Formats a list of arguments to a String, using the same format
> -// spec string as for printf.
> -//
> -// We do not use the StringPrintf class as it is not universally
> -// available.
> -//
> -// The result is limited to 4096 characters (including the tailing 0).
> -// If 4096 characters are not enough to format the input, or if
> -// there's an error, "<formatting error or buffer exceeded>" is
> -// returned.
> -String String::Format(const char * format, ...) {
> -  va_list args;
> -  va_start(args, format);
> -
> -  char buffer[4096];
> -  const int kBufferSize = sizeof(buffer)/sizeof(buffer[0]);
> -
> -  // MSVC 8 deprecates vsnprintf(), so we want to suppress warning
> -  // 4996 (deprecated function) there.
> -#ifdef _MSC_VER  // We are using MSVC.
> -# pragma warning(push)          // Saves the current warning state.
> -# pragma warning(disable:4996)  // Temporarily disables warning 4996.
> -
> -  const int size = vsnprintf(buffer, kBufferSize, format, args);
> -
> -# pragma warning(pop)           // Restores the warning state.
> -#else  // We are not using MSVC.
> -  const int size = vsnprintf(buffer, kBufferSize, format, args);
> -#endif  // _MSC_VER
> -  va_end(args);
> -
> -  // vsnprintf()'s behavior is not portable.  When the buffer is not
> -  // big enough, it returns a negative value in MSVC, and returns the
> -  // needed buffer size on Linux.  When there is an output error, it
> -  // always returns a negative value.  For simplicity, we lump the two
> -  // error cases together.
> -  if (size < 0 || size >= kBufferSize) {
> -    return String("<formatting error or buffer exceeded>");
> -  } else {
> -    return String(buffer, size);
> -  }
> +// Formats a byte as "%02X".
> +std::string String::FormatByte(unsigned char value) {
> +  std::stringstream ss;
> +  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
> +     << static_cast<unsigned int>(value);
> +  return ss.str();
>  }
>  
> -// Converts the buffer in a stringstream to a String, converting NUL
> +// Converts the buffer in a stringstream to an std::string, converting NUL
>  // bytes to "\\0" along the way.
> -String StringStreamToString(::std::stringstream* ss) {
> +std::string StringStreamToString(::std::stringstream* ss) {
>    const ::std::string& str = ss->str();
>    const char* const start = str.c_str();
>    const char* const end = start + str.length();
>  
> -  // We need to use a helper stringstream to do this transformation
> -  // because String doesn't support push_back().
> -  ::std::stringstream helper;
> +  std::string result;
> +  result.reserve(2 * (end - start));
>    for (const char* ch = start; ch != end; ++ch) {
>      if (*ch == '\0') {
> -      helper << "\\0";  // Replaces NUL with "\\0";
> +      result += "\\0";  // Replaces NUL with "\\0";
>      } else {
> -      helper.put(*ch);
> +      result += *ch;
>      }
>    }
>  
> -  return String(helper.str().c_str());
> +  return result;
>  }
>  
>  // Appends the user-supplied message to the Google-Test-generated message.
> -String AppendUserMessage(const String& gtest_msg,
> -                         const Message& user_msg) {
> +std::string AppendUserMessage(const std::string& gtest_msg,
> +                              const Message& user_msg) {
>    // Appends the user message if it's non-empty.
> -  const String user_msg_string = user_msg.GetString();
> +  const std::string user_msg_string = user_msg.GetString();
>    if (user_msg_string.empty()) {
>      return gtest_msg;
>    }
>  
> -  Message msg;
> -  msg << gtest_msg << "\n" << user_msg_string;
> -
> -  return msg.GetString();
> +  return gtest_msg + "\n" + user_msg_string;
>  }
>  
>  }  // namespace internal
> @@ -1811,8 +1731,9 @@ void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
>  // Adds a test property to the list. If a property with the same key as the
>  // supplied property is already represented, the value of this test_property
>  // replaces the old value for that key.
> -void TestResult::RecordProperty(const TestProperty& test_property) {
> -  if (!ValidateTestProperty(test_property)) {
> +void TestResult::RecordProperty(const std::string& xml_element,
> +                                const TestProperty& test_property) {
> +  if (!ValidateTestProperty(xml_element, test_property)) {
>      return;
>    }
>    internal::MutexLock lock(&test_properites_mutex_);
> @@ -1826,21 +1747,94 @@ void TestResult::RecordProperty(const TestProperty& test_property) {
>    property_with_matching_key->SetValue(test_property.value());
>  }
>  
> -// Adds a failure if the key is a reserved attribute of Google Test
> -// testcase tags.  Returns true if the property is valid.
> -bool TestResult::ValidateTestProperty(const TestProperty& test_property) {
> -  internal::String key(test_property.key());
> -  if (key == "name" || key == "status" || key == "time" || key == "classname") {
> -    ADD_FAILURE()
> -        << "Reserved key used in RecordProperty(): "
> -        << key
> -        << " ('name', 'status', 'time', and 'classname' are reserved by "
> -        << GTEST_NAME_ << ")";
> +// The list of reserved attributes used in the <testsuites> element of XML
> +// output.
> +static const char* const kReservedTestSuitesAttributes[] = {
> +  "disabled",
> +  "errors",
> +  "failures",
> +  "name",
> +  "random_seed",
> +  "tests",
> +  "time",
> +  "timestamp"
> +};
> +
> +// The list of reserved attributes used in the <testsuite> element of XML
> +// output.
> +static const char* const kReservedTestSuiteAttributes[] = {
> +  "disabled",
> +  "errors",
> +  "failures",
> +  "name",
> +  "tests",
> +  "time"
> +};
> +
> +// The list of reserved attributes used in the <testcase> element of XML output.
> +static const char* const kReservedTestCaseAttributes[] = {
> +  "classname",
> +  "name",
> +  "status",
> +  "time",
> +  "type_param",
> +  "value_param"
> +};
> +
> +template <int kSize>
> +std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
> +  return std::vector<std::string>(array, array + kSize);
> +}
> +
> +static std::vector<std::string> GetReservedAttributesForElement(
> +    const std::string& xml_element) {
> +  if (xml_element == "testsuites") {
> +    return ArrayAsVector(kReservedTestSuitesAttributes);
> +  } else if (xml_element == "testsuite") {
> +    return ArrayAsVector(kReservedTestSuiteAttributes);
> +  } else if (xml_element == "testcase") {
> +    return ArrayAsVector(kReservedTestCaseAttributes);
> +  } else {
> +    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
> +  }
> +  // This code is unreachable but some compilers may not realizes that.
> +  return std::vector<std::string>();
> +}
> +
> +static std::string FormatWordList(const std::vector<std::string>& words) {
> +  Message word_list;
> +  for (size_t i = 0; i < words.size(); ++i) {
> +    if (i > 0 && words.size() > 2) {
> +      word_list << ", ";
> +    }
> +    if (i == words.size() - 1) {
> +      word_list << "and ";
> +    }
> +    word_list << "'" << words[i] << "'";
> +  }
> +  return word_list.GetString();
> +}
> +
> +bool ValidateTestPropertyName(const std::string& property_name,
> +                              const std::vector<std::string>& reserved_names) {
> +  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
> +          reserved_names.end()) {
> +    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
> +                  << " (" << FormatWordList(reserved_names)
> +                  << " are reserved by " << GTEST_NAME_ << ")";
>      return false;
>    }
>    return true;
>  }
>  
> +// Adds a failure if the key is a reserved attribute of the element named
> +// xml_element.  Returns true if the property is valid.
> +bool TestResult::ValidateTestProperty(const std::string& xml_element,
> +                                      const TestProperty& test_property) {
> +  return ValidateTestPropertyName(test_property.key(),
> +                                  GetReservedAttributesForElement(xml_element));
> +}
> +
>  // Clears the object.
>  void TestResult::Clear() {
>    test_part_results_.clear();
> @@ -1916,12 +1910,12 @@ void Test::TearDown() {
>  }
>  
>  // Allows user supplied key value pairs to be recorded for later output.
> -void Test::RecordProperty(const char* key, const char* value) {
> -  UnitTest::GetInstance()->RecordPropertyForCurrentTest(key, value);
> +void Test::RecordProperty(const std::string& key, const std::string& value) {
> +  UnitTest::GetInstance()->RecordProperty(key, value);
>  }
>  
>  // Allows user supplied key value pairs to be recorded for later output.
> -void Test::RecordProperty(const char* key, int value) {
> +void Test::RecordProperty(const std::string& key, int value) {
>    Message value_message;
>    value_message << value;
>    RecordProperty(key, value_message.GetString().c_str());
> @@ -1930,7 +1924,7 @@ void Test::RecordProperty(const char* key, int value) {
>  namespace internal {
>  
>  void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
> -                                    const String& message) {
> +                                    const std::string& message) {
>    // This function is a friend of UnitTest and as such has access to
>    // AddTestPartResult.
>    UnitTest::GetInstance()->AddTestPartResult(
> @@ -1938,7 +1932,7 @@ void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
>        NULL,  // No info about the source file where the exception occurred.
>        -1,    // We have no info on which line caused the exception.
>        message,
> -      String());  // No stack trace, either.
> +      "");   // No stack trace, either.
>  }
>  
>  }  // namespace internal
> @@ -2015,22 +2009,24 @@ bool Test::HasSameFixtureClass() {
>  // function returns its result via an output parameter pointer because VC++
>  // prohibits creation of objects with destructors on stack in functions
>  // using __try (see error C2712).
> -static internal::String* FormatSehExceptionMessage(DWORD exception_code,
> -                                                   const char* location) {
> +static std::string* FormatSehExceptionMessage(DWORD exception_code,
> +                                              const char* location) {
>    Message message;
>    message << "SEH exception with code 0x" << std::setbase(16) <<
>      exception_code << std::setbase(10) << " thrown in " << location << ".";
>  
> -  return new internal::String(message.GetString());
> +  return new std::string(message.GetString());
>  }
>  
>  #endif  // GTEST_HAS_SEH
>  
> +namespace internal {
> +
>  #if GTEST_HAS_EXCEPTIONS
>  
>  // Adds an "exception thrown" fatal failure to the current test.
> -static internal::String FormatCxxExceptionMessage(const char* description,
> -                                                  const char* location) {
> +static std::string FormatCxxExceptionMessage(const char* description,
> +                                             const char* location) {
>    Message message;
>    if (description != NULL) {
>      message << "C++ exception with description \"" << description << "\"";
> @@ -2042,23 +2038,15 @@ static internal::String FormatCxxExceptionMessage(const char* description,
>    return message.GetString();
>  }
>  
> -static internal::String PrintTestPartResultToString(
> +static std::string PrintTestPartResultToString(
>      const TestPartResult& test_part_result);
>  
> -// A failed Google Test assertion will throw an exception of this type when
> -// GTEST_FLAG(throw_on_failure) is true (if exceptions are enabled).  We
> -// derive it from std::runtime_error, which is for errors presumably
> -// detectable only at run time.  Since std::runtime_error inherits from
> -// std::exception, many testing frameworks know how to extract and print the
> -// message inside it.
> -class GoogleTestFailureException : public ::std::runtime_error {
> - public:
> -  explicit GoogleTestFailureException(const TestPartResult& failure)
> -      : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
> -};
> +GoogleTestFailureException::GoogleTestFailureException(
> +    const TestPartResult& failure)
> +    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
> +
>  #endif  // GTEST_HAS_EXCEPTIONS
>  
> -namespace internal {
>  // We put these helper functions in the internal namespace as IBM's xlC
>  // compiler rejects the code if they were declared static.
>  
> @@ -2078,7 +2066,7 @@ Result HandleSehExceptionsInMethodIfSupported(
>      // We create the exception message on the heap because VC++ prohibits
>      // creation of objects with destructors on stack in functions using __try
>      // (see error C2712).
> -    internal::String* exception_message = FormatSehExceptionMessage(
> +    std::string* exception_message = FormatSehExceptionMessage(
>          GetExceptionCode(), location);
>      internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
>                                               *exception_message);
> @@ -2124,9 +2112,10 @@ Result HandleExceptionsInMethodIfSupported(
>  #if GTEST_HAS_EXCEPTIONS
>      try {
>        return HandleSehExceptionsInMethodIfSupported(object, method, location);
> -    } catch (const GoogleTestFailureException&) {  // NOLINT
> -      // This exception doesn't originate in code under test. It makes no
> -      // sense to report it as a test failure.
> +    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
> +      // This exception type can only be thrown by a failed Google
> +      // Test assertion with the intention of letting another testing
> +      // framework catch it.  Therefore we just re-throw it.
>        throw;
>      } catch (const std::exception& e) {  // NOLINT
>        internal::ReportFailureInUnknownLocation(
> @@ -2185,10 +2174,8 @@ bool Test::HasNonfatalFailure() {
>  
>  // Constructs a TestInfo object. It assumes ownership of the test factory
>  // object.
> -// TODO(vladl@google.com): Make a_test_case_name and a_name const string&'s
> -// to signify they cannot be NULLs.
> -TestInfo::TestInfo(const char* a_test_case_name,
> -                   const char* a_name,
> +TestInfo::TestInfo(const std::string& a_test_case_name,
> +                   const std::string& a_name,
>                     const char* a_type_param,
>                     const char* a_value_param,
>                     internal::TypeId fixture_class_id,
> @@ -2227,7 +2214,8 @@ namespace internal {
>  //                     The newly created TestInfo instance will assume
>  //                     ownership of the factory object.
>  TestInfo* MakeAndRegisterTestInfo(
> -    const char* test_case_name, const char* name,
> +    const char* test_case_name,
> +    const char* name,
>      const char* type_param,
>      const char* value_param,
>      TypeId fixture_class_id,
> @@ -2282,11 +2270,11 @@ class TestNameIs {
>  
>    // Returns true iff the test name of test_info matches name_.
>    bool operator()(const TestInfo * test_info) const {
> -    return test_info && internal::String(test_info->name()).Compare(name_) == 0;
> +    return test_info && test_info->name() == name_;
>    }
>  
>   private:
> -  internal::String name_;
> +  std::string name_;
>  };
>  
>  }  // namespace
> @@ -2365,10 +2353,21 @@ int TestCase::failed_test_count() const {
>    return CountIf(test_info_list_, TestFailed);
>  }
>  
> +// Gets the number of disabled tests that will be reported in the XML report.
> +int TestCase::reportable_disabled_test_count() const {
> +  return CountIf(test_info_list_, TestReportableDisabled);
> +}
> +
> +// Gets the number of disabled tests in this test case.
>  int TestCase::disabled_test_count() const {
>    return CountIf(test_info_list_, TestDisabled);
>  }
>  
> +// Gets the number of tests to be printed in the XML report.
> +int TestCase::reportable_test_count() const {
> +  return CountIf(test_info_list_, TestReportable);
> +}
> +
>  // Get the number of tests in this test case that should run.
>  int TestCase::test_to_run_count() const {
>    return CountIf(test_info_list_, ShouldRunTest);
> @@ -2456,6 +2455,7 @@ void TestCase::Run() {
>  
>  // Clears the results of all tests in this test case.
>  void TestCase::ClearResult() {
> +  ad_hoc_test_result_.Clear();
>    ForEach(test_info_list_, TestInfo::ClearTestResult);
>  }
>  
> @@ -2476,20 +2476,20 @@ void TestCase::UnshuffleTests() {
>  //
>  // FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
>  // FormatCountableNoun(5, "book", "books") returns "5 books".
> -static internal::String FormatCountableNoun(int count,
> -                                            const char * singular_form,
> -                                            const char * plural_form) {
> -  return internal::String::Format("%d %s", count,
> -                                  count == 1 ? singular_form : plural_form);
> +static std::string FormatCountableNoun(int count,
> +                                       const char * singular_form,
> +                                       const char * plural_form) {
> +  return internal::StreamableToString(count) + " " +
> +      (count == 1 ? singular_form : plural_form);
>  }
>  
>  // Formats the count of tests.
> -static internal::String FormatTestCount(int test_count) {
> +static std::string FormatTestCount(int test_count) {
>    return FormatCountableNoun(test_count, "test", "tests");
>  }
>  
>  // Formats the count of test cases.
> -static internal::String FormatTestCaseCount(int test_case_count) {
> +static std::string FormatTestCaseCount(int test_case_count) {
>    return FormatCountableNoun(test_case_count, "test case", "test cases");
>  }
>  
> @@ -2514,8 +2514,10 @@ static const char * TestPartResultTypeToString(TestPartResult::Type type) {
>    }
>  }
>  
> -// Prints a TestPartResult to a String.
> -static internal::String PrintTestPartResultToString(
> +namespace internal {
> +
> +// Prints a TestPartResult to an std::string.
> +static std::string PrintTestPartResultToString(
>      const TestPartResult& test_part_result) {
>    return (Message()
>            << internal::FormatFileLocation(test_part_result.file_name(),
> @@ -2526,7 +2528,7 @@ static internal::String PrintTestPartResultToString(
>  
>  // Prints a TestPartResult.
>  static void PrintTestPartResult(const TestPartResult& test_part_result) {
> -  const internal::String& result =
> +  const std::string& result =
>        PrintTestPartResultToString(test_part_result);
>    printf("%s\n", result.c_str());
>    fflush(stdout);
> @@ -2545,8 +2547,6 @@ static void PrintTestPartResult(const TestPartResult& test_part_result) {
>  
>  // class PrettyUnitTestResultPrinter
>  
> -namespace internal {
> -
>  enum GTestColor {
>    COLOR_DEFAULT,
>    COLOR_RED,
> @@ -2598,6 +2598,7 @@ bool ShouldUseColor(bool stdout_is_tty) {
>          String::CStringEquals(term, "xterm-color") ||
>          String::CStringEquals(term, "xterm-256color") ||
>          String::CStringEquals(term, "screen") ||
> +        String::CStringEquals(term, "screen-256color") ||
>          String::CStringEquals(term, "linux") ||
>          String::CStringEquals(term, "cygwin");
>      return stdout_is_tty && term_supports_color;
> @@ -2621,7 +2622,7 @@ void ColoredPrintf(GTestColor color, const char* fmt, ...) {
>    va_list args;
>    va_start(args, fmt);
>  
> -#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
> +#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || GTEST_OS_IOS
>    const bool use_color = false;
>  #else
>    static const bool in_color_mode =
> @@ -2663,6 +2664,11 @@ void ColoredPrintf(GTestColor color, const char* fmt, ...) {
>    va_end(args);
>  }
>  
> +// Text printed in Google Test's text output and --gunit_list_tests
> +// output to label the type parameter and value parameter for a test.
> +static const char kTypeParamLabel[] = "TypeParam";
> +static const char kValueParamLabel[] = "GetParam()";
> +
>  void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
>    const char* const type_param = test_info.type_param();
>    const char* const value_param = test_info.value_param();
> @@ -2670,12 +2676,12 @@ void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
>    if (type_param != NULL || value_param != NULL) {
>      printf(", where ");
>      if (type_param != NULL) {
> -      printf("TypeParam = %s", type_param);
> +      printf("%s = %s", kTypeParamLabel, type_param);
>        if (value_param != NULL)
>          printf(" and ");
>      }
>      if (value_param != NULL) {
> -      printf("GetParam() = %s", value_param);
> +      printf("%s = %s", kValueParamLabel, value_param);
>      }
>    }
>  }
> @@ -2707,8 +2713,6 @@ class PrettyUnitTestResultPrinter : public TestEventListener {
>  
>   private:
>    static void PrintFailedTests(const UnitTest& unit_test);
> -
> -  internal::String test_case_name_;
>  };
>  
>    // Fired before each iteration of tests starts.
> @@ -2721,7 +2725,7 @@ void PrettyUnitTestResultPrinter::OnTestIterationStart(
>  
>    // Prints the filter if it's not *.  This reminds the user that some
>    // tests may be skipped.
> -  if (!internal::String::CStringEquals(filter, kUniversalFilter)) {
> +  if (!String::CStringEquals(filter, kUniversalFilter)) {
>      ColoredPrintf(COLOR_YELLOW,
>                    "Note: %s filter = %s\n", GTEST_NAME_, filter);
>    }
> @@ -2755,22 +2759,21 @@ void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
>  }
>  
>  void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
> -  test_case_name_ = test_case.name();
> -  const internal::String counts =
> +  const std::string counts =
>        FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
>    ColoredPrintf(COLOR_GREEN, "[----------] ");
> -  printf("%s from %s", counts.c_str(), test_case_name_.c_str());
> +  printf("%s from %s", counts.c_str(), test_case.name());
>    if (test_case.type_param() == NULL) {
>      printf("\n");
>    } else {
> -    printf(", where TypeParam = %s\n", test_case.type_param());
> +    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
>    }
>    fflush(stdout);
>  }
>  
>  void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
>    ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
> -  PrintTestName(test_case_name_.c_str(), test_info.name());
> +  PrintTestName(test_info.test_case_name(), test_info.name());
>    printf("\n");
>    fflush(stdout);
>  }
> @@ -2793,7 +2796,7 @@ void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
>    } else {
>      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
>    }
> -  PrintTestName(test_case_name_.c_str(), test_info.name());
> +  PrintTestName(test_info.test_case_name(), test_info.name());
>    if (test_info.result()->Failed())
>      PrintFullTestCommentIfPresent(test_info);
>  
> @@ -2809,12 +2812,11 @@ void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
>  void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
>    if (!GTEST_FLAG(print_time)) return;
>  
> -  test_case_name_ = test_case.name();
> -  const internal::String counts =
> +  const std::string counts =
>        FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
>    ColoredPrintf(COLOR_GREEN, "[----------] ");
>    printf("%s from %s (%s ms total)\n\n",
> -         counts.c_str(), test_case_name_.c_str(),
> +         counts.c_str(), test_case.name(),
>           internal::StreamableToString(test_case.elapsed_time()).c_str());
>    fflush(stdout);
>  }
> @@ -2875,7 +2877,7 @@ void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
>                          num_failures == 1 ? "TEST" : "TESTS");
>    }
>  
> -  int num_disabled = unit_test.disabled_test_count();
> +  int num_disabled = unit_test.reportable_disabled_test_count();
>    if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
>      if (!num_failures) {
>        printf("\n");  // Add a spacer if no FAILURE banner is displayed.
> @@ -3029,18 +3031,27 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
>    // is_attribute is true, the text is meant to appear as an attribute
>    // value, and normalizable whitespace is preserved by replacing it
>    // with character references.
> -  static String EscapeXml(const char* str, bool is_attribute);
> +  static std::string EscapeXml(const std::string& str, bool is_attribute);
>  
>    // Returns the given string with all characters invalid in XML removed.
> -  static string RemoveInvalidXmlCharacters(const string& str);
> +  static std::string RemoveInvalidXmlCharacters(const std::string& str);
>  
>    // Convenience wrapper around EscapeXml when str is an attribute value.
> -  static String EscapeXmlAttribute(const char* str) {
> +  static std::string EscapeXmlAttribute(const std::string& str) {
>      return EscapeXml(str, true);
>    }
>  
>    // Convenience wrapper around EscapeXml when str is not an attribute value.
> -  static String EscapeXmlText(const char* str) { return EscapeXml(str, false); }
> +  static std::string EscapeXmlText(const char* str) {
> +    return EscapeXml(str, false);
> +  }
> +
> +  // Verifies that the given attribute belongs to the given element and
> +  // streams the attribute as XML.
> +  static void OutputXmlAttribute(std::ostream* stream,
> +                                 const std::string& element_name,
> +                                 const std::string& name,
> +                                 const std::string& value);
>  
>    // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
>    static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
> @@ -3051,19 +3062,21 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
>                                  const TestInfo& test_info);
>  
>    // Prints an XML representation of a TestCase object
> -  static void PrintXmlTestCase(FILE* out, const TestCase& test_case);
> +  static void PrintXmlTestCase(::std::ostream* stream,
> +                               const TestCase& test_case);
>  
>    // Prints an XML summary of unit_test to output stream out.
> -  static void PrintXmlUnitTest(FILE* out, const UnitTest& unit_test);
> +  static void PrintXmlUnitTest(::std::ostream* stream,
> +                               const UnitTest& unit_test);
>  
>    // Produces a string representing the test properties in a result as space
>    // delimited XML attributes based on the property key="value" pairs.
> -  // When the String is not empty, it includes a space at the beginning,
> +  // When the std::string is not empty, it includes a space at the beginning,
>    // to delimit this attribute from prior attributes.
> -  static String TestPropertiesAsXmlAttributes(const TestResult& result);
> +  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
>  
>    // The output file.
> -  const String output_file_;
> +  const std::string output_file_;
>  
>    GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
>  };
> @@ -3105,7 +3118,9 @@ void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
>      fflush(stderr);
>      exit(EXIT_FAILURE);
>    }
> -  PrintXmlUnitTest(xmlout, unit_test);
> +  std::stringstream stream;
> +  PrintXmlUnitTest(&stream, unit_test);
> +  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
>    fclose(xmlout);
>  }
>  
> @@ -3121,42 +3136,43 @@ void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
>  // most invalid characters can be retained using character references.
>  // TODO(wan): It might be nice to have a minimally invasive, human-readable
>  // escaping scheme for invalid characters, rather than dropping them.
> -String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_attribute) {
> +std::string XmlUnitTestResultPrinter::EscapeXml(
> +    const std::string& str, bool is_attribute) {
>    Message m;
>  
> -  if (str != NULL) {
> -    for (const char* src = str; *src; ++src) {
> -      switch (*src) {
> -        case '<':
> -          m << "&lt;";
> -          break;
> -        case '>':
> -          m << "&gt;";
> -          break;
> -        case '&':
> -          m << "&amp;";
> -          break;
> -        case '\'':
> -          if (is_attribute)
> -            m << "&apos;";
> -          else
> -            m << '\'';
> -          break;
> -        case '"':
> -          if (is_attribute)
> -            m << "&quot;";
> +  for (size_t i = 0; i < str.size(); ++i) {
> +    const char ch = str[i];
> +    switch (ch) {
> +      case '<':
> +        m << "&lt;";
> +        break;
> +      case '>':
> +        m << "&gt;";
> +        break;
> +      case '&':
> +        m << "&amp;";
> +        break;
> +      case '\'':
> +        if (is_attribute)
> +          m << "&apos;";
> +        else
> +          m << '\'';
> +        break;
> +      case '"':
> +        if (is_attribute)
> +          m << "&quot;";
> +        else
> +          m << '"';
> +        break;
> +      default:
> +        if (IsValidXmlCharacter(ch)) {
> +          if (is_attribute && IsNormalizableWhitespace(ch))
> +            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
> +              << ";";
>            else
> -            m << '"';
> -          break;
> -        default:
> -          if (IsValidXmlCharacter(*src)) {
> -            if (is_attribute && IsNormalizableWhitespace(*src))
> -              m << String::Format("&#x%02X;", unsigned(*src));
> -            else
> -              m << *src;
> -          }
> -          break;
> -      }
> +            m << ch;
> +        }
> +        break;
>      }
>    }
>  
> @@ -3166,10 +3182,11 @@ String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_attribute) {
>  // Returns the given string with all characters invalid in XML removed.
>  // Currently invalid characters are dropped from the string. An
>  // alternative is to replace them with certain characters such as . or ?.
> -string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const string& str) {
> -  string output;
> +std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
> +    const std::string& str) {
> +  std::string output;
>    output.reserve(str.size());
> -  for (string::const_iterator it = str.begin(); it != str.end(); ++it)
> +  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
>      if (IsValidXmlCharacter(*it))
>        output.push_back(*it);
>  
> @@ -3199,6 +3216,32 @@ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
>    return ss.str();
>  }
>  
> +// Converts the given epoch time in milliseconds to a date string in the ISO
> +// 8601 format, without the timezone information.
> +std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
> +  // Using non-reentrant version as localtime_r is not portable.
> +  time_t seconds = static_cast<time_t>(ms / 1000);
> +#ifdef _MSC_VER
> +# pragma warning(push)          // Saves the current warning state.
> +# pragma warning(disable:4996)  // Temporarily disables warning 4996
> +                                // (function or variable may be unsafe).
> +  const struct tm* const time_struct = localtime(&seconds);  // NOLINT
> +# pragma warning(pop)           // Restores the warning state again.
> +#else
> +  const struct tm* const time_struct = localtime(&seconds);  // NOLINT
> +#endif
> +  if (time_struct == NULL)
> +    return "";  // Invalid ms value
> +
> +  // YYYY-MM-DDThh:mm:ss
> +  return StreamableToString(time_struct->tm_year + 1900) + "-" +
> +      String::FormatIntWidth2(time_struct->tm_mon + 1) + "-" +
> +      String::FormatIntWidth2(time_struct->tm_mday) + "T" +
> +      String::FormatIntWidth2(time_struct->tm_hour) + ":" +
> +      String::FormatIntWidth2(time_struct->tm_min) + ":" +
> +      String::FormatIntWidth2(time_struct->tm_sec);
> +}
> +
>  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
>  void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
>                                                       const char* data) {
> @@ -3219,45 +3262,63 @@ void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
>    *stream << "]]>";
>  }
>  
> +void XmlUnitTestResultPrinter::OutputXmlAttribute(
> +    std::ostream* stream,
> +    const std::string& element_name,
> +    const std::string& name,
> +    const std::string& value) {
> +  const std::vector<std::string>& allowed_names =
> +      GetReservedAttributesForElement(element_name);
> +
> +  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
> +                   allowed_names.end())
> +      << "Attribute " << name << " is not allowed for element <" << element_name
> +      << ">.";
> +
> +  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
> +}
> +
>  // Prints an XML representation of a TestInfo object.
>  // TODO(wan): There is also value in printing properties with the plain printer.
>  void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
>                                                   const char* test_case_name,
>                                                   const TestInfo& test_info) {
>    const TestResult& result = *test_info.result();
> -  *stream << "    <testcase name=\""
> -          << EscapeXmlAttribute(test_info.name()).c_str() << "\"";
> +  const std::string kTestcase = "testcase";
> +
> +  *stream << "    <testcase";
> +  OutputXmlAttribute(stream, kTestcase, "name", test_info.name());
>  
>    if (test_info.value_param() != NULL) {
> -    *stream << " value_param=\"" << EscapeXmlAttribute(test_info.value_param())
> -            << "\"";
> +    OutputXmlAttribute(stream, kTestcase, "value_param",
> +                       test_info.value_param());
>    }
>    if (test_info.type_param() != NULL) {
> -    *stream << " type_param=\"" << EscapeXmlAttribute(test_info.type_param())
> -            << "\"";
> +    OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param());
>    }
>  
> -  *stream << " status=\""
> -          << (test_info.should_run() ? "run" : "notrun")
> -          << "\" time=\""
> -          << FormatTimeInMillisAsSeconds(result.elapsed_time())
> -          << "\" classname=\"" << EscapeXmlAttribute(test_case_name).c_str()
> -          << "\"" << TestPropertiesAsXmlAttributes(result).c_str();
> +  OutputXmlAttribute(stream, kTestcase, "status",
> +                     test_info.should_run() ? "run" : "notrun");
> +  OutputXmlAttribute(stream, kTestcase, "time",
> +                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
> +  OutputXmlAttribute(stream, kTestcase, "classname", test_case_name);
> +  *stream << TestPropertiesAsXmlAttributes(result);
>  
>    int failures = 0;
>    for (int i = 0; i < result.total_part_count(); ++i) {
>      const TestPartResult& part = result.GetTestPartResult(i);
>      if (part.failed()) {
> -      if (++failures == 1)
> +      if (++failures == 1) {
>          *stream << ">\n";
> -      *stream << "      <failure message=\""
> -              << EscapeXmlAttribute(part.summary()).c_str()
> -              << "\" type=\"\">";
> +      }
>        const string location = internal::FormatCompilerIndependentFileLocation(
>            part.file_name(), part.line_number());
> -      const string message = location + "\n" + part.message();
> -      OutputXmlCDataSection(stream,
> -                            RemoveInvalidXmlCharacters(message).c_str());
> +      const string summary = location + "\n" + part.summary();
> +      *stream << "      <failure message=\""
> +              << EscapeXmlAttribute(summary.c_str())
> +              << "\" type=\"\">";
> +      const string detail = location + "\n" + part.message();
> +      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
>        *stream << "</failure>\n";
>      }
>    }
> @@ -3269,49 +3330,73 @@ void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
>  }
>  
>  // Prints an XML representation of a TestCase object
> -void XmlUnitTestResultPrinter::PrintXmlTestCase(FILE* out,
> +void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
>                                                  const TestCase& test_case) {
> -  fprintf(out,
> -          "  <testsuite name=\"%s\" tests=\"%d\" failures=\"%d\" "
> -          "disabled=\"%d\" ",
> -          EscapeXmlAttribute(test_case.name()).c_str(),
> -          test_case.total_test_count(),
> -          test_case.failed_test_count(),
> -          test_case.disabled_test_count());
> -  fprintf(out,
> -          "errors=\"0\" time=\"%s\">\n",
> -          FormatTimeInMillisAsSeconds(test_case.elapsed_time()).c_str());
> +  const std::string kTestsuite = "testsuite";
> +  *stream << "  <" << kTestsuite;
> +  OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
> +  OutputXmlAttribute(stream, kTestsuite, "tests",
> +                     StreamableToString(test_case.reportable_test_count()));
> +  OutputXmlAttribute(stream, kTestsuite, "failures",
> +                     StreamableToString(test_case.failed_test_count()));
> +  OutputXmlAttribute(
> +      stream, kTestsuite, "disabled",
> +      StreamableToString(test_case.reportable_disabled_test_count()));
> +  OutputXmlAttribute(stream, kTestsuite, "errors", "0");
> +  OutputXmlAttribute(stream, kTestsuite, "time",
> +                     FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
> +  *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result())
> +          << ">\n";
> +
>    for (int i = 0; i < test_case.total_test_count(); ++i) {
> -    ::std::stringstream stream;
> -    OutputXmlTestInfo(&stream, test_case.name(), *test_case.GetTestInfo(i));
> -    fprintf(out, "%s", StringStreamToString(&stream).c_str());
> +    if (test_case.GetTestInfo(i)->is_reportable())
> +      OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i));
>    }
> -  fprintf(out, "  </testsuite>\n");
> +  *stream << "  </" << kTestsuite << ">\n";
>  }
>  
>  // Prints an XML summary of unit_test to output stream out.
> -void XmlUnitTestResultPrinter::PrintXmlUnitTest(FILE* out,
> +void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
>                                                  const UnitTest& unit_test) {
> -  fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
> -  fprintf(out,
> -          "<testsuites tests=\"%d\" failures=\"%d\" disabled=\"%d\" "
> -          "errors=\"0\" time=\"%s\" ",
> -          unit_test.total_test_count(),
> -          unit_test.failed_test_count(),
> -          unit_test.disabled_test_count(),
> -          FormatTimeInMillisAsSeconds(unit_test.elapsed_time()).c_str());
> +  const std::string kTestsuites = "testsuites";
> +
> +  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
> +  *stream << "<" << kTestsuites;
> +
> +  OutputXmlAttribute(stream, kTestsuites, "tests",
> +                     StreamableToString(unit_test.reportable_test_count()));
> +  OutputXmlAttribute(stream, kTestsuites, "failures",
> +                     StreamableToString(unit_test.failed_test_count()));
> +  OutputXmlAttribute(
> +      stream, kTestsuites, "disabled",
> +      StreamableToString(unit_test.reportable_disabled_test_count()));
> +  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
> +  OutputXmlAttribute(
> +      stream, kTestsuites, "timestamp",
> +      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
> +  OutputXmlAttribute(stream, kTestsuites, "time",
> +                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
> +
>    if (GTEST_FLAG(shuffle)) {
> -    fprintf(out, "random_seed=\"%d\" ", unit_test.random_seed());
> +    OutputXmlAttribute(stream, kTestsuites, "random_seed",
> +                       StreamableToString(unit_test.random_seed()));
> +  }
> +
> +  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
> +
> +  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
> +  *stream << ">\n";
> +
> +  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
> +    if (unit_test.GetTestCase(i)->reportable_test_count() > 0)
> +      PrintXmlTestCase(stream, *unit_test.GetTestCase(i));
>    }
> -  fprintf(out, "name=\"AllTests\">\n");
> -  for (int i = 0; i < unit_test.total_test_case_count(); ++i)
> -    PrintXmlTestCase(out, *unit_test.GetTestCase(i));
> -  fprintf(out, "</testsuites>\n");
> +  *stream << "</" << kTestsuites << ">\n";
>  }
>  
>  // Produces a string representing the test properties in a result as space
>  // delimited XML attributes based on the property key="value" pairs.
> -String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
> +std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
>      const TestResult& result) {
>    Message attributes;
>    for (int i = 0; i < result.test_property_count(); ++i) {
> @@ -3326,112 +3411,6 @@ String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
>  
>  #if GTEST_CAN_STREAM_RESULTS_
>  
> -// Streams test results to the given port on the given host machine.
> -class StreamingListener : public EmptyTestEventListener {
> - public:
> -  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
> -  static string UrlEncode(const char* str);
> -
> -  StreamingListener(const string& host, const string& port)
> -      : sockfd_(-1), host_name_(host), port_num_(port) {
> -    MakeConnection();
> -    Send("gtest_streaming_protocol_version=1.0\n");
> -  }
> -
> -  virtual ~StreamingListener() {
> -    if (sockfd_ != -1)
> -      CloseConnection();
> -  }
> -
> -  void OnTestProgramStart(const UnitTest& /* unit_test */) {
> -    Send("event=TestProgramStart\n");
> -  }
> -
> -  void OnTestProgramEnd(const UnitTest& unit_test) {
> -    // Note that Google Test current only report elapsed time for each
> -    // test iteration, not for the entire test program.
> -    Send(String::Format("event=TestProgramEnd&passed=%d\n",
> -                        unit_test.Passed()));
> -
> -    // Notify the streaming server to stop.
> -    CloseConnection();
> -  }
> -
> -  void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
> -    Send(String::Format("event=TestIterationStart&iteration=%d\n",
> -                        iteration));
> -  }
> -
> -  void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
> -    Send(String::Format("event=TestIterationEnd&passed=%d&elapsed_time=%sms\n",
> -                        unit_test.Passed(),
> -                        StreamableToString(unit_test.elapsed_time()).c_str()));
> -  }
> -
> -  void OnTestCaseStart(const TestCase& test_case) {
> -    Send(String::Format("event=TestCaseStart&name=%s\n", test_case.name()));
> -  }
> -
> -  void OnTestCaseEnd(const TestCase& test_case) {
> -    Send(String::Format("event=TestCaseEnd&passed=%d&elapsed_time=%sms\n",
> -                        test_case.Passed(),
> -                        StreamableToString(test_case.elapsed_time()).c_str()));
> -  }
> -
> -  void OnTestStart(const TestInfo& test_info) {
> -    Send(String::Format("event=TestStart&name=%s\n", test_info.name()));
> -  }
> -
> -  void OnTestEnd(const TestInfo& test_info) {
> -    Send(String::Format(
> -        "event=TestEnd&passed=%d&elapsed_time=%sms\n",
> -        (test_info.result())->Passed(),
> -        StreamableToString((test_info.result())->elapsed_time()).c_str()));
> -  }
> -
> -  void OnTestPartResult(const TestPartResult& test_part_result) {
> -    const char* file_name = test_part_result.file_name();
> -    if (file_name == NULL)
> -      file_name = "";
> -    Send(String::Format("event=TestPartResult&file=%s&line=%d&message=",
> -                        UrlEncode(file_name).c_str(),
> -                        test_part_result.line_number()));
> -    Send(UrlEncode(test_part_result.message()) + "\n");
> -  }
> -
> - private:
> -  // Creates a client socket and connects to the server.
> -  void MakeConnection();
> -
> -  // Closes the socket.
> -  void CloseConnection() {
> -    GTEST_CHECK_(sockfd_ != -1)
> -        << "CloseConnection() can be called only when there is a connection.";
> -
> -    close(sockfd_);
> -    sockfd_ = -1;
> -  }
> -
> -  // Sends a string to the socket.
> -  void Send(const string& message) {
> -    GTEST_CHECK_(sockfd_ != -1)
> -        << "Send() can be called only when there is a connection.";
> -
> -    const int len = static_cast<int>(message.length());
> -    if (write(sockfd_, message.c_str(), len) != len) {
> -      GTEST_LOG_(WARNING)
> -          << "stream_result_to: failed to stream to "
> -          << host_name_ << ":" << port_num_;
> -    }
> -  }
> -
> -  int sockfd_;   // socket file descriptor
> -  const string host_name_;
> -  const string port_num_;
> -
> -  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
> -};  // class StreamingListener
> -
>  // Checks if str contains '=', '&', '%' or '\n' characters. If yes,
>  // replaces them by "%xx" where xx is their hexadecimal value. For
>  // example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
> @@ -3446,7 +3425,7 @@ string StreamingListener::UrlEncode(const char* str) {
>        case '=':
>        case '&':
>        case '\n':
> -        result.append(String::Format("%%%02x", static_cast<unsigned char>(ch)));
> +        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
>          break;
>        default:
>          result.push_back(ch);
> @@ -3456,7 +3435,7 @@ string StreamingListener::UrlEncode(const char* str) {
>    return result;
>  }
>  
> -void StreamingListener::MakeConnection() {
> +void StreamingListener::SocketWriter::MakeConnection() {
>    GTEST_CHECK_(sockfd_ == -1)
>        << "MakeConnection() can't be called when there is already a connection.";
>  
> @@ -3504,8 +3483,8 @@ void StreamingListener::MakeConnection() {
>  
>  // Pushes the given source file location and message onto a per-thread
>  // trace stack maintained by Google Test.
> -// L < UnitTest::mutex_
> -ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) {
> +ScopedTrace::ScopedTrace(const char* file, int line, const Message& message)
> +    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
>    TraceInfo trace;
>    trace.file = file;
>    trace.line = line;
> @@ -3515,35 +3494,64 @@ ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) {
>  }
>  
>  // Pops the info pushed by the c'tor.
> -// L < UnitTest::mutex_
> -ScopedTrace::~ScopedTrace() {
> +ScopedTrace::~ScopedTrace()
> +    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
>    UnitTest::GetInstance()->PopGTestTrace();
>  }
>  
>  
>  // class OsStackTraceGetter
>  
> -// Returns the current OS stack trace as a String.  Parameters:
> +// Returns the current OS stack trace as an std::string.  Parameters:
>  //
>  //   max_depth  - the maximum number of stack frames to be included
>  //                in the trace.
>  //   skip_count - the number of top frames to be skipped; doesn't count
>  //                against max_depth.
>  //
> -// L < mutex_
> -// We use "L < mutex_" to denote that the function may acquire mutex_.
> -String OsStackTraceGetter::CurrentStackTrace(int, int) {
> -  return String("");
> +string OsStackTraceGetter::CurrentStackTrace(int /* max_depth */,
> +                                             int /* skip_count */)
> +    GTEST_LOCK_EXCLUDED_(mutex_) {
> +  return "";
>  }
>  
> -// L < mutex_
> -void OsStackTraceGetter::UponLeavingGTest() {
> +void OsStackTraceGetter::UponLeavingGTest()
> +    GTEST_LOCK_EXCLUDED_(mutex_) {
>  }
>  
>  const char* const
>  OsStackTraceGetter::kElidedFramesMarker =
>      "... " GTEST_NAME_ " internal frames ...";
>  
> +// A helper class that creates the premature-exit file in its
> +// constructor and deletes the file in its destructor.
> +class ScopedPrematureExitFile {
> + public:
> +  explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
> +      : premature_exit_filepath_(premature_exit_filepath) {
> +    // If a path to the premature-exit file is specified...
> +    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
> +      // create the file with a single "0" character in it.  I/O
> +      // errors are ignored as there's nothing better we can do and we
> +      // don't want to fail the test because of this.
> +      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
> +      fwrite("0", 1, 1, pfile);
> +      fclose(pfile);
> +    }
> +  }
> +
> +  ~ScopedPrematureExitFile() {
> +    if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') {
> +      remove(premature_exit_filepath_);
> +    }
> +  }
> +
> + private:
> +  const char* const premature_exit_filepath_;
> +
> +  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
> +};
> +
>  }  // namespace internal
>  
>  // class TestEventListeners
> @@ -3630,7 +3638,7 @@ void TestEventListeners::SuppressEventForwarding() {
>  // We don't protect this under mutex_ as a user is not supposed to
>  // call this before main() starts, from which point on the return
>  // value will never change.
> -UnitTest * UnitTest::GetInstance() {
> +UnitTest* UnitTest::GetInstance() {
>    // When compiled with MSVC 7.1 in optimized mode, destroying the
>    // UnitTest object upon exiting the program messes up the exit code,
>    // causing successful tests to appear failed.  We have to use a
> @@ -3680,17 +3688,33 @@ int UnitTest::successful_test_count() const {
>  // Gets the number of failed tests.
>  int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
>  
> +// Gets the number of disabled tests that will be reported in the XML report.
> +int UnitTest::reportable_disabled_test_count() const {
> +  return impl()->reportable_disabled_test_count();
> +}
> +
>  // Gets the number of disabled tests.
>  int UnitTest::disabled_test_count() const {
>    return impl()->disabled_test_count();
>  }
>  
> +// Gets the number of tests to be printed in the XML report.
> +int UnitTest::reportable_test_count() const {
> +  return impl()->reportable_test_count();
> +}
> +
>  // Gets the number of all tests.
>  int UnitTest::total_test_count() const { return impl()->total_test_count(); }
>  
>  // Gets the number of tests that should run.
>  int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
>  
> +// Gets the time of the test program start, in ms from the start of the
> +// UNIX epoch.
> +internal::TimeInMillis UnitTest::start_timestamp() const {
> +    return impl()->start_timestamp();
> +}
> +
>  // Gets the elapsed time, in milliseconds.
>  internal::TimeInMillis UnitTest::elapsed_time() const {
>    return impl()->elapsed_time();
> @@ -3709,6 +3733,12 @@ const TestCase* UnitTest::GetTestCase(int i) const {
>    return impl()->GetTestCase(i);
>  }
>  
> +// Returns the TestResult containing information on test failures and
> +// properties logged outside of individual test cases.
> +const TestResult& UnitTest::ad_hoc_test_result() const {
> +  return *impl()->ad_hoc_test_result();
> +}
> +
>  // Gets the i-th test case among all the test cases. i can range from 0 to
>  // total_test_case_count() - 1. If i is not in that range, returns NULL.
>  TestCase* UnitTest::GetMutableTestCase(int i) {
> @@ -3744,12 +3774,12 @@ Environment* UnitTest::AddEnvironment(Environment* env) {
>  // assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
>  // this to report their results.  The user code should use the
>  // assertion macros instead of calling this directly.
> -// L < mutex_
> -void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
> -                                 const char* file_name,
> -                                 int line_number,
> -                                 const internal::String& message,
> -                                 const internal::String& os_stack_trace) {
> +void UnitTest::AddTestPartResult(
> +    TestPartResult::Type result_type,
> +    const char* file_name,
> +    int line_number,
> +    const std::string& message,
> +    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
>    Message msg;
>    msg << message;
>  
> @@ -3796,7 +3826,7 @@ void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
>  #endif  // GTEST_OS_WINDOWS
>      } else if (GTEST_FLAG(throw_on_failure)) {
>  #if GTEST_HAS_EXCEPTIONS
> -      throw GoogleTestFailureException(result);
> +      throw internal::GoogleTestFailureException(result);
>  #else
>        // We cannot call abort() as it generates a pop-up in debug mode
>        // that cannot be suppressed in VC 7.1 or below.
> @@ -3806,12 +3836,14 @@ void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
>    }
>  }
>  
> -// Creates and adds a property to the current TestResult. If a property matching
> -// the supplied value already exists, updates its value instead.
> -void UnitTest::RecordPropertyForCurrentTest(const char* key,
> -                                            const char* value) {
> -  const TestProperty test_property(key, value);
> -  impl_->current_test_result()->RecordProperty(test_property);
> +// Adds a TestProperty to the current TestResult object when invoked from
> +// inside a test, to current TestCase's ad_hoc_test_result_ when invoked
> +// from SetUpTestCase or TearDownTestCase, or to the global property set
> +// when invoked elsewhere.  If the result already contains a property with
> +// the same key, the value will be updated.
> +void UnitTest::RecordProperty(const std::string& key,
> +                              const std::string& value) {
> +  impl_->RecordProperty(TestProperty(key, value));
>  }
>  
>  // Runs all tests in this UnitTest object and prints the result.
> @@ -3820,20 +3852,44 @@ void UnitTest::RecordPropertyForCurrentTest(const char* key,
>  // We don't protect this under mutex_, as we only support calling it
>  // from the main thread.
>  int UnitTest::Run() {
> +  const bool in_death_test_child_process =
> +      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
> +
> +  // Google Test implements this protocol for catching that a test
> +  // program exits before returning control to Google Test:
> +  //
> +  //   1. Upon start, Google Test creates a file whose absolute path
> +  //      is specified by the environment variable
> +  //      TEST_PREMATURE_EXIT_FILE.
> +  //   2. When Google Test has finished its work, it deletes the file.
> +  //
> +  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
> +  // running a Google-Test-based test program and check the existence
> +  // of the file at the end of the test execution to see if it has
> +  // exited prematurely.
> +
> +  // If we are in the child process of a death test, don't
> +  // create/delete the premature exit file, as doing so is unnecessary
> +  // and will confuse the parent process.  Otherwise, create/delete
> +  // the file upon entering/leaving this function.  If the program
> +  // somehow exits before this function has a chance to return, the
> +  // premature-exit file will be left undeleted, causing a test runner
> +  // that understands the premature-exit-file protocol to report the
> +  // test as having failed.
> +  const internal::ScopedPrematureExitFile premature_exit_file(
> +      in_death_test_child_process ?
> +      NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
> +
>    // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
>    // used for the duration of the program.
>    impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
>  
>  #if GTEST_HAS_SEH
> -  const bool in_death_test_child_process =
> -      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
> -
>    // Either the user wants Google Test to catch exceptions thrown by the
>    // tests or this is executing in the context of death test child
>    // process. In either case the user does not want to see pop-up dialogs
>    // about crashes - they are expected.
>    if (impl()->catch_exceptions() || in_death_test_child_process) {
> -
>  # if !GTEST_OS_WINDOWS_MOBILE
>      // SetErrorMode doesn't exist on CE.
>      SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
> @@ -3864,7 +3920,6 @@ int UnitTest::Run() {
>            0x0,                                    // Clear the following flags:
>            _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
>  # endif
> -
>    }
>  #endif  // GTEST_HAS_SEH
>  
> @@ -3882,16 +3937,16 @@ const char* UnitTest::original_working_dir() const {
>  
>  // Returns the TestCase object for the test that's currently running,
>  // or NULL if no test is running.
> -// L < mutex_
> -const TestCase* UnitTest::current_test_case() const {
> +const TestCase* UnitTest::current_test_case() const
> +    GTEST_LOCK_EXCLUDED_(mutex_) {
>    internal::MutexLock lock(&mutex_);
>    return impl_->current_test_case();
>  }
>  
>  // Returns the TestInfo object for the test that's currently running,
>  // or NULL if no test is running.
> -// L < mutex_
> -const TestInfo* UnitTest::current_test_info() const {
> +const TestInfo* UnitTest::current_test_info() const
> +    GTEST_LOCK_EXCLUDED_(mutex_) {
>    internal::MutexLock lock(&mutex_);
>    return impl_->current_test_info();
>  }
> @@ -3902,9 +3957,9 @@ int UnitTest::random_seed() const { return impl_->random_seed(); }
>  #if GTEST_HAS_PARAM_TEST
>  // Returns ParameterizedTestCaseRegistry object used to keep track of
>  // value-parameterized tests and instantiate and register them.
> -// L < mutex_
>  internal::ParameterizedTestCaseRegistry&
> -    UnitTest::parameterized_test_registry() {
> +    UnitTest::parameterized_test_registry()
> +        GTEST_LOCK_EXCLUDED_(mutex_) {
>    return impl_->parameterized_test_registry();
>  }
>  #endif  // GTEST_HAS_PARAM_TEST
> @@ -3921,15 +3976,15 @@ UnitTest::~UnitTest() {
>  
>  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
>  // Google Test trace stack.
> -// L < mutex_
> -void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) {
> +void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
> +    GTEST_LOCK_EXCLUDED_(mutex_) {
>    internal::MutexLock lock(&mutex_);
>    impl_->gtest_trace_stack().push_back(trace);
>  }
>  
>  // Pops a trace from the per-thread Google Test trace stack.
> -// L < mutex_
> -void UnitTest::PopGTestTrace() {
> +void UnitTest::PopGTestTrace()
> +    GTEST_LOCK_EXCLUDED_(mutex_) {
>    internal::MutexLock lock(&mutex_);
>    impl_->gtest_trace_stack().pop_back();
>  }
> @@ -3965,9 +4020,9 @@ UnitTestImpl::UnitTestImpl(UnitTest* parent)
>        post_flag_parse_init_performed_(false),
>        random_seed_(0),  // Will be overridden by the flag before first use.
>        random_(0),  // Will be reseeded before first use.
> +      start_timestamp_(0),
>        elapsed_time_(0),
>  #if GTEST_HAS_DEATH_TEST
> -      internal_run_death_test_flag_(NULL),
>        death_test_factory_(new DefaultDeathTestFactory),
>  #endif
>        // Will be overridden by the flag before first use.
> @@ -3985,6 +4040,28 @@ UnitTestImpl::~UnitTestImpl() {
>    delete os_stack_trace_getter_;
>  }
>  
> +// Adds a TestProperty to the current TestResult object when invoked in a
> +// context of a test, to current test case's ad_hoc_test_result when invoke
> +// from SetUpTestCase/TearDownTestCase, or to the global property set
> +// otherwise.  If the result already contains a property with the same key,
> +// the value will be updated.
> +void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
> +  std::string xml_element;
> +  TestResult* test_result;  // TestResult appropriate for property recording.
> +
> +  if (current_test_info_ != NULL) {
> +    xml_element = "testcase";
> +    test_result = &(current_test_info_->result_);
> +  } else if (current_test_case_ != NULL) {
> +    xml_element = "testsuite";
> +    test_result = &(current_test_case_->ad_hoc_test_result_);
> +  } else {
> +    xml_element = "testsuites";
> +    test_result = &ad_hoc_test_result_;
> +  }
> +  test_result->RecordProperty(xml_element, test_property);
> +}
> +
>  #if GTEST_HAS_DEATH_TEST
>  // Disables event forwarding if the control is currently in a death test
>  // subprocess. Must not be called before InitGoogleTest.
> @@ -3997,7 +4074,7 @@ void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
>  // Initializes event listeners performing XML output as specified by
>  // UnitTestOptions. Must not be called before InitGoogleTest.
>  void UnitTestImpl::ConfigureXmlOutput() {
> -  const String& output_format = UnitTestOptions::GetOutputFormat();
> +  const std::string& output_format = UnitTestOptions::GetOutputFormat();
>    if (output_format == "xml") {
>      listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
>          UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
> @@ -4009,13 +4086,13 @@ void UnitTestImpl::ConfigureXmlOutput() {
>  }
>  
>  #if GTEST_CAN_STREAM_RESULTS_
> -// Initializes event listeners for streaming test results in String form.
> +// Initializes event listeners for streaming test results in string form.
>  // Must not be called before InitGoogleTest.
>  void UnitTestImpl::ConfigureStreamingOutput() {
> -  const string& target = GTEST_FLAG(stream_result_to);
> +  const std::string& target = GTEST_FLAG(stream_result_to);
>    if (!target.empty()) {
>      const size_t pos = target.find(':');
> -    if (pos != string::npos) {
> +    if (pos != std::string::npos) {
>        listeners()->Append(new StreamingListener(target.substr(0, pos),
>                                                  target.substr(pos+1)));
>      } else {
> @@ -4069,7 +4146,7 @@ void UnitTestImpl::PostFlagParsingInit() {
>  class TestCaseNameIs {
>   public:
>    // Constructor.
> -  explicit TestCaseNameIs(const String& name)
> +  explicit TestCaseNameIs(const std::string& name)
>        : name_(name) {}
>  
>    // Returns true iff the name of test_case matches name_.
> @@ -4078,7 +4155,7 @@ class TestCaseNameIs {
>    }
>  
>   private:
> -  String name_;
> +  std::string name_;
>  };
>  
>  // Finds and returns a TestCase with the given name.  If one doesn't
> @@ -4110,7 +4187,7 @@ TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
>        new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
>  
>    // Is this a death test case?
> -  if (internal::UnitTestOptions::MatchesFilter(String(test_case_name),
> +  if (internal::UnitTestOptions::MatchesFilter(test_case_name,
>                                                 kDeathTestCaseFilter)) {
>      // Yes.  Inserts the test case after the last death test case
>      // defined so far.  This only works when the test cases haven't
> @@ -4196,6 +4273,7 @@ bool UnitTestImpl::RunAllTests() {
>  
>    TestEventListener* repeater = listeners()->repeater();
>  
> +  start_timestamp_ = GetTimeInMillis();
>    repeater->OnTestProgramStart(*parent_);
>  
>    // How many times to repeat the tests?  We don't want to repeat them
> @@ -4388,12 +4466,12 @@ int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
>    int num_selected_tests = 0;
>    for (size_t i = 0; i < test_cases_.size(); i++) {
>      TestCase* const test_case = test_cases_[i];
> -    const String &test_case_name = test_case->name();
> +    const std::string &test_case_name = test_case->name();
>      test_case->set_should_run(false);
>  
>      for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
>        TestInfo* const test_info = test_case->test_info_list()[j];
> -      const String test_name(test_info->name());
> +      const std::string test_name(test_info->name());
>        // A test is disabled if test case name or test name matches
>        // kDisableTestFilter.
>        const bool is_disabled =
> @@ -4427,8 +4505,33 @@ int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
>    return num_selected_tests;
>  }
>  
> +// Prints the given C-string on a single line by replacing all '\n'
> +// characters with string "\\n".  If the output takes more than
> +// max_length characters, only prints the first max_length characters
> +// and "...".
> +static void PrintOnOneLine(const char* str, int max_length) {
> +  if (str != NULL) {
> +    for (int i = 0; *str != '\0'; ++str) {
> +      if (i >= max_length) {
> +        printf("...");
> +        break;
> +      }
> +      if (*str == '\n') {
> +        printf("\\n");
> +        i += 2;
> +      } else {
> +        printf("%c", *str);
> +        ++i;
> +      }
> +    }
> +  }
> +}
> +
>  // Prints the names of the tests matching the user-specified filter flag.
>  void UnitTestImpl::ListTestsMatchingFilter() {
> +  // Print at most this many characters for each type/value parameter.
> +  const int kMaxParamLength = 250;
> +
>    for (size_t i = 0; i < test_cases_.size(); i++) {
>      const TestCase* const test_case = test_cases_[i];
>      bool printed_test_case_name = false;
> @@ -4439,9 +4542,23 @@ void UnitTestImpl::ListTestsMatchingFilter() {
>        if (test_info->matches_filter_) {
>          if (!printed_test_case_name) {
>            printed_test_case_name = true;
> -          printf("%s.\n", test_case->name());
> +          printf("%s.", test_case->name());
> +          if (test_case->type_param() != NULL) {
> +            printf("  # %s = ", kTypeParamLabel);
> +            // We print the type parameter on a single line to make
> +            // the output easy to parse by a program.
> +            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
> +          }
> +          printf("\n");
> +        }
> +        printf("  %s", test_info->name());
> +        if (test_info->value_param() != NULL) {
> +          printf("  # %s = ", kValueParamLabel);
> +          // We print the value parameter on a single line to make the
> +          // output easy to parse by a program.
> +          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
>          }
> -        printf("  %s\n", test_info->name());
> +        printf("\n");
>        }
>      }
>    }
> @@ -4505,7 +4622,7 @@ void UnitTestImpl::UnshuffleTests() {
>    }
>  }
>  
> -// Returns the current OS stack trace as a String.
> +// Returns the current OS stack trace as an std::string.
>  //
>  // The maximum number of stack frames to be included is specified by
>  // the gtest_stack_trace_depth flag.  The skip_count parameter
> @@ -4515,8 +4632,8 @@ void UnitTestImpl::UnshuffleTests() {
>  // For example, if Foo() calls Bar(), which in turn calls
>  // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
>  // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
> -String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
> -                                       int skip_count) {
> +std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
> +                                            int skip_count) {
>    // We pass skip_count + 1 to skip this wrapper function in addition
>    // to what the user really wants to skip.
>    return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
> @@ -4564,7 +4681,7 @@ const char* ParseFlagValue(const char* str,
>    if (str == NULL || flag == NULL) return NULL;
>  
>    // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
> -  const String flag_str = String::Format("--%s%s", GTEST_FLAG_PREFIX_, flag);
> +  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
>    const size_t flag_len = flag_str.length();
>    if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
>  
> @@ -4629,7 +4746,7 @@ bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
>  //
>  // On success, stores the value of the flag in *value, and returns
>  // true.  On failure, returns false without changing *value.
> -bool ParseStringFlag(const char* str, const char* flag, String* value) {
> +bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
>    // Gets the value of the flag as a string.
>    const char* const value_str = ParseFlagValue(str, flag, false);
>  
> @@ -4681,7 +4798,7 @@ static void PrintColorEncoded(const char* str) {
>        return;
>      }
>  
> -    ColoredPrintf(color, "%s", String(str, p - str).c_str());
> +    ColoredPrintf(color, "%s", std::string(str, p).c_str());
>  
>      const char ch = p[1];
>      str = p + 2;
> @@ -4771,7 +4888,7 @@ static const char kColorEncodedHelpMessage[] =
>  template <typename CharType>
>  void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
>    for (int i = 1; i < *argc; i++) {
> -    const String arg_string = StreamableToString(argv[i]);
> +    const std::string arg_string = StreamableToString(argv[i]);
>      const char* const arg = arg_string.c_str();
>  
>      using internal::ParseBoolFlag;
> diff --git a/src/gtest/src/gtest_main.cc b/src/gtest/src/gtest_main.cc
> index a09bbe0..f302822 100644
> --- a/src/gtest/src/gtest_main.cc
> +++ b/src/gtest/src/gtest_main.cc
> @@ -27,13 +27,12 @@
>  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  
> -#include <iostream>
> +#include <stdio.h>
>  
>  #include "gtest/gtest.h"
>  
>  GTEST_API_ int main(int argc, char **argv) {
> -  std::cout << "Running main() from gtest_main.cc\n";
> -
> +  printf("Running main() from gtest_main.cc\n");
>    testing::InitGoogleTest(&argc, argv);
>    return RUN_ALL_TESTS();
>  }
>