is Google's (unit) testing and mocking framework for C++ tests.
| gtest-message.h (googletest-release-1.11.0) | : | gtest-message.h (googletest-release-1.12.0) |
|---|
| | |
| skipping to change at line 30 | | skipping to change at line 30 |
|---|
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| | |
|
| // | | |
| // The Google C++ Testing and Mocking Framework (Google Test) | | // The Google C++ Testing and Mocking Framework (Google Test) |
| // | | // |
| // This header file defines the Message class. | | // This header file defines the Message class. |
| // | | // |
| // IMPORTANT NOTE: Due to limitation of the C++ language, we have to | | // IMPORTANT NOTE: Due to limitation of the C++ language, we have to |
| // leave some internal implementation details in this header file. | | // leave some internal implementation details in this header file. |
| // They are clearly marked by comments like this: | | // They are clearly marked by comments like this: |
| // | | // |
| // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | | // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. |
| // | | // |
| // Such code is NOT meant to be used by a user directly, and is subject | | // 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 | | // to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user |
| // program! | | // program! |
| | |
|
| // GOOGLETEST_CM0001 DO NOT DELETE | | // IWYU pragma: private, include "gtest/gtest.h" |
| | // IWYU pragma: friend gtest/.* |
| | // IWYU pragma: friend gmock/.* |
| | |
| #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ | | #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ |
| #define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ | | #define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ |
| | |
| #include <limits> | | #include <limits> |
| #include <memory> | | #include <memory> |
| #include <sstream> | | #include <sstream> |
| | |
| #include "gtest/internal/gtest-port.h" | | #include "gtest/internal/gtest-port.h" |
| | |
| | |
| skipping to change at line 113 | | skipping to change at line 114 |
|---|
| *ss_ << msg.GetString(); | | *ss_ << msg.GetString(); |
| } | | } |
| | |
| // Constructs a Message from a C-string. | | // Constructs a Message from a C-string. |
| explicit Message(const char* str) : ss_(new ::std::stringstream) { | | explicit Message(const char* str) : ss_(new ::std::stringstream) { |
| *ss_ << str; | | *ss_ << str; |
| } | | } |
| | |
| // Streams a non-pointer value to this object. | | // Streams a non-pointer value to this object. |
| template <typename T> | | template <typename T> |
|
| inline Message& operator <<(const T& val) { | | inline Message& operator<<(const T& val) { |
| // Some libraries overload << for STL containers. These | | // Some libraries overload << for STL containers. These |
| // overloads are defined in the global namespace instead of ::std. | | // overloads are defined in the global namespace instead of ::std. |
| // | | // |
| // C++'s symbol lookup rule (i.e. Koenig lookup) says that these | | // C++'s symbol lookup rule (i.e. Koenig lookup) says that these |
| // overloads are visible in either the std namespace or the global | | // overloads are visible in either the std namespace or the global |
| // namespace, but not other namespaces, including the testing | | // namespace, but not other namespaces, including the testing |
| // namespace which Google Test's Message class is in. | | // namespace which Google Test's Message class is in. |
| // | | // |
| // To allow STL containers (and other types that has a << operator | | // To allow STL containers (and other types that has a << operator |
| // defined in the global namespace) to be used in Google Test | | // defined in the global namespace) to be used in Google Test |
| // assertions, testing::Message must access the custom << operator | | // assertions, testing::Message must access the custom << operator |
| // from the global namespace. With this using declaration, | | // from the global namespace. With this using declaration, |
| // overloads of << defined in the global namespace and those | | // overloads of << defined in the global namespace and those |
| // visible via Koenig lookup are both exposed in this function. | | // visible via Koenig lookup are both exposed in this function. |
|
| using ::operator <<; | | using ::operator<<; |
| *ss_ << val; | | *ss_ << val; |
| return *this; | | return *this; |
| } | | } |
| | |
| // Streams a pointer value to this object. | | // Streams a pointer value to this object. |
| // | | // |
| // This function is an overload of the previous one. When you | | // This function is an overload of the previous one. When you |
| // stream a pointer to a Message, this definition will be used as it | | // stream a pointer to a Message, this definition will be used as it |
| // is more specialized. (The C++ Standard, section | | // is more specialized. (The C++ Standard, section |
| // [temp.func.order].) If you stream a non-pointer, then the | | // [temp.func.order].) If you stream a non-pointer, then the |
| // previous definition will be used. | | // previous definition will be used. |
| // | | // |
| // The reason for this overload is that streaming a NULL pointer to | | // The reason for this overload is that streaming a NULL pointer to |
| // ostream is undefined behavior. Depending on the compiler, you | | // ostream is undefined behavior. Depending on the compiler, you |
| // may get "0", "(nil)", "(null)", or an access violation. To | | // may get "0", "(nil)", "(null)", or an access violation. To |
| // ensure consistent result across compilers, we always treat NULL | | // ensure consistent result across compilers, we always treat NULL |
| // as "(null)". | | // as "(null)". |
| template <typename T> | | template <typename T> |
|
| inline Message& operator <<(T* const& pointer) { // NOLINT | | inline Message& operator<<(T* const& pointer) { // NOLINT |
| if (pointer == nullptr) { | | if (pointer == nullptr) { |
| *ss_ << "(null)"; | | *ss_ << "(null)"; |
| } else { | | } else { |
| *ss_ << pointer; | | *ss_ << pointer; |
| } | | } |
| return *this; | | return *this; |
| } | | } |
| | |
| // Since the basic IO manipulators are overloaded for both narrow | | // Since the basic IO manipulators are overloaded for both narrow |
| // and wide streams, we have to provide this specialized definition | | // and wide streams, we have to provide this specialized definition |
| // of operator <<, even though its body is the same as the | | // of operator <<, even though its body is the same as the |
| // templatized version above. Without this definition, streaming | | // templatized version above. Without this definition, streaming |
| // endl or other basic IO manipulators to Message will confuse the | | // endl or other basic IO manipulators to Message will confuse the |
| // compiler. | | // compiler. |
|
| Message& operator <<(BasicNarrowIoManip val) { | | Message& operator<<(BasicNarrowIoManip val) { |
| *ss_ << val; | | *ss_ << val; |
| return *this; | | return *this; |
| } | | } |
| | |
| // Instead of 1/0, we want to see true/false for bool values. | | // Instead of 1/0, we want to see true/false for bool values. |
|
| Message& operator <<(bool b) { | | Message& operator<<(bool b) { return *this << (b ? "true" : "false"); } |
| return *this << (b ? "true" : "false"); | | |
| } | | |
| | |
| // These two overloads allow streaming a wide C string to a Message | | // These two overloads allow streaming a wide C string to a Message |
| // using the UTF-8 encoding. | | // using the UTF-8 encoding. |
|
| Message& operator <<(const wchar_t* wide_c_str); | | Message& operator<<(const wchar_t* wide_c_str); |
| Message& operator <<(wchar_t* wide_c_str); | | Message& operator<<(wchar_t* wide_c_str); |
| | |
| #if GTEST_HAS_STD_WSTRING | | #if GTEST_HAS_STD_WSTRING |
| // Converts the given wide string to a narrow string using the UTF-8 | | // Converts the given wide string to a narrow string using the UTF-8 |
| // encoding, and streams the result to this Message object. | | // encoding, and streams the result to this Message object. |
|
| Message& operator <<(const ::std::wstring& wstr); | | Message& operator<<(const ::std::wstring& wstr); |
| #endif // GTEST_HAS_STD_WSTRING | | #endif // GTEST_HAS_STD_WSTRING |
| | |
| // Gets the text streamed to this object so far as an std::string. | | // Gets the text streamed to this object so far as an std::string. |
| // Each '\0' character in the buffer is replaced with "\\0". | | // Each '\0' character in the buffer is replaced with "\\0". |
| // | | // |
| // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. | | // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. |
| std::string GetString() const; | | std::string GetString() const; |
| | |
| private: | | private: |
| // We'll hold the text streamed to this object here. | | // We'll hold the text streamed to this object here. |
| const std::unique_ptr< ::std::stringstream> ss_; | | const std::unique_ptr< ::std::stringstream> ss_; |
| | |
| // We declare (but don't implement) this to prevent the compiler | | // We declare (but don't implement) this to prevent the compiler |
| // from implementing the assignment operator. | | // from implementing the assignment operator. |
| void operator=(const Message&); | | void operator=(const Message&); |
| }; | | }; |
| | |
| // Streams a Message to an ostream. | | // Streams a Message to an ostream. |
|
| inline std::ostream& operator <<(std::ostream& os, const Message& sb) { | | inline std::ostream& operator<<(std::ostream& os, const Message& sb) { |
| return os << sb.GetString(); | | return os << sb.GetString(); |
| } | | } |
| | |
| namespace internal { | | namespace internal { |
| | |
| // Converts a streamable value to an std::string. A NULL pointer is | | // Converts a streamable value to an std::string. A NULL pointer is |
| // converted to "(null)". When the input value is a ::string, | | // converted to "(null)". When the input value is a ::string, |
| // ::std::string, ::wstring, or ::std::wstring object, each NUL | | // ::std::string, ::wstring, or ::std::wstring object, each NUL |
| // character in it is replaced with "\\0". | | // character in it is replaced with "\\0". |
| template <typename T> | | template <typename T> |
| | | |
| End of changes. 10 change blocks. |
|---|
| 14 lines changed or deleted | | 13 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 