// Copyright 2005, Google Inc.

// All rights reserved.

//

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

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

// met:

//

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

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

//     * Redistributions in binary form must reproduce the above

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

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

// distribution.

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

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

// this software without specific prior written permission.

//

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

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

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

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

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

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

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

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

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

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

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

//

// Author: wan@google.com (Zhanyong Wan)

//

// The Google C++ Testing 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!

#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

#include <limits>

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

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

  }

#if GTEST_OS_SYMBIAN

  // Streams a value (either a pointer or not) to this object.

  template <typename T>

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

    StreamHelper(typename internal::is_pointer<T>::type(), value);

    return *this;

  }

#else

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

      *ss_ << "(null)";

    } else {

      *ss_ << pointer;

    }

    return *this;

  }

#endif  // GTEST_OS_SYMBIAN

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

#if GTEST_OS_SYMBIAN

  // These are needed as the Nokia Symbian Compiler cannot decide between

  // const T& and const T* in a function template. The Nokia compiler _can_

  // 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 /*is_pointer*/, T* pointer) {

    if (pointer == NULL) {

      *ss_ << "(null)";

    } else {

      *ss_ << pointer;

    }

  }

  template <typename T>

  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

  // We'll hold the text streamed to this object here.

  const internal::scoped_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

#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_