Line endings fix?

1 files changed, 230 insertions, 230 deletions

diff --git a/gtest-1.6.0/include/gtest/gtest-message.h b/gtest-1.6.0/include/gtest/gtest-message.h
index a4d7bbf..9b7142f 100644
--- a/gtest-1.6.0/include/gtest/gtest-message.h
+++ b/gtest-1.6.0/include/gtest/gtest-message.h
@@ -1,230 +1,230 @@
-// 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-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<double>::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 <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) {

-    ::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 <typename T>

-  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 <typename T>

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

-    if (pointer == NULL) {

-      *ss_ << "(null)";

-    } else {

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

-    }

-  }

-  template <typename T>

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

+// 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-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<double>::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 <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) {
+    ::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 <typename T>
+  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 <typename T>
+  inline void StreamHelper(internal::true_type /*dummy*/, T* pointer) {
+    if (pointer == NULL) {
+      *ss_ << "(null)";
+    } else {
+      ::GTestStreamToHelper(ss_.get(), pointer);
+    }
+  }
+  template <typename T>
+  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_