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

// IWYU pragma: private, include "gtest/gtest.h"

// IWYU pragma: friend gtest/.*

// IWYU pragma: friend gmock/.*

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

#define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

#include <limits>

#include <memory>

#include <ostream>

#include <sstream>

#include <string>

#include "gtest/internal/gtest-port.h"

#ifdef GTEST_HAS_ABSL

#include <type_traits>

#include "absl/strings/has_absl_stringify.h"

#include "absl/strings/str_cat.h"

#endif  // GTEST_HAS_ABSL

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. If building a version of

  // GoogleTest with ABSL, this overload is only enabled if the value does not

  // have an AbslStringify definition.

  template <

      typename T

#ifdef GTEST_HAS_ABSL

      ,

      typename std::enable_if<!absl::HasAbslStringify<T>::value,  // NOLINT

                              int>::type = 0

#endif  // GTEST_HAS_ABSL

      >

  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;

  }

Unexecuted instantiation: testing::Message& testing::Message::operator<< <char [34]>(char const (&) [34])

Unexecuted instantiation: testing::Message& testing::Message::operator<< <std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)

Unexecuted instantiation: testing::Message& testing::Message::operator<< <char [63]>(char const (&) [63])

Unexecuted instantiation: testing::Message& testing::Message::operator<< <char [25]>(char const (&) [25])

#ifdef GTEST_HAS_ABSL

  // Streams a non-pointer value with an AbslStringify definition to this

  // object.

  template <typename T,

            typename std::enable_if<absl::HasAbslStringify<T>::value,  // NOLINT

                                    int>::type = 0>

  inline Message& operator<<(const T& val) {

    // ::operator<< is needed here for a similar reason as with the non-Abseil

    // version above

    using ::operator<<;

    *ss_ << absl::StrCat(val);

    return *this;

  }

#endif  // GTEST_HAS_ABSL

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

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