"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googlemock/src/gmock-internal-utils.cc" between
googletest-release-1.11.0.tar.gz and googletest-release-1.12.0.tar.gz

About: GoogleTest is Google's (unit) testing and mocking framework for C++ tests.

gmock-internal-utils.cc  (googletest-release-1.11.0):gmock-internal-utils.cc  (googletest-release-1.12.0)
skipping to change at line 39 skipping to change at line 39
// Google Mock - a framework for writing C++ mock classes. // Google Mock - a framework for writing C++ mock classes.
// //
// This file defines some utilities useful for implementing Google // This file defines some utilities useful for implementing Google
// Mock. They are subject to change without notice, so please DO NOT // Mock. They are subject to change without notice, so please DO NOT
// USE THEM IN USER CODE. // USE THEM IN USER CODE.
#include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-internal-utils.h"
#include <ctype.h> #include <ctype.h>
#include <array>
#include <cctype>
#include <cstdint>
#include <cstring>
#include <ostream> // NOLINT #include <ostream> // NOLINT
#include <string> #include <string>
#include <vector>
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gmock/internal/gmock-port.h" #include "gmock/internal/gmock-port.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
namespace testing { namespace testing {
namespace internal { namespace internal {
// Joins a vector of strings as if they are fields of a tuple; returns // Joins a vector of strings as if they are fields of a tuple; returns
// the joined string. // the joined string.
GTEST_API_ std::string JoinAsTuple(const Strings& fields) { GTEST_API_ std::string JoinAsKeyValueTuple(
switch (fields.size()) { const std::vector<const char*>& names, const Strings& values) {
case 0: GTEST_CHECK_(names.size() == values.size());
return ""; if (values.empty()) {
case 1: return "";
return fields[0]; }
default: const auto build_one = [&](const size_t i) {
std::string result = "(" + fields[0]; return std::string(names[i]) + ": " + values[i];
for (size_t i = 1; i < fields.size(); i++) { };
result += ", "; std::string result = "(" + build_one(0);
result += fields[i]; for (size_t i = 1; i < values.size(); i++) {
} result += ", ";
result += ")"; result += build_one(i);
return result;
} }
result += ")";
return result;
} }
// Converts an identifier name to a space-separated list of lower-case // Converts an identifier name to a space-separated list of lower-case
// words. Each maximum substring of the form [A-Za-z][a-z]*|\d+ is // words. Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
// treated as one word. For example, both "FooBar123" and // treated as one word. For example, both "FooBar123" and
// "foo_bar_123" are converted to "foo bar 123". // "foo_bar_123" are converted to "foo bar 123".
GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) { GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
std::string result; std::string result;
char prev_char = '\0'; char prev_char = '\0';
for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) { for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
// We don't care about the current locale as the input is // We don't care about the current locale as the input is
// guaranteed to be a valid C++ identifier name. // guaranteed to be a valid C++ identifier name.
const bool starts_new_word = IsUpper(*p) || const bool starts_new_word = IsUpper(*p) ||
(!IsAlpha(prev_char) && IsLower(*p)) || (!IsAlpha(prev_char) && IsLower(*p)) ||
(!IsDigit(prev_char) && IsDigit(*p)); (!IsDigit(prev_char) && IsDigit(*p));
if (IsAlNum(*p)) { if (IsAlNum(*p)) {
if (starts_new_word && result != "") if (starts_new_word && result != "") result += ' ';
result += ' ';
result += ToLower(*p); result += ToLower(*p);
} }
} }
return result; return result;
} }
// This class reports Google Mock failures as Google Test failures. A // This class reports Google Mock failures as Google Test failures. A
// user can define another class in a similar fashion if they intend to // user can define another class in a similar fashion if they intend to
// use Google Mock with a testing framework other than Google Test. // use Google Mock with a testing framework other than Google Test.
class GoogleTestFailureReporter : public FailureReporterInterface { class GoogleTestFailureReporter : public FailureReporterInterface {
public: public:
void ReportFailure(FailureType type, const char* file, int line, void ReportFailure(FailureType type, const char* file, int line,
const std::string& message) override { const std::string& message) override {
AssertHelper(type == kFatal ? AssertHelper(type == kFatal ? TestPartResult::kFatalFailure
TestPartResult::kFatalFailure : : TestPartResult::kNonFatalFailure,
TestPartResult::kNonFatalFailure, file, line, message.c_str()) = Message();
file,
line,
message.c_str()) = Message();
if (type == kFatal) { if (type == kFatal) {
posix::Abort(); posix::Abort();
} }
} }
}; };
// Returns the global failure reporter. Will create a // Returns the global failure reporter. Will create a
// GoogleTestFailureReporter and return it the first time called. // GoogleTestFailureReporter and return it the first time called.
GTEST_API_ FailureReporterInterface* GetFailureReporter() { GTEST_API_ FailureReporterInterface* GetFailureReporter() {
// Points to the global failure reporter used by Google Mock. gcc // Points to the global failure reporter used by Google Mock. gcc
skipping to change at line 128 skipping to change at line 132
new GoogleTestFailureReporter(); new GoogleTestFailureReporter();
return failure_reporter; return failure_reporter;
} }
// Protects global resources (stdout in particular) used by Log(). // Protects global resources (stdout in particular) used by Log().
static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex); static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
// Returns true if and only if a log with the given severity is visible // Returns true if and only if a log with the given severity is visible
// according to the --gmock_verbose flag. // according to the --gmock_verbose flag.
GTEST_API_ bool LogIsVisible(LogSeverity severity) { GTEST_API_ bool LogIsVisible(LogSeverity severity) {
if (GMOCK_FLAG(verbose) == kInfoVerbosity) { if (GMOCK_FLAG_GET(verbose) == kInfoVerbosity) {
// Always show the log if --gmock_verbose=info. // Always show the log if --gmock_verbose=info.
return true; return true;
} else if (GMOCK_FLAG(verbose) == kErrorVerbosity) { } else if (GMOCK_FLAG_GET(verbose) == kErrorVerbosity) {
// Always hide it if --gmock_verbose=error. // Always hide it if --gmock_verbose=error.
return false; return false;
} else { } else {
// If --gmock_verbose is neither "info" nor "error", we treat it // If --gmock_verbose is neither "info" nor "error", we treat it
// as "warning" (its default value). // as "warning" (its default value).
return severity == kWarning; return severity == kWarning;
} }
} }
// Prints the given message to stdout if and only if 'severity' >= the level // Prints the given message to stdout if and only if 'severity' >= the level
// specified by the --gmock_verbose flag. If stack_frames_to_skip >= // specified by the --gmock_verbose flag. If stack_frames_to_skip >=
// 0, also prints the stack trace excluding the top // 0, also prints the stack trace excluding the top
// stack_frames_to_skip frames. In opt mode, any positive // stack_frames_to_skip frames. In opt mode, any positive
// stack_frames_to_skip is treated as 0, since we don't know which // stack_frames_to_skip is treated as 0, since we don't know which
// function calls will be inlined by the compiler and need to be // function calls will be inlined by the compiler and need to be
// conservative. // conservative.
GTEST_API_ void Log(LogSeverity severity, const std::string& message, GTEST_API_ void Log(LogSeverity severity, const std::string& message,
int stack_frames_to_skip) { int stack_frames_to_skip) {
if (!LogIsVisible(severity)) if (!LogIsVisible(severity)) return;
return;
// Ensures that logs from different threads don't interleave. // Ensures that logs from different threads don't interleave.
MutexLock l(&g_log_mutex); MutexLock l(&g_log_mutex);
if (severity == kWarning) { if (severity == kWarning) {
// Prints a GMOCK WARNING marker to make the warnings easily searchable. // Prints a GMOCK WARNING marker to make the warnings easily searchable.
std::cout << "\nGMOCK WARNING:"; std::cout << "\nGMOCK WARNING:";
} }
// Pre-pends a new-line to message if it doesn't start with one. // Pre-pends a new-line to message if it doesn't start with one.
if (message.empty() || message[0] != '\n') { if (message.empty() || message[0] != '\n') {
skipping to change at line 180 skipping to change at line 183
// In dbg mode, we can do what the caller tell us to do (plus one // In dbg mode, we can do what the caller tell us to do (plus one
// for skipping this function's stack frame). // for skipping this function's stack frame).
const int actual_to_skip = stack_frames_to_skip + 1; const int actual_to_skip = stack_frames_to_skip + 1;
#endif // NDEBUG #endif // NDEBUG
// Appends a new-line to message if it doesn't end with one. // Appends a new-line to message if it doesn't end with one.
if (!message.empty() && *message.rbegin() != '\n') { if (!message.empty() && *message.rbegin() != '\n') {
std::cout << "\n"; std::cout << "\n";
} }
std::cout << "Stack trace:\n" std::cout << "Stack trace:\n"
<< ::testing::internal::GetCurrentOsStackTraceExceptTop( << ::testing::internal::GetCurrentOsStackTraceExceptTop(
::testing::UnitTest::GetInstance(), actual_to_skip); ::testing::UnitTest::GetInstance(), actual_to_skip);
} }
std::cout << ::std::flush; std::cout << ::std::flush;
} }
GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); } GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); }
GTEST_API_ void IllegalDoDefault(const char* file, int line) { GTEST_API_ void IllegalDoDefault(const char* file, int line) {
internal::Assert( internal::Assert(
false, file, line, false, file, line,
"You are using DoDefault() inside a composite action like " "You are using DoDefault() inside a composite action like "
"DoAll() or WithArgs(). This is not supported for technical " "DoAll() or WithArgs(). This is not supported for technical "
"reasons. Please instead spell out the default action, or " "reasons. Please instead spell out the default action, or "
"assign the default action to an Action variable and use " "assign the default action to an Action variable and use "
"the variable in various places."); "the variable in various places.");
} }
constexpr char UnBase64Impl(char c, const char* const base64, char carry) {
return *base64 == 0 ? static_cast<char>(65)
: *base64 == c ? carry
: UnBase64Impl(c, base64 + 1, carry + 1);
}
template <size_t... I>
constexpr std::array<char, 256> UnBase64Impl(IndexSequence<I...>,
const char* const base64) {
return {{UnBase64Impl(static_cast<char>(I), base64, 0)...}};
}
constexpr std::array<char, 256> UnBase64(const char* const base64) {
return UnBase64Impl(MakeIndexSequence<256>{}, base64);
}
static constexpr char kBase64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static constexpr std::array<char, 256> kUnBase64 = UnBase64(kBase64);
bool Base64Unescape(const std::string& encoded, std::string* decoded) {
decoded->clear();
size_t encoded_len = encoded.size();
decoded->reserve(3 * (encoded_len / 4) + (encoded_len % 4));
int bit_pos = 0;
char dst = 0;
for (int src : encoded) {
if (std::isspace(src) || src == '=') {
continue;
}
char src_bin = kUnBase64[static_cast<size_t>(src)];
if (src_bin >= 64) {
decoded->clear();
return false;
}
if (bit_pos == 0) {
dst |= static_cast<char>(src_bin << 2);
bit_pos = 6;
} else {
dst |= static_cast<char>(src_bin >> (bit_pos - 2));
decoded->push_back(dst);
dst = static_cast<char>(src_bin << (10 - bit_pos));
bit_pos = (bit_pos + 6) % 8;
}
}
return true;
}
} // namespace internal } // namespace internal
} // namespace testing } // namespace testing
 End of changes. 12 change blocks. 
30 lines changed or deleted 81 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)