PageRenderTime 79ms CodeModel.GetById 65ms app.highlight 10ms RepoModel.GetById 2ms app.codeStats 0ms

/testlibs/gtest/include/gtest/gtest-message.h

https://github.com/deltaforge/nebu-common-cpp
C Header | 230 lines | 86 code | 23 blank | 121 comment | 6 complexity | 00a18462616ae62be7f81c1588c95a9f MD5 | raw file
  1// Copyright 2005, Google Inc.
  2// All rights reserved.
  3//
  4// Redistribution and use in source and binary forms, with or without
  5// modification, are permitted provided that the following conditions are
  6// met:
  7//
  8//     * Redistributions of source code must retain the above copyright
  9// notice, this list of conditions and the following disclaimer.
 10//     * Redistributions in binary form must reproduce the above
 11// copyright notice, this list of conditions and the following disclaimer
 12// in the documentation and/or other materials provided with the
 13// distribution.
 14//     * Neither the name of Google Inc. nor the names of its
 15// contributors may be used to endorse or promote products derived from
 16// this software without specific prior written permission.
 17//
 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 29//
 30// Author: wan@google.com (Zhanyong Wan)
 31//
 32// The Google C++ Testing Framework (Google Test)
 33//
 34// This header file defines the Message class.
 35//
 36// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
 37// leave some internal implementation details in this header file.
 38// They are clearly marked by comments like this:
 39//
 40//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 41//
 42// Such code is NOT meant to be used by a user directly, and is subject
 43// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
 44// program!
 45
 46#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
 47#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
 48
 49#include <limits>
 50
 51#include "gtest/internal/gtest-string.h"
 52#include "gtest/internal/gtest-internal.h"
 53
 54namespace testing {
 55
 56// The Message class works like an ostream repeater.
 57//
 58// Typical usage:
 59//
 60//   1. You stream a bunch of values to a Message object.
 61//      It will remember the text in a stringstream.
 62//   2. Then you stream the Message object to an ostream.
 63//      This causes the text in the Message to be streamed
 64//      to the ostream.
 65//
 66// For example;
 67//
 68//   testing::Message foo;
 69//   foo << 1 << " != " << 2;
 70//   std::cout << foo;
 71//
 72// will print "1 != 2".
 73//
 74// Message is not intended to be inherited from.  In particular, its
 75// destructor is not virtual.
 76//
 77// Note that stringstream behaves differently in gcc and in MSVC.  You
 78// can stream a NULL char pointer to it in the former, but not in the
 79// latter (it causes an access violation if you do).  The Message
 80// class hides this difference by treating a NULL char pointer as
 81// "(null)".
 82class GTEST_API_ Message {
 83 private:
 84  // The type of basic IO manipulators (endl, ends, and flush) for
 85  // narrow streams.
 86  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
 87
 88 public:
 89  // Constructs an empty Message.
 90  // We allocate the stringstream separately because otherwise each use of
 91  // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
 92  // stack frame leading to huge stack frames in some cases; gcc does not reuse
 93  // the stack space.
 94  Message() : ss_(new ::std::stringstream) {
 95    // By default, we want there to be enough precision when printing
 96    // a double to a Message.
 97    *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
 98  }
 99
100  // Copy constructor.
101  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
102    *ss_ << msg.GetString();
103  }
104
105  // Constructs a Message from a C-string.
106  explicit Message(const char* str) : ss_(new ::std::stringstream) {
107    *ss_ << str;
108  }
109
110#if GTEST_OS_SYMBIAN
111  // Streams a value (either a pointer or not) to this object.
112  template <typename T>
113  inline Message& operator <<(const T& value) {
114    StreamHelper(typename internal::is_pointer<T>::type(), value);
115    return *this;
116  }
117#else
118  // Streams a non-pointer value to this object.
119  template <typename T>
120  inline Message& operator <<(const T& val) {
121    ::GTestStreamToHelper(ss_.get(), val);
122    return *this;
123  }
124
125  // Streams a pointer value to this object.
126  //
127  // This function is an overload of the previous one.  When you
128  // stream a pointer to a Message, this definition will be used as it
129  // is more specialized.  (The C++ Standard, section
130  // [temp.func.order].)  If you stream a non-pointer, then the
131  // previous definition will be used.
132  //
133  // The reason for this overload is that streaming a NULL pointer to
134  // ostream is undefined behavior.  Depending on the compiler, you
135  // may get "0", "(nil)", "(null)", or an access violation.  To
136  // ensure consistent result across compilers, we always treat NULL
137  // as "(null)".
138  template <typename T>
139  inline Message& operator <<(T* const& pointer) {  // NOLINT
140    if (pointer == NULL) {
141      *ss_ << "(null)";
142    } else {
143      ::GTestStreamToHelper(ss_.get(), pointer);
144    }
145    return *this;
146  }
147#endif  // GTEST_OS_SYMBIAN
148
149  // Since the basic IO manipulators are overloaded for both narrow
150  // and wide streams, we have to provide this specialized definition
151  // of operator <<, even though its body is the same as the
152  // templatized version above.  Without this definition, streaming
153  // endl or other basic IO manipulators to Message will confuse the
154  // compiler.
155  Message& operator <<(BasicNarrowIoManip val) {
156    *ss_ << val;
157    return *this;
158  }
159
160  // Instead of 1/0, we want to see true/false for bool values.
161  Message& operator <<(bool b) {
162    return *this << (b ? "true" : "false");
163  }
164
165  // These two overloads allow streaming a wide C string to a Message
166  // using the UTF-8 encoding.
167  Message& operator <<(const wchar_t* wide_c_str) {
168    return *this << internal::String::ShowWideCString(wide_c_str);
169  }
170  Message& operator <<(wchar_t* wide_c_str) {
171    return *this << internal::String::ShowWideCString(wide_c_str);
172  }
173
174#if GTEST_HAS_STD_WSTRING
175  // Converts the given wide string to a narrow string using the UTF-8
176  // encoding, and streams the result to this Message object.
177  Message& operator <<(const ::std::wstring& wstr);
178#endif  // GTEST_HAS_STD_WSTRING
179
180#if GTEST_HAS_GLOBAL_WSTRING
181  // Converts the given wide string to a narrow string using the UTF-8
182  // encoding, and streams the result to this Message object.
183  Message& operator <<(const ::wstring& wstr);
184#endif  // GTEST_HAS_GLOBAL_WSTRING
185
186  // Gets the text streamed to this object so far as a String.
187  // Each '\0' character in the buffer is replaced with "\\0".
188  //
189  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
190  internal::String GetString() const {
191    return internal::StringStreamToString(ss_.get());
192  }
193
194 private:
195
196#if GTEST_OS_SYMBIAN
197  // These are needed as the Nokia Symbian Compiler cannot decide between
198  // const T& and const T* in a function template. The Nokia compiler _can_
199  // decide between class template specializations for T and T*, so a
200  // tr1::type_traits-like is_pointer works, and we can overload on that.
201  template <typename T>
202  inline void StreamHelper(internal::true_type /*dummy*/, T* pointer) {
203    if (pointer == NULL) {
204      *ss_ << "(null)";
205    } else {
206      ::GTestStreamToHelper(ss_.get(), pointer);
207    }
208  }
209  template <typename T>
210  inline void StreamHelper(internal::false_type /*dummy*/, const T& value) {
211    ::GTestStreamToHelper(ss_.get(), value);
212  }
213#endif  // GTEST_OS_SYMBIAN
214
215  // We'll hold the text streamed to this object here.
216  const internal::scoped_ptr< ::std::stringstream> ss_;
217
218  // We declare (but don't implement) this to prevent the compiler
219  // from implementing the assignment operator.
220  void operator=(const Message&);
221};
222
223// Streams a Message to an ostream.
224inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
225  return os << sb.GetString();
226}
227
228}  // namespace testing
229
230#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_