text: // Copyright 2005, Google Inc.
  // All rights reserved.
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are
  // met:
  //
  //     * Redistributions of source code must retain the above copyright
  // notice, this list of conditions and the following disclaimer.
  //     * Redistributions in binary form must reproduce the above
  // copyright notice, this list of conditions and the following disclaimer
  // in the documentation and/or other materials provided with the
  // distribution.
  //     * Neither the name of Google Inc. nor the names of its
  // contributors may be used to endorse or promote products derived from
  // this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  //
  // The Google C++ Testing and Mocking Framework (Google Test)
  //
  // This header file defines the Message class.
  //
  // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
  // leave some internal implementation details in this header file.
  // They are clearly marked by comments like this:
  //
  //   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
  //
  // Such code is NOT meant to be used by a user directly, and is subject
  // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
  // program!
  
  // GOOGLETEST_CM0001 DO NOT DELETE
  
  #ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
  #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
  
  #include <limits>
  #include <memory>
  
  #include "gtest/internal/gtest-port.h"
  
  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
  /* class A needs to have dll-interface to be used by clients of class B */)
  
  // 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 {
  
  // The Message class works like an ostream repeater.
  //
  // Typical usage:
  //
  //   1. You stream a bunch of values to a Message object.
  //      It will remember the text in a stringstream.
  //   2. Then you stream the Message object to an ostream.
  //      This causes the text in the Message to be streamed
  //      to the ostream.
  //
  // For example;
  //
  //   testing::Message foo;
  //   foo << 1 << " != " << 2;
  //   std::cout << foo;
  //
  // will print "1 != 2".
  //
  // Message is not intended to be inherited from.  In particular, its
  // destructor is not virtual.
  //
  // Note that stringstream behaves differently in gcc and in MSVC.  You
  // can stream a NULL char pointer to it in the former, but not in the
  // latter (it causes an access violation if you do).  The Message
  // class hides this difference by treating a NULL char pointer as
  // "(null)".
  class GTEST_API_ Message {
   private:
    // The type of basic IO manipulators (endl, ends, and flush) for
    // narrow streams.
    typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
  
   public:
    // Constructs an empty Message.
    Message();
  
    // Copy constructor.
    Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
      *ss_ << msg.GetString();
    }
  
    // Constructs a Message from a C-string.
    explicit Message(const char* str) : ss_(new ::std::stringstream) {
      *ss_ << str;
    }
  
    // Streams a non-pointer value to this object.
    template <typename T>
    inline Message& operator <<(const T& 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;
    }
  
    // Streams a pointer value to this object.
    //
    // This function is an overload of the previous one.  When you
    // stream a pointer to a Message, this definition will be used as it
    // is more specialized.  (The C++ Standard, section
    // [temp.func.order].)  If you stream a non-pointer, then the
    // previous definition will be used.
    //
    // The reason for this overload is that streaming a NULL pointer to
    // ostream is undefined behavior.  Depending on the compiler, you
    // may get "0", "(nil)", "(null)", or an access violation.  To
    // ensure consistent result across compilers, we always treat NULL
    // as "(null)".
    template <typename T>
    inline Message& operator <<(T* const& pointer) {  // NOLINT
      if (pointer == nullptr) {
        *ss_ << "(null)";
      } else {
        *ss_ << pointer;
      }
      return *this;
    }
  
    // Since the basic IO manipulators are overloaded for both narrow
    // and wide streams, we have to provide this specialized definition
    // of operator <<, even though its body is the same as the
    // templatized version above.  Without this definition, streaming
    // endl or other basic IO manipulators to Message will confuse the
    // compiler.
    Message& operator <<(BasicNarrowIoManip val) {
      *ss_ << val;
      return *this;
    }
  
    // Instead of 1/0, we want to see true/false for bool values.
    Message& operator <<(bool b) {
      return *this << (b ? "true" : "false");
    }
  
    // 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);
    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
    // encoding, and streams the result to this Message object.
    Message& operator <<(const ::std::wstring& wstr);
  #endif  // GTEST_HAS_STD_WSTRING
  
  #if GTEST_HAS_GLOBAL_WSTRING
    // Converts the given wide string to a narrow string using the UTF-8
    // encoding, and streams the result to this Message object.
    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".
    //
    // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
    std::string GetString() const;
  
   private:
    // We'll hold the text streamed to this object here.
    const std::unique_ptr< ::std::stringstream> ss_;
  
    // We declare (but don't implement) this to prevent the compiler
    // from implementing the assignment operator.
    void operator=(const Message&);
  };
  
  // Streams a Message to an ostream.
  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
  
  GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
  
  #endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
  