Subversion Repositories Kolibri OS

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

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

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

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.

  // 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::digits10 + 2);

  }

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

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

    StreamHelper(typename internal::is_pointer::type(), value);

    return *this;

  }

#else

  // Streams a non-pointer value to this object.

  template 

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

    ::GTestStreamToHelper(ss_.get(), 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 

  inline Message& operator <<(T* const& pointer) {  // NOLINT

    if (pointer == NULL) {

      *ss_ << "(null)";

    } else {

      ::GTestStreamToHelper(ss_.get(), 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) {

    return *this << internal::String::ShowWideCString(wide_c_str);

  }

  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.

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

  }

 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 

  inline void StreamHelper(internal::true_type /*dummy*/, T* pointer) {

    if (pointer == NULL) {

      *ss_ << "(null)";

    } else {

      ::GTestStreamToHelper(ss_.get(), pointer);

    }

  }

  template 

  inline void StreamHelper(internal::false_type /*dummy*/, const T& value) {

    ::GTestStreamToHelper(ss_.get(), 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 testing

#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_