351 lines
13 KiB
C
351 lines
13 KiB
C
|
// 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.
|
||
|
|
//
|
||
|
|
// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
|
||
|
|
//
|
||
|
|
// The Google C++ Testing Framework (Google Test)
|
||
|
|
//
|
||
|
|
// This header file declares the String class and functions used internally by
|
||
|
|
// Google Test. They are subject to change without notice. They should not used
|
||
|
|
// by code external to Google Test.
|
||
|
|
//
|
||
|
|
// This header file is #included by <gtest/internal/gtest-internal.h>.
|
||
|
|
// It should not be #included by other files.
|
||
|
|
|
||
|
|
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
|
||
|
|
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
|
||
|
|
|
||
|
|
#ifdef __BORLANDC__
|
||
|
|
// string.h is not guaranteed to provide strcpy on C++ Builder.
|
||
|
|
# include <mem.h>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
#include "gtest/internal/gtest-port.h"
|
||
|
|
|
||
|
|
#include <string>
|
||
|
|
|
||
|
|
namespace testing {
|
||
|
|
namespace internal {
|
||
|
|
|
||
|
|
// String - a UTF-8 string class.
|
||
|
|
//
|
||
|
|
// For historic reasons, we don't use std::string.
|
||
|
|
//
|
||
|
|
// TODO(wan@google.com): replace this class with std::string or
|
||
|
|
// implement it in terms of the latter.
|
||
|
|
//
|
||
|
|
// Note that String can represent both NULL and the empty string,
|
||
|
|
// while std::string cannot represent NULL.
|
||
|
|
//
|
||
|
|
// NULL and the empty string are considered different. NULL is less
|
||
|
|
// than anything (including the empty string) except itself.
|
||
|
|
//
|
||
|
|
// This class only provides minimum functionality necessary for
|
||
|
|
// implementing Google Test. We do not intend to implement a full-fledged
|
||
|
|
// string class here.
|
||
|
|
//
|
||
|
|
// Since the purpose of this class is to provide a substitute for
|
||
|
|
// std::string on platforms where it cannot be used, we define a copy
|
||
|
|
// constructor and assignment operators such that we don't need
|
||
|
|
// conditional compilation in a lot of places.
|
||
|
|
//
|
||
|
|
// In order to make the representation efficient, the d'tor of String
|
||
|
|
// is not virtual. Therefore DO NOT INHERIT FROM String.
|
||
|
|
class GTEST_API_ String {
|
||
|
|
public:
|
||
|
|
// Static utility methods
|
||
|
|
|
||
|
|
// Returns the input enclosed in double quotes if it's not NULL;
|
||
|
|
// otherwise returns "(null)". For example, "\"Hello\"" is returned
|
||
|
|
// for input "Hello".
|
||
|
|
//
|
||
|
|
// This is useful for printing a C string in the syntax of a literal.
|
||
|
|
//
|
||
|
|
// Known issue: escape sequences are not handled yet.
|
||
|
|
static String ShowCStringQuoted(const char* c_str);
|
||
|
|
|
||
|
|
// Clones a 0-terminated C string, allocating memory using new. The
|
||
|
|
// caller is responsible for deleting the return value using
|
||
|
|
// delete[]. Returns the cloned string, or NULL if the input is
|
||
|
|
// NULL.
|
||
|
|
//
|
||
|
|
// This is different from strdup() in string.h, which allocates
|
||
|
|
// memory using malloc().
|
||
|
|
static const char* CloneCString(const char* c_str);
|
||
|
|
|
||
|
|
#if GTEST_OS_WINDOWS_MOBILE
|
||
|
|
// Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
|
||
|
|
// able to pass strings to Win32 APIs on CE we need to convert them
|
||
|
|
// to 'Unicode', UTF-16.
|
||
|
|
|
||
|
|
// Creates a UTF-16 wide string from the given ANSI string, allocating
|
||
|
|
// memory using new. The caller is responsible for deleting the return
|
||
|
|
// value using delete[]. Returns the wide string, or NULL if the
|
||
|
|
// input is NULL.
|
||
|
|
//
|
||
|
|
// The wide string is created using the ANSI codepage (CP_ACP) to
|
||
|
|
// match the behaviour of the ANSI versions of Win32 calls and the
|
||
|
|
// C runtime.
|
||
|
|
static LPCWSTR AnsiToUtf16(const char* c_str);
|
||
|
|
|
||
|
|
// Creates an ANSI string from the given wide string, allocating
|
||
|
|
// memory using new. The caller is responsible for deleting the return
|
||
|
|
// value using delete[]. Returns the ANSI string, or NULL if the
|
||
|
|
// input is NULL.
|
||
|
|
//
|
||
|
|
// The returned string is created using the ANSI codepage (CP_ACP) to
|
||
|
|
// match the behaviour of the ANSI versions of Win32 calls and the
|
||
|
|
// C runtime.
|
||
|
|
static const char* Utf16ToAnsi(LPCWSTR utf16_str);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Compares two C strings. Returns true iff they have the same content.
|
||
|
|
//
|
||
|
|
// Unlike strcmp(), this function can handle NULL argument(s). A
|
||
|
|
// NULL C string is considered different to any non-NULL C string,
|
||
|
|
// including the empty string.
|
||
|
|
static bool CStringEquals(const char* lhs, const char* rhs);
|
||
|
|
|
||
|
|
// Converts a wide C string to a String using the UTF-8 encoding.
|
||
|
|
// NULL will be converted to "(null)". If an error occurred during
|
||
|
|
// the conversion, "(failed to convert from wide string)" is
|
||
|
|
// returned.
|
||
|
|
static String ShowWideCString(const wchar_t* wide_c_str);
|
||
|
|
|
||
|
|
// Similar to ShowWideCString(), except that this function encloses
|
||
|
|
// the converted string in double quotes.
|
||
|
|
static String ShowWideCStringQuoted(const wchar_t* wide_c_str);
|
||
|
|
|
||
|
|
// Compares two wide C strings. Returns true iff they have the same
|
||
|
|
// content.
|
||
|
|
//
|
||
|
|
// Unlike wcscmp(), this function can handle NULL argument(s). A
|
||
|
|
// NULL C string is considered different to any non-NULL C string,
|
||
|
|
// including the empty string.
|
||
|
|
static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
|
||
|
|
|
||
|
|
// Compares two C strings, ignoring case. Returns true iff they
|
||
|
|
// have the same content.
|
||
|
|
//
|
||
|
|
// Unlike strcasecmp(), this function can handle NULL argument(s).
|
||
|
|
// A NULL C string is considered different to any non-NULL C string,
|
||
|
|
// including the empty string.
|
||
|
|
static bool CaseInsensitiveCStringEquals(const char* lhs,
|
||
|
|
const char* rhs);
|
||
|
|
|
||
|
|
// Compares two wide C strings, ignoring case. Returns true iff they
|
||
|
|
// have the same content.
|
||
|
|
//
|
||
|
|
// Unlike wcscasecmp(), this function can handle NULL argument(s).
|
||
|
|
// A NULL C string is considered different to any non-NULL wide C string,
|
||
|
|
// including the empty string.
|
||
|
|
// NB: The implementations on different platforms slightly differ.
|
||
|
|
// On windows, this method uses _wcsicmp which compares according to LC_CTYPE
|
||
|
|
// environment variable. On GNU platform this method uses wcscasecmp
|
||
|
|
// which compares according to LC_CTYPE category of the current locale.
|
||
|
|
// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
|
||
|
|
// current locale.
|
||
|
|
static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
|
||
|
|
const wchar_t* rhs);
|
||
|
|
|
||
|
|
// Formats a list of arguments to a String, using the same format
|
||
|
|
// spec string as for printf.
|
||
|
|
//
|
||
|
|
// We do not use the StringPrintf class as it is not universally
|
||
|
|
// available.
|
||
|
|
//
|
||
|
|
// The result is limited to 4096 characters (including the tailing
|
||
|
|
// 0). If 4096 characters are not enough to format the input,
|
||
|
|
// "<buffer exceeded>" is returned.
|
||
|
|
static String Format(const char* format, ...);
|
||
|
|
|
||
|
|
// C'tors
|
||
|
|
|
||
|
|
// The default c'tor constructs a NULL string.
|
||
|
|
String() : c_str_(NULL), length_(0) {}
|
||
|
|
|
||
|
|
// Constructs a String by cloning a 0-terminated C string.
|
||
|
|
String(const char* a_c_str) { // NOLINT
|
||
|
|
if (a_c_str == NULL) {
|
||
|
|
c_str_ = NULL;
|
||
|
|
length_ = 0;
|
||
|
|
} else {
|
||
|
|
ConstructNonNull(a_c_str, strlen(a_c_str));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Constructs a String by copying a given number of chars from a
|
||
|
|
// buffer. E.g. String("hello", 3) creates the string "hel",
|
||
|
|
// String("a\0bcd", 4) creates "a\0bc", String(NULL, 0) creates "",
|
||
|
|
// and String(NULL, 1) results in access violation.
|
||
|
|
String(const char* buffer, size_t a_length) {
|
||
|
|
ConstructNonNull(buffer, a_length);
|
||
|
|
}
|
||
|
|
|
||
|
|
// The copy c'tor creates a new copy of the string. The two
|
||
|
|
// String objects do not share content.
|
||
|
|
String(const String& str) : c_str_(NULL), length_(0) { *this = str; }
|
||
|
|
|
||
|
|
// D'tor. String is intended to be a final class, so the d'tor
|
||
|
|
// doesn't need to be virtual.
|
||
|
|
~String() { delete[] c_str_; }
|
||
|
|
|
||
|
|
// Allows a String to be implicitly converted to an ::std::string or
|
||
|
|
// ::string, and vice versa. Converting a String containing a NULL
|
||
|
|
// pointer to ::std::string or ::string is undefined behavior.
|
||
|
|
// Converting a ::std::string or ::string containing an embedded NUL
|
||
|
|
// character to a String will result in the prefix up to the first
|
||
|
|
// NUL character.
|
||
|
|
String(const ::std::string& str) {
|
||
|
|
ConstructNonNull(str.c_str(), str.length());
|
||
|
|
}
|
||
|
|
|
||
|
|
operator ::std::string() const { return ::std::string(c_str(), length()); }
|
||
|
|
|
||
|
|
#if GTEST_HAS_GLOBAL_STRING
|
||
|
|
String(const ::string& str) {
|
||
|
|
ConstructNonNull(str.c_str(), str.length());
|
||
|
|
}
|
||
|
|
|
||
|
|
operator ::string() const { return ::string(c_str(), length()); }
|
||
|
|
#endif // GTEST_HAS_GLOBAL_STRING
|
||
|
|
|
||
|
|
// Returns true iff this is an empty string (i.e. "").
|
||
|
|
bool empty() const { return (c_str() != NULL) && (length() == 0); }
|
||
|
|
|
||
|
|
// Compares this with another String.
|
||
|
|
// Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
|
||
|
|
// if this is greater than rhs.
|
||
|
|
int Compare(const String& rhs) const;
|
||
|
|
|
||
|
|
// Returns true iff this String equals the given C string. A NULL
|
||
|
|
// string and a non-NULL string are considered not equal.
|
||
|
|
bool operator==(const char* a_c_str) const { return Compare(a_c_str) == 0; }
|
||
|
|
|
||
|
|
// Returns true iff this String is less than the given String. A
|
||
|
|
// NULL string is considered less than "".
|
||
|
|
bool operator<(const String& rhs) const { return Compare(rhs) < 0; }
|
||
|
|
|
||
|
|
// Returns true iff this String doesn't equal the given C string. A NULL
|
||
|
|
// string and a non-NULL string are considered not equal.
|
||
|
|
bool operator!=(const char* a_c_str) const { return !(*this == a_c_str); }
|
||
|
|
|
||
|
|
// Returns true iff this String ends with the given suffix. *Any*
|
||
|
|
// String is considered to end with a NULL or empty suffix.
|
||
|
|
bool EndsWith(const char* suffix) const;
|
||
|
|
|
||
|
|
// Returns true iff this String ends with the given suffix, not considering
|
||
|
|
// case. Any String is considered to end with a NULL or empty suffix.
|
||
|
|
bool EndsWithCaseInsensitive(const char* suffix) const;
|
||
|
|
|
||
|
|
// Returns the length of the encapsulated string, or 0 if the
|
||
|
|
// string is NULL.
|
||
|
|
size_t length() const { return length_; }
|
||
|
|
|
||
|
|
// Gets the 0-terminated C string this String object represents.
|
||
|
|
// The String object still owns the string. Therefore the caller
|
||
|
|
// should NOT delete the return value.
|
||
|
|
const char* c_str() const { return c_str_; }
|
||
|
|
|
||
|
|
// Assigns a C string to this object. Self-assignment works.
|
||
|
|
const String& operator=(const char* a_c_str) {
|
||
|
|
return *this = String(a_c_str);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Assigns a String object to this object. Self-assignment works.
|
||
|
|
const String& operator=(const String& rhs) {
|
||
|
|
if (this != &rhs) {
|
||
|
|
delete[] c_str_;
|
||
|
|
if (rhs.c_str() == NULL) {
|
||
|
|
c_str_ = NULL;
|
||
|
|
length_ = 0;
|
||
|
|
} else {
|
||
|
|
ConstructNonNull(rhs.c_str(), rhs.length());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
// Constructs a non-NULL String from the given content. This
|
||
|
|
// function can only be called when c_str_ has not been allocated.
|
||
|
|
// ConstructNonNull(NULL, 0) results in an empty string ("").
|
||
|
|
// ConstructNonNull(NULL, non_zero) is undefined behavior.
|
||
|
|
void ConstructNonNull(const char* buffer, size_t a_length) {
|
||
|
|
char* const str = new char[a_length + 1];
|
||
|
|
memcpy(str, buffer, a_length);
|
||
|
|
str[a_length] = '\0';
|
||
|
|
c_str_ = str;
|
||
|
|
length_ = a_length;
|
||
|
|
}
|
||
|
|
|
||
|
|
const char* c_str_;
|
||
|
|
size_t length_;
|
||
|
|
}; // class String
|
||
|
|
|
||
|
|
// Streams a String to an ostream. Each '\0' character in the String
|
||
|
|
// is replaced with "\\0".
|
||
|
|
inline ::std::ostream& operator<<(::std::ostream& os, const String& str) {
|
||
|
|
if (str.c_str() == NULL) {
|
||
|
|
os << "(null)";
|
||
|
|
} else {
|
||
|
|
const char* const c_str = str.c_str();
|
||
|
|
for (size_t i = 0; i != str.length(); i++) {
|
||
|
|
if (c_str[i] == '\0') {
|
||
|
|
os << "\\0";
|
||
|
|
} else {
|
||
|
|
os << c_str[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return os;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Gets the content of the stringstream's buffer as a String. Each '\0'
|
||
|
|
// character in the buffer is replaced with "\\0".
|
||
|
|
GTEST_API_ String StringStreamToString(::std::stringstream* stream);
|
||
|
|
|
||
|
|
// Converts a streamable value to a 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".
|
||
|
|
|
||
|
|
// Declared here but defined in gtest.h, so that it has access
|
||
|
|
// to the definition of the Message class, required by the ARM
|
||
|
|
// compiler.
|
||
|
|
template <typename T>
|
||
|
|
String StreamableToString(const T& streamable);
|
||
|
|
|
||
|
|
} // namespace internal
|
||
|
|
} // namespace testing
|
||
|
|
|
||
|
|
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
|